自定义注解扫描并动态注册bean

        缺省情况下，ClassPathBeanDefinitionScanner类只会扫描带有@Component（@RestController、@Controller、@Service、@Repository）、@ManagedBean、@Named 注解的类，如果要扫描自定义注解类，则需要通过创建ClassPathBeanDefinitionScanner类的子类实现该功能，该类对外提供scan方法，根据传入的包名，自动扫描加载BeanDefinition并将BeanDefinition注册到registry中。

 

ClassPathBeanDefinitionScanner子类在调用过程的位置有：

        @import注解类 >> ImportBeanDefinitionRegistrar注册 >> ClassPathBeanDefinitionScanner扫描 >> FactoryBean动态代理 >> Advice面向切面编程

 

        BeanFactoryPostProcessor >> ClassPathBeanDefinitionScanner扫描 >> FactoryBean动态代理 >> Advice面向切面编程

 

1、配置类

@Import({ScannerImportBeanDefinitionRegistrar.class})
//@Import({ScannerBeanFactoryPostProcessor.class})
class ScannerConfig {
	
}

 

2、BeanDefinition注册类

class ScannerImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar{
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    	ClassPathBeanDefinitionScanner scanner = new ScannerClassPathBeanDefinitionScanner(registry);
    	
    	//从指定包路径下扫描
    	scanner.scan(ScannerClassPathBeanDefinitionScanner.PACKAGE_PATH);
    }
}

 

     BeanFactoryPostProcessor类

/**
 * BeanFactoryPostProcessor
 * 		BeanFactoryPostProcessor在spring容器加载了bean的定义文件之后，在bean实例化之前执行。
 * 		使用BeanFactoryPostProcessor对BeanFactory中的BeanDefinition进行修改，或者创建BeanDefinition到BeanFactory中。
 */
class ScannerBeanFactoryPostProcessor implements BeanFactoryPostProcessor{
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		ClassPathBeanDefinitionScanner scanner = new ScannerClassPathBeanDefinitionScanner((BeanDefinitionRegistry)beanFactory);
		
    	//从指定包路径下扫描
    	scanner.scan(ScannerClassPathBeanDefinitionScanner.PACKAGE_PATH);
	}
}

 

3、扫描器类

class ScannerClassPathBeanDefinitionScanner extends ClassPathBeanDefinitionScanner{
	public static String PACKAGE_PATH = "com.seasy.springboottest.examples.example2";
	
	//工厂Bean
	private ScannerFactoryBean scannerFactoryBean = new ScannerFactoryBean();
	
	public ScannerClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
        super(registry);
        addIncludeFilters();
    }
	
	void addIncludeFilters(){
    	//基于 自定义注解类 进行扫描过滤
    	addIncludeFilter(new AnnotationTypeFilter(Mapper.class));
    	
    	//基于 接口类 进行扫描过滤
    	addIncludeFilter(new AssignableTypeFilter(UserMapper.class));
	}
	
	@Override
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
		
		ScannedGenericBeanDefinition definition;
		for(BeanDefinitionHolder holder : beanDefinitions){
			definition = (ScannedGenericBeanDefinition) holder.getBeanDefinition();
			
			if(definition.getMetadata().isInterface()){ //是接口类
				String beanName = holder.getBeanName();
				String beanClassName = definition.getBeanClassName();
				System.out.println(">>> beanName=" + beanName + ", beanClassName=" + beanClassName);

				//通过工厂Bean获取Bean对象
				definition.setBeanClass(scannerFactoryBean.getClass()); 
				
				//给FactoryBean类的interfaceClassName属性值设置值
				definition.getPropertyValues().add("interfaceClassName", beanClassName);
				
				//给FactoryBean类的构造函数添加入参值
				//definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
				
				//sqlSessionFactory属性值是一个bean对象，根据bean名形成依赖关系
				//definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(beanName));
				
			}else{
				System.out.println("###########  " + definition.getBeanClassName());
			}
		}
		
		return beanDefinitions;
	}
	
	/**
	 * 候选组件
	 */
	@Override
	protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
		AnnotationMetadata metadata = beanDefinition.getMetadata();
		
		//isIndependent独立的、isConcrete具体的、isInterface接口
		return metadata.isIndependent() 
				&& (metadata.isConcrete() || metadata.isInterface());
	}
}

 

4、FactoryBean类

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;
	}
}

 

5、MethodInterceptor类

class CustomMethodInterceptor implements MethodInterceptor{
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		Object object = null;
		
		//接口没有对应的实现类，不能直接调用 invocation.proceed() 方法
        //object = invocation.proceed();
		System.out.println(invocation.getMethod().getDeclaringClass().getName() + ": " + invocation.getMethod().getName());
		
        return object;
	}
}