手动创建或者扫描Bean并注册到Spring容器

使用方式：

       1、借助 @Import 注解类，创建ImportBeanDefinitionRegistrar的子类，手动构造BeanDefinition对象并注册到容器

       2、借助BeanFactoryPostProcessor接口类，通过ClassPathBeanDefinitionScanner类扫描并注册类到容器

       3、借助 @Import 注解类，创建ImportBeanDefinitionRegistrar的子类，通过ClassPathBeanDefinitionScanner类扫描并注册类到容器

 

一、通过创建 ImportBeanDefinitionRegistrar 的子类实现

public class User {
	private String username;
	private String password;
	
	public String getUsername() {
		return username;
	}
	
	public void setUsername(String username) {
		this.username = username;
	}
	
	public String getPassword() {
		return password;
	}
	
	public void setPassword(String password) {
		this.password = password;
	}
}


/**
 * 通过创建 ImportBeanDefinitionRegistrar 的子类实现手动将bean注入到Spring容器中。
 *		在方法registerBeanDefinitions中构造BeanDefinition对象，并调用BeanDefinitionRegistry的registerBeanDefinition方法注册
 * 		然后通过@Import注解导入到Spring容器中。
 */
public class MapperImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware{
	private ResourceLoader resourceLoader;
    
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    	registerUserBean(registry);  	
    }
    
    private void registerUserBean(BeanDefinitionRegistry registry){
    	if(!registry.containsBeanDefinition(User.class.getSimpleName())){
	    	BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(User.class);
	    	
	    	GenericBeanDefinition beanDefinition = (GenericBeanDefinition)builder.getRawBeanDefinition();
	    	beanDefinition.setBeanClass(User.class);
	    	beanDefinition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);
	    	
                //设置目标Bean的属性值
	    	beanDefinition.getPropertyValues().add("username", "abc");
	    	beanDefinition.getPropertyValues().add("password", "123");
	    	
	    	registry.registerBeanDefinition(User.class.getSimpleName(), beanDefinition);
    	}
    }
    
    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
    	this.resourceLoader = resourceLoader;
    }
}


/**
 * CommandLineRunner：
 * 		用于在应用程序启动前执行某些动作。
 * 		在所有Spring Beans都初始化之后，SpringApplication.run()之前执行。
 * 		如果存在多个CommandLineRunner的实现类，可以使用@Order注解来排序。
 */
@SpringBootApplication()
@Import({MapperImportBeanDefinitionRegistrar.class})
public class Main implements CommandLineRunner {
	@Autowired
	private User user;
	
	public static void main(String[] args){
		SpringApplication.run(Main.class, args);
	}
	
	@Override
	public void run(String... args) throws Exception {
		System.out.println(user.getUsername() + ", " + user.getPassword());
	}
}

 

二、通过创建 BeanFactoryPostProcessor 的子类，并结合ClassPathBeanDefinitionScanner类实现

      BeanFactoryPostProcessor： 在Bean初始化之前Spring容器会回调该类的postProcessBeanFactory方法。

      ClassPathBeanDefinitionScanner：将指定包下的类通过一定规则过滤后将Class信息包装成 BeanDefinition 的形式注册到IOC容器中。

/**
 * 自定义注解类
 */
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Mapper {
	 String value() default "";
}


/**
 * 接口类
 */
public interface CountryMapper {
	void show();
}


/**
 * 接口的实现类，该类用自定义注解@Mapper进行标注
 */
@Mapper
public class CountryMapperImpl implements CountryMapper {
	@Override
	public void show(){
		System.out.println("invoke show...");
	}
}


/**
 * BeanFactoryPostProcessor的子类
 * 		在Bean初始化之前Spring容器会回调该类的 postProcessBeanFactory 方法
 */
@Component
public class MapperBeanFactoryPostProcessor implements BeanFactoryPostProcessor, ApplicationContextAware {
	private ApplicationContext applicationContext;
	
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
	}
	
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
	    //扫描满足特定规则的类，并注册到容器中
		MapperClassPathBeanDefinitionScanner scanner = new MapperClassPathBeanDefinitionScanner((BeanDefinitionRegistry)beanFactory);
		scanner.setResourceLoader(this.applicationContext);
		scanner.registerDefaultFilters();
		scanner.scan(MapperClassPathBeanDefinitionScanner.BASE_PACKAGES);
	}
}


public class MapperClassPathBeanDefinitionScanner extends ClassPathBeanDefinitionScanner{
	public static final String BASE_PACKAGES = "com.seasy.springboottest";

	public MapperClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
        super(registry);
    }
	
	public void registerDefaultFilters() {
		//默认：根据指定注解类@Mapper过滤出满足条件的类
		TypeFilter typeFilter = new AnnotationTypeFilter(Mapper.class);
		
		//根据指定的类（包括子类和接口类）过滤出满足条件的类
//		TypeFilter typeFilter = new AssignableTypeFilter(CountryMapperImpl.class);
//		TypeFilter typeFilter = new AssignableTypeFilter(CountryMapper.class);
		
        this.addIncludeFilter(typeFilter);
    }
	
	@Override
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		return super.doScan(basePackages);
	}
	
	@Override
	protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
		return super.isCandidateComponent(beanDefinition) 
			&& beanDefinition.getMetadata().hasAnnotation(Mapper.class.getName());
	}
}


@SpringBootApplication()
public class Main implements CommandLineRunner {
	@Autowired
	private CountryMapper countryMapper;
	
	public static void main(String[] args){
		SpringApplication.run(Main.class, args);
	}
	
	@Override
	public void run(String... args) throws Exception {
		countryMapper.show();
	}
}

 

三、通过FactoryBean和Spring代理创建

/**
 * 自定义注解类
 */
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Mapper {
	 String value() default "";
}


//创建接口类，并用自定义注解类标注
@Mapper
public interface RoleMapper{
	public void printRole();
}

@Mapper
public interface UserMapper{
	public void print();
}

/**
 * 自定义拦截器
 */
public class CustomMethodInterceptor implements MethodInterceptor{
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		
		Object object = null;
		
		//接口没有对应的实现类，不能直接调用 invocation.proceed() 方法
        //object = invocation.proceed();
		
		//在此处编写业务逻辑
		//......

		System.out.println(invocation.getMethod().getDeclaringClass().getName() + ": " + invocation.getMethod().getName());
        
		stopWatch.stop();
        System.out.println("执行时间:" + stopWatch.getTotalTimeMillis() + "ms");
        return object;
	}
}

/**
 * 工厂Bean：通过Spring代理工厂创建代理类
 */
public class ScannerFactoryBean implements FactoryBean<Object>{
	private ProxyFactory factory;
	private String interfaceClassName;

	public void setInterfaceClassName(String interfaceClassName) {
		this.interfaceClassName = interfaceClassName;
		
		try {
			factory.setInterfaces(Class.forName(interfaceClassName));
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	public ScannerFactoryBean(){
		factory = new ProxyFactory(); //Spring代理工厂
	    factory.addAdvice(new CustomMethodInterceptor());
	}
	
	@Override
	public Object getObject() throws Exception {
		return factory.getProxy();
	}
	
	@Override
	public Class<?> getObjectType() {
		try {
			if(StringUtils.hasText(interfaceClassName)){
				return Class.forName(interfaceClassName);
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	@Override
	public boolean isSingleton() {
		return true;
	}
}

/**
 * 自定义BeanDefinition扫描器
 */
public class ScannerClassPathBeanDefinitionScanner extends ClassPathBeanDefinitionScanner{
	private ScannerFactoryBean scannerFactoryBean = new ScannerFactoryBean();
	
	public ScannerClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
        super(registry);
    }
	
	@Override
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
		
		ScannedGenericBeanDefinition beanDefinition;
		for(BeanDefinitionHolder holder : beanDefinitions){
			beanDefinition = (ScannedGenericBeanDefinition) holder.getBeanDefinition();
			if(beanDefinition.getMetadata().isInterface()){ //是接口类
				//添加BeanClass的属性值
				beanDefinition.getPropertyValues().add("interfaceClassName", beanDefinition.getBeanClassName());

				beanDefinition.setBeanClass(scannerFactoryBean.getClass()); //通过工厂Bean获取Bean对象
			}
		}
		
		return beanDefinitions;
	}
	
	/**
	 * 是候选组件
	 */
	@Override
	protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
		AnnotationMetadata metadata = beanDefinition.getMetadata();
		
		//isIndependent独立的、isConcrete具体的、isInterface接口
		return metadata.isIndependent() && (metadata.isConcrete() || metadata.isInterface());
	}
}

public class ScannerImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar{
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    	//BeanDefinition扫描器
    	ClassPathBeanDefinitionScanner scanner = new ScannerClassPathBeanDefinitionScanner(registry);
    	scanner.addIncludeFilter(new AnnotationTypeFilter(Mapper.class)); //基于注解类进行扫描过滤
    	scanner.scan("com.seasy.springboottest");
    }
}

/**
 * 配置类
 */
@Configuration
//通过导入的方式把实例加入SpringIOC容器中
@Import(value = {ScannerImportBeanDefinitionRegistrar.class})
public class ScannerConfig {

}

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = Main.class)
public class ScannerTest {
	@Test
	public void test3()throws Exception{
		//基于配置类加载Spring的应用上下文
        AnnotationConfigApplicationContext applicationContext 
        	= new AnnotationConfigApplicationContext(ScannerConfig.class);
        
        UserMapper userMapper = (UserMapper)applicationContext.getBean("userMapper");
        userMapper.print();
        
        RoleMapper roleMapper = (RoleMapper)applicationContext.getBean("roleMapper");
        roleMapper.printRole();
	}
}

  

RuntimeBeanReference：

        一个bean可能需要依赖其他的bean，而在Spring的解析阶段，其实容器中是没有依赖的Bean的实例的。为了表示这个被依赖的bean，在解析到依赖的Bean的时侯，解析器会依据依赖bean的name创建一个RuntimeBeanReference对像，将这个对像放入BeanDefinition的MutablePropertyValues中。

 

        reference = new RuntimeBeanReference("otherBeanName");

        beanDefinition.getPropertyValues().addPropertyValue("referBeanName", reference);

 

        在创建Bean时，需要将依赖解析成真正的在Spring容器中存在的Bean。这是在getBean时由AbstractAutowireCapableBeanFactory在applyPropertyValues方法中通过BeanDefinitionValueResolver来实现的。BeanDefinitionValueResolver将真正的依赖bean和referBeanName关联起来。