`

spring 手动使用代码注入bean

阅读更多

直接上代码 很简单一看就懂了

 

 

这是我自写的一个与mybatis类似的orm框架与spring集成的两个主要的类,希望能给和同样想自造轮子的童鞋抛出一块砖头大笑

 

BeanFactory

 

package org.smile.orm.spring;

import org.smile.orm.dao.MapperProxy;
import org.springframework.beans.factory.FactoryBean;

public class MapperBeanFactory<T> implements FactoryBean<T>{

	private MapperProxy<T> proxy; 
	
	private Class<T> type;
	
	private boolean singleton;
	@Override
	public T getObject() throws Exception {
		if(singleton){
			return proxy.getInterfaceDao();
		}else{
			return MapperProxy.copy(proxy).getInterfaceDao();
		}
		
	}

	@Override
	public Class<T> getObjectType() {
		return type;
	}

	@Override
	public boolean isSingleton() {
		return singleton;
	}
	
	
	public void setSingleton(boolean singleton) {
		this.singleton = singleton;
	}

	public void setProxy(MapperProxy<T> proxy){
		this.proxy=proxy;
	}

	public void setType(Class<T> type) {
		this.type = type;
	}

}

 

SpringXmlApplication 

package org.smile.orm.spring;

import org.smile.orm.dao.DaoMapper;
import org.smile.orm.dao.MapperProxy;
import org.smile.orm.load.ClassPathXmlApplication;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;


public class SpringXmlApplication extends  ClassPathXmlApplication implements BeanDefinitionRegistryPostProcessor,ApplicationContextAware{
	
	private DefaultListableBeanFactory acf ;
	
	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefin)
			throws BeansException {
		initOrmApplication();
		BeanDefinitionBuilder bdb;  
		for(DaoMapper<?> mapper:application.getAllMapper()){
			bdb = BeanDefinitionBuilder.rootBeanDefinition(MapperBeanFactory.class.getName());  
            bdb.getBeanDefinition().setAttribute("id", mapper.getName());  
            bdb.addPropertyValue("proxy", new MapperProxy(application, mapper));
            bdb.addPropertyValue("type", mapper.getDaoClass());
            bdb.addPropertyValue("singleton", mapper.isSingle());
	        //  注册bean  
	        acf.registerBeanDefinition(mapper.getName(), bdb.getBeanDefinition());  
		}
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory factory)
			throws BeansException {
	}


	@Override
	public void setApplicationContext(ApplicationContext context) throws BeansException {
		this.acf=(DefaultListableBeanFactory)context.getAutowireCapableBeanFactory();
	}
	
}

 

 ClassPathXmlApplication

package org.smile.orm.load;

import java.util.List;

import javax.naming.NamingException;
import javax.sql.DataSource;

import org.smile.db.DbManager;
import org.smile.db.Dialect;
import org.smile.orm.OrmApplication;
import org.smile.orm.dao.BaseExecutor;
import org.smile.orm.dao.Executor;


public class ClassPathXmlApplication implements Application{
	
	protected DataSource dataSource;
	
	protected List<String> packageString;
	
	protected OrmApplication application;
	
	protected Dialect dialect;
	
	
	@Override
	public void setDataSource(Object dataSource) {
		if(dataSource instanceof DataSource){
			this.dataSource=(DataSource)dataSource;
		}else{
			try {
				this.dataSource = DbManager.getDataSource(String.valueOf(dataSource));
			} catch (NamingException e) {
				e.printStackTrace();
			}
		}
	}
	@Override
	public void setPackageString(List<String> packageString) {
		this.packageString = packageString;
	}
	@Override
	public void initOrmApplication(){
		application=new OrmApplication();
		application.setPackageString(packageString);
		Executor executor=new BaseExecutor();
		executor.setDataSource(dataSource);
		executor.setDialect(dialect);
		application.setExecuter(executor);
		application.init();
	}
	@Override
	public OrmApplication getOrmApplication() {
		return application;
	}
	@Override
	public void setDialect(String dialect) {
		this.dialect=Dialect.of(dialect);
	}
	
}

  

spring 中的配置

<bean id="dataSource" class="org.smile.db.DataSourceBean">
       <property name="name" value="mysql"></property>
	</bean>
	
	<bean id="ormappliction" class="org.smile.orm.spring.SpringXmlApplication">
		<property name="dataSource" ref="dataSource"></property>
		<property name="dialect" value="mysql"></property>
		<property name="packageString">
			<list>
				<value>dbmapper</value>
			</list>
		</property>
	</bean>

 

分享到:
评论

相关推荐

    41. Spring Boot 使用Java代码创建Bean并注册到Spring中【从零开始学Spring Boot】

    在本篇博文中,我们将深入探讨如何在Spring Boot应用中使用Java代码来创建Bean并将其注册到Spring容器中。这是Spring Boot的核心特性之一,它使得我们能够以编程方式管理对象,而无需XML配置。让我们逐步解析这个...

    Spring高级应用之注入嵌套Bean编程开发技术共1页

    `ref`属性用于指定被注入Bean的ID,确保Spring知道如何连接它们。 嵌套Bean的好处在于可以更好地组织代码,每个Bean都专注于自己的职责,同时保持了高内聚和低耦合。此外,由于Spring会管理这些Bean的生命周期,...

    spring自动扫描和管理Bean的示例

    在`spring_autozp_demo`压缩包中,可能包含了一个Spring应用的示例代码,演示了如何使用上述注解和配置。通过分析这个示例,你可以更好地理解Spring自动扫描和管理Bean的工作原理,以及如何在实际项目中应用这些概念...

    自定义注解得使用,模拟spring通过注解方式创建bean实例

    自定义注解允许我们创建自己的标记,用于特定目的,比如代码分析、验证、依赖注入等。 要创建自定义注解,我们需要使用`@interface`关键字。例如,我们可以定义一个名为`MyComponent`的注解: ```java import java...

    Spring在代码中获取bean的几种方式.rar

    如果需要注入Bean引用,可以配合`#{}`表达式。 ```java public class MyComponent { @Value("${my.property}") private String property; } ``` 8. **`@Qualifier` 注解** 当有多个相同类型的Bean时,`@...

    spring static静态方法里面注入bean空指针解决

    然而,静态方法和静态变量不参与Spring的生命周期管理,因此,尝试在静态字段或静态方法中直接使用`@Autowired`注入Bean会导致空指针异常,因为Spring容器不会初始化静态成员。 **解决方法1:使用@Component和非...

    day38 11-Spring的Bean的属性的注入:对象属性

    - 尽可能使用类型安全的注入,避免使用`@Value`注入Bean,除非必要。 7. **Spring的源码分析** - 深入源码可以帮助我们更好地理解Spring是如何处理属性注入的。例如,`DefaultListableBeanFactory`类中的`...

    面试官常问的spring依赖注入和bean的装配问题.pdf

    这种方式代码最为简洁,但缺点是丧失了灵活性,因为它不直接指定注入的来源,而是依赖于Spring的自动装配机制。在Spring 4.3及以后的版本中,甚至可以不定义构造函数,直接在类中声明私有变量,并通过@Autowired注解...

    spring 入门示例代码

    或者使用@Component注解将Java类标记为Spring Bean,然后通过@Configuration和@Bean注解进行更详细的配置。 4. **AOP(面向切面编程)**:Spring支持AOP,允许开发者定义“切面”,将关注点如日志、事务管理等与...

    扩展Spring—使用Annotation将配置资源注入到Bean中

    当一个类需要另一个类作为依赖时,无需手动创建,而是由Spring自动注入。例如,`@Autowired`注解在一个字段或方法上,Spring会自动寻找匹配类型的Bean并注入。 5. **注入特定的Bean** 如果有多重类型匹配的Bean,...

    Java中Spring获取bean方法小结

    - **通过代码注解**:Spring也支持通过注解来获取Bean,如`@Autowired`和`@Resource`,它们能够自动将依赖注入到目标字段或方法中,无需手动从ApplicationContext获取。 3. **静态Singleton Bean Manager** 通常...

    SpringIoc示例代码

    1. **Bean定义**:在Spring中,一个Java类可以被声明为一个Bean,这可以通过XML配置文件中的`&lt;bean&gt;`标签实现,或者使用`@Component`、`@Service`、`@Repository`、`@Controller`等注解。Bean定义包含了类名、属性值...

    Spring 入门代码实例

    在这个“Spring 入门代码实例”中,我们将深入探讨Spring的依赖注入机制,包括设值注入和构造注入两种方式,并结合JUnit进行测试。 **一、Spring IOC (控制反转) 理念** 控制反转(Inversion of Control,IoC)是...

    spring 中特殊bean用法

    6. **自动装配(Autowired)**: Spring的自动装配功能可以自动将依赖注入到Bean中,无需手动配置。`@Autowired`注解可以应用在字段、方法和构造函数上,Spring会根据类型或名称自动寻找匹配的Bean进行注入。 7. ** ...

    Springboot实现多线程注入bean的工具类操作

    总之,Spring Boot通过`ApplicationContextAware`接口和相关的工具类,使得在多线程环境中获取和使用bean变得简单易行,避免了手动管理bean实例的问题,保证了代码的整洁和可维护性。同时,这种方式也确保了bean的...

    Spring bean生命周期demo

    如果Bean之间有依赖关系,Spring会先实例化并注入依赖的Bean。 4. **初始化回调** 初始化回调是在Bean实例化后,所有属性注入完成时执行的方法。Spring提供了`InitializingBean`接口的`afterPropertiesSet()`方法...

    Spring应用开发代码

    这意味着开发者不再需要手动创建和配置对象,而是由Spring容器负责这一切,使得代码更加松耦合,易于测试和维护。 2. **面向切面编程(AOP)**:Spring的AOP允许开发者定义“切面”,这些切面可以包含业务逻辑的...

    获取Spring容器

    因此,在可能的情况下,建议使用`@Autowired`或`@Resource`等注解来自动注入Bean。 通过以上介绍,我们可以了解到如何在Spring应用中通过编程的方式手动获取Spring容器中的对象。这种方式为开发者提供了更大的灵活...

    自己的代码模拟spring的依赖注入

    以上就是使用自己的代码模拟Spring的依赖注入的基本流程。通过这个过程,我们可以理解DI的核心原理,并且在没有Spring框架的情况下实现类似的功能。这样的实践有助于深化对IoC和DI的理解,同时也可以用于学习和教学...

    SpingIOC注入实例化bean

    Spring的依赖注入允许bean之间通过接口而非具体实现进行耦合,提高了代码的可测试性和可维护性。依赖注入有两种方式: - **设值注入(setter注入)**:通过setter方法设置依赖的bean。 - **构造器注入**:在构造...

Global site tag (gtag.js) - Google Analytics