Spring中自定义注解的解析过程-学习

Spring中自定义注解的解析过程-学习

在学习spring源码的过程中，最好奇的一件事就是Sprint的注解是怎么被读取到的，又是怎么进行解析的。然后又是怎么将注解的内容注入到spring容器中的。带着这个好奇心，写了一个小的Spring的自定义注解的demo，记录一下，怕自己忘记！

1. 在spring中，对于注解的解析，有一个非常重要的类就是ConfigurationClassPostProcessor,它是BeanDefinitionRegistryPostProcessor的其中一个实现类。关于后置处理器的暂时不记录，只要知道它是一个后置处理器，暂时就可以了。他是在容器启动时会被调用的一个后置处理器，调用的方法是postProcessBeanDefinitionRegistry，在这个方法中调用了processConfigBeanDefinitions方法。

@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);
		// 重要的方法在这个地方，调用这个方法，然后进行处理
		processConfigBeanDefinitions(registry);
	}
	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		// ..... 省略一部分暂时不需要关心的代码
		// Parse each @Configuration class
		// 注解解析入口 解析每一个@Configuration标注的配置类
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);

		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
		do {
			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
			// 最终调用的是这个方法，在这个方法里面进行注解的解析以及相应的处理
			parser.parse(candidates);
	// ...... 省略
}

2. 知道注解的解析，然后开始自己定义一个自定义注解TanxiiValue

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TanxiiValue {
	String value() default "";
}

3. 不采用上面的解析，我想自己写一个后置处理器来处理这个注解相关的逻辑，因此需要准备一个ApplicationContext、BeanFactoryPostProcessor以及一个BeanPostProcessor

public class TanxiiApplicationContext extends AnnotationConfigApplicationContext {
	public TanxiiApplicationContext(Class<MyConfig> myConfigClass) {
		super(myConfigClass);
	}

	@Override
	protected void initPropertySources() {
		// abc 属性必填 通过系统参数的形式获取
		this.getEnvironment().setRequiredProperties("abc");
	}

	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		System.out.println("Application的postProcessBeanFactory");
	}

	@Override
	public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
		Assert.notNull(postProcessor,"postProcessor is must not null");
		super.addBeanFactoryPostProcessor(postProcessor);
	}
}
//BeanFactoryPostProcessor 这里实现了一个Aware接口 目的是为了在容器启动的时候为当前类设置一个ApplicationContext，我需要通过这个context来获取一些必要属性，具体每一行代码干什么用的，都写好了注释，可以参考一下
@Component
public class TanxiiBeanFactoryPostProcessor implements BeanFactoryPostProcessor, ApplicationContextAware {

	private BeanDefinitionRegistry registry;

	private ApplicationContext applicationContext;

	@Override
	public void postProcessBeanFactory(@NotNull ConfigurableListableBeanFactory beanFactory) throws BeansException {
		if(beanFactory instanceof BeanDefinitionRegistry){
			System.out.println("======BeanDefinitionRegistry");
			this.registry = (BeanDefinitionRegistry) beanFactory;
		}
		// 获取扫描的包 这个地方有一个限制，就是加了注解的类必须在applicationContext的同级包或者子包里面 不然遍历不到
		String packageName = this.applicationContext.getClass().getPackageName();
		// 拼接待扫描的包的表达式
		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
				packageName.replaceAll("\\.","/") + '/' + "**/*.class";
		// 构造一个reader工厂出来，目的是为了方便构造一个beandefinition出来
		CachingMetadataReaderFactory cachingMetadataReaderFactory = new CachingMetadataReaderFactory();
		try {
			// 扫描符合packageSearchPath 路径下的所有类
			Resource[] resources = this.applicationContext.getResources(packageSearchPath);
			// 遍历所有类
			for (Resource resource : resources) {
				// 将类变成一个reader 给后面构成beandefinition使用
				MetadataReader metadataReader = cachingMetadataReaderFactory.getMetadataReader(resource);
				// 构造beandefinition
				ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
				// BeanNameGengrator bean的名称生成器
				AnnotationBeanNameGenerator annotationBeanNameGenerator = new AnnotationBeanNameGenerator();
				// 设置资源
				sbd.setSource(resource);
				// 设置单例
				sbd.setScope(BeanDefinition.SCOPE_SINGLETON);
				// 获取注解
				AnnotationMetadata metadata = sbd.getMetadata();
				// 获取指定注解的方法 主要的地方，在这里获取到了被TanxiiValue修饰的类
				// 因为被TanxiiValue修饰的类没有@Component注解，因此在spring启动的时候不会将该类扫描到SPring容器中，需要手动进行注册。这里就是我的目的，获取被注解的类，将其注入到spring容器中
				if(metadata.isAnnotated(TanxiiValue.class.getName())){
					// 构造一个BeanDefinitionHolder 然后将其注册到spring容器中
					BeanDefinitionHolder holder = new BeanDefinitionHolder(sbd,annotationBeanNameGenerator.generateBeanName(sbd,this.registry));
					BeanDefinitionReaderUtils.registerBeanDefinition(holder,this.registry);
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
	// 获取spring容器中的applicationContext对象
	@Override
	public void setApplicationContext(@NotNull ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
	}
}
// beanPostProcessor 在bean实例化并已经进行属性填充之后，在执行初始化方法的前后进行调用处理的地方，因此，我们自定义的注解在bean初始化前后都可以进行相应的个性化处理 这里只是写了一个测试的方法，勉强够看
@Component
public class TanxiiBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		Annotation[] annotations = bean.getClass().getAnnotations();
		for (Annotation annotation : annotations) {
			if(annotation instanceof TanxiiValue){
				TanxiiValue tanxiiValue = bean.getClass().getAnnotation(TanxiiValue.class);
				System.out.println("获取到注解的值" + tanxiiValue.value());
			}
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("BeanPostProcessor======after " + beanName);
		Annotation[] annotations = bean.getClass().getAnnotations();
		for (Annotation annotation : annotations) {
			if(annotation instanceof TanxiiValue){
				TanxiiValue tanxiiValue = bean.getClass().getAnnotation(TanxiiValue.class);
				System.out.println("获取到注解的值" + tanxiiValue.value());
			}
		}
		return bean;
	}
}

3. 测试，需要注意的是，在TanxiiBeanFactoryPostProcessor类中，我是获取的applicationcontext的包路径，这个地方就有一个限制，测试的类必须在applicationcontext的同级或者下级包中

@TanxiiValue(value = "正好做一个注解值获取的测试")
public class TestAnnotation {
	@Autowired
	public UserService userService;
	public void printf(){
		System.out.println(userService.orderService.getHello());
	}
}

4. 启动spring容器

public class MyFirstSpringApplication {
	public static void main(String[] args) {
		ApplicationContext context = new TanxiiApplicationContext(MyConfig.class);
//		OrderService orderService = (OrderService) context.getBean("testAnnotation");
		TestAnnotation testAnnotation = (TestAnnotation) context.getBean("testAnnotation");
		testAnnotation.printf();
		System.out.println(context.getBean("testAnnotation"));
//		System.out.println("====================orderServiceBefore");
//		System.out.println(orderService.getHello());
//		System.out.println("====================orderServiceAfter");
	}
}

可以发现被TanxiiValue注解修饰的类也可以正常从Spring容器中获取。当前注解可以被正常解析。