Spring 5.x 源码之旅一AnnotatedBeanDefinitionReader

前言

前面写了一些netty的源码解析，虽然覆盖不了所有的内容，但是大部分核心的内容都讲到了，主要还是要自己去看，去理解，然后写点小demo，领会netty的设计意图，为什么能高性能，从线程的分工明确，多路复用到内存分配的分而治之，让多线程之间减少竞争，让内存使用效率提高，等等一些思想。现在想再分析下Spirng 5.2.1.RELEASE的源码，虽然这个很复杂，但是我们还是可以大致了解一些原理，对以后使用和问题定位都有所帮助，而且还可以学到一些思想，一些处理方法，一些设计模式等等。我们主要是研究注解使用的一些原理。

简单注解例子

首先我们创建一个配置类MyConfig ：

@Configuration
public class MyConfig {
    
}

然后写一个测试方法，方便我们调试：

 @Test
    public void BeanDefinitionRegistryPostProcessorTest0() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
    }

啥都不干，就分析他对配置类做了什么。

简单思考

先不看源码，我们自己思考下我们把一个配置类放进去，他可能会做点什么。假设我们都用过Spring，哪怕最简单的那种，很明显我们可以猜到，他里面应该是对我们注解@Configuration的类进行了解析，分析他里面有点什么，然后进行相应的处理。确实大致思路就这样，但是具体就比较复杂了，我们还是看源码慢慢分析吧。

AnnotationConfigApplicationContext注解配置上下文

先看下大致创建了什么

首先我们看名字只知道他是注解配置的上下文，也就是一个环境，那环境里面应该有好多东西，可以处理我们传进去的类。我们刚才调用的构造方法就是这个：

	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();
		register(componentClasses);
		refresh();
	}
	
	public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}
	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}

首先他先创建了一个DefaultListableBeanFactory，这个就是后面一直要用的bean工厂，里面放着所有和bean相关的东西，比如bean定义，bean后置处理器等等，其实spring的思想就是把你给他的类都需要一个bean定义来描述，这样才可以进行处理。然后再创建AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner，一个是注解的bean定义读取器，一个是bean定义的扫描器。这里要注意ClassPathBeanDefinitionScanner其实是提供给用户用的，并不是他内部使用，内部后面他会再创建一个来用。我们先来看下AnnotatedBeanDefinitionReader创建做了什么。

AnnotatedBeanDefinitionReader读取器

看这个构造方法，传入的是一个BeanDefinitionRegistry类型，就是可以注册bean定义的，内部要注册就需要用到。

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}

getOrCreateEnvironment获得或者创建环境

如果BeanDefinitionRegistry是EnvironmentCapable的话就可以直接获取，否则就创建一个标准环境，其实就是获取一些系统的变量。比如可以配置dev环境，test环境，online环境等等。

	private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		if (registry instanceof EnvironmentCapable) {
			return ((EnvironmentCapable) registry).getEnvironment();
		}
		return new StandardEnvironment();
	}

AnnotatedBeanDefinitionReader构造方法

对BeanDefinitionRegistry进行了保存和把environment封装进了ConditionEvaluator，ConditionEvaluator可以理解成一个条件过滤器，与@Conditional有关，如果有了这个注解，就先判断条件成不成立，不成立的话有些操作就不做了。

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		this.registry = registry;
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

重要属性

另外有三个属性后面会用到，比如bean的名字生成器BeanNameGenerator，可以自定义怎么生成，默认是简单类名首字母小写，还有一个是范围注解的解析器ScopeMetadataResolver，解析出范围，是单例，还是原型，另一个就是条件评估器了ConditionEvaluator：

private final BeanDefinitionRegistry registry;
	//类名生成器
	private BeanNameGenerator beanNameGenerator = AnnotationBeanNameGenerator.INSTANCE;
	//socpe注解解析器
	private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
	//条件评估器
	private ConditionEvaluator conditionEvaluator;

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)注册注解配置处理器

这个一看方法就知道要加一些处理器，来处理我们的注解，也就是说，spring有些内部的处理器需要注册进来，这里可以想到spring应该是为了统一处理处理器，所以也是按注册，处理这样的流程来，无论是自己内部的，还是用户自定义的，我们来看看里面是怎么做的。

	public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}

主要流程就是获取DefaultListableBeanFactory，然后注册AnnotationAwareOrderComparator顺序比较器，排序用的，ContextAnnotationAutowireCandidateResolver自动装配解析器，解析自动装配相关配置用。然后创建一些后置处理器的bean定义，内部一般用RootBeanDefinition来定义，比如这个类ConfigurationClassPostProcessor，他是前面配置类处理的关键，所以这里先添加bean定义，还有AutowiredAnnotationBeanPostProcessor，处理自动装配的，另外还有EventListenerMethodProcessor和DefaultEventListenerFactory，CommonAnnotationBeanPostProcessor暂时不讲，后面用到会说。

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {
		//获取beanFactory
		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);//设置依赖比较器
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());//设置自动装配解析器
			}
		}
		//创建BeanDefinitionHolder集合
		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
		//设置ConfigurationClassPostProcessor后置处理器
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}
		//自动装配注解处理器
		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}
		//事件监听方法处理器
		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}
		//默认事件监听器工厂
		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

AnnotationConfigUtils的registerPostProcessor注册后置处理器

注册后置处理器，其实是注册对应的bean定义，对于一些内部处理器的bean定义，会设置角色属性setRole，然后向registry里注册beanName和bean定义，最后封装成BeanDefinitionHolder返回。

	private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(beanName, definition);//注册进registry
		return new BeanDefinitionHolder(definition, beanName);
	}

GenericApplicationContext的registerBeanDefinition注册bean定义

可以看到，这里出现了beanFactory，就是我们开始获得的DefaultListableBeanFactory，注册bean定义是交给他的。

@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
	}

DefaultListableBeanFactory的registerBeanDefinition注册bean定义

其他非核心的暂时略过了，剩下就两行，最终是把他放入ConcurrentHashMap中，名字放入ArrayList中。放在map里是为了后面可以方便映射获取，名字在list中则是为了方便获取遍历。

...
	this.beanDefinitionMap.put(beanName, beanDefinition);//名字和bean定义对应
				this.beanDefinitionNames.add(beanName);//名字
...

BeanDefinitionHolder封装bean定义而已

这个类其实就是对beanName和bean定义和别名做了封装：

最后注解配置处理器注册完成，注册了比较器和解析器，注册了注解处理器bean定义：


可以看到，内部的bean定义全部都是用RootBeanDefinition，关于bean定义的类型后面会说，先了解就行。至此读取器创建完成，其实就是注册了需要处理注解的处理器bean定义，此时还没有创建bean哦。后面ConfigurationClassPostProcessor发挥着很大的作用，用来解析配置类。后面我们要先了解下spring里的bean定义到是定义什么。

好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。