spring源码分析（二）之学习笔记1

spring源码分析流程图：

流程图解析（等分析完源码后解析）


分析注解方式的spring容器初始化

//注解配置程序上下文环境
AnnotationConfigApplicationContext annotationConfigApplicationContext =
                                  new AnnotationConfigApplicationContext(AppConfig.class);

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
   //调用无参构造方法
   this();

   //注册配置类或单个类
   register(componentClasses);

   //进行初始化工作
   refresh();
}

这里分析分3步，本文主要分析调用无参构造方法所做的事情

调用无参构造方法

public AnnotationConfigApplicationContext() { 
	/**
	 * 1.父类的构造方法
	 */
	/**
	 * 2.2.创建一个读取注解的Bean定义读取器
	 * 什么是Bean定义？BeanDefinition（用来描述bean，相当于java的class：描述java类）
	 */
	this.reader = new AnnotatedBeanDefinitionReader(this);
	//可以用来扫描包或者类，继而转换成bd
	//但是实际上我们扫描包的工作不是scanner这个对象完成的
	//是spring自己new的一个ClassPathBeanDefinitionScanner（下面会说到）
	//这里的scanner仅仅是为了程序员能够在外部调用AnnotationConfigApplicationContext对象的scan方法
	this.scanner = new ClassPathBeanDefinitionScanner(this);
}

1.其中父类构造方法中，实例化一个工厂DefaultListableBeanFactory：

public GenericApplicationContext() {
   this.beanFactory = new DefaultListableBeanFactory();
}

2.接着创建了一个AnnotatedBeanDefinitionReader（注解bean定义读取器，以下简称reader），this.reader = new AnnotatedBeanDefinitionReader(this);

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

reader委托AnnotationConfigUtils.registerAnnotationConfigProcessors方法注册了6个bd（这6个bd后续会有各自的作用）
registerAnnotationConfigProcessors往beanDefinitionMap中注册6个BeanDefinition

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
                                //添加AnnotationAwareOrderComparator类的对象，主要去排序
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
		//BeanDefinition的注册，这里很重要，需要理解注册每个bean的类型
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			//需要注意的是ConfigurationClassPostProcessor的类型是BeanDefinitionRegistryPostProcessor
			//而 BeanDefinitionRegistryPostProcessor 最终实现BeanFactoryPostProcessor这个接口
			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)) {
			//AutowiredAnnotationBeanPostProcessor 实现了MergedBeanDefinitionPostProcessor
			//MergedBeanDefinitionPostProcessor最终实现了BeanPostProcessor
			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;
	}

分析过程：
 1、添加AnnotationAwareOrderComparator类的对象，主要去排序
 2、ContextAnnotationAutowireCandidateResolver
 3、往BeanDefinitionMap注册一个ConfigurationClassPostProcessor（bean工厂后置处理器，主要用来插手spring工厂的初始化过程）（注1）
 4. 往BeanDefinitionMap中添加RequiredAnnotationBeanPostProcessor
 ...

注：为什么要加一个bean工厂后置处理器？
因为需要在invokeBeanFactoryPostProcessors（本方法在refresh()调用中）
invokeBeanFactoryPostProcessors主要是在spring的beanFactory初始化的过程中去做一些事情，怎么来做这些事情呢？委托了多个实现了BeanDefinitionRegistryPostProcessor或者BeanFactoryProcessor接口的类来做这些事情,有自定义的也有spring内部的，其中ConfigurationClassPostProcessor就是一个spring内部的BeanDefinitionRegistryPostProcessor，因为如果你不添加这里就没有办法委托ConfigurationClassPostProcessor做一些功能，到底哪些功能？下文
 

其中的registerPostProcessor()方法，

private static BeanDefinitionHolder registerPostProcessor(
      BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
   definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   registry.registerBeanDefinition(beanName, definition);
   return new BeanDefinitionHolder(definition, beanName);
}

BeanDefinitionHolder只是封装了beanName和bd，便于传参

3.ClassPathBeanDefinitionScanner，能够扫描bd（BeanDefinition以下简称bd）,能够扫描一个类，并且转换成bd

该类可以可以用来扫描包或者类，继而转换成bd，但是实际上我们扫描包的工作不是scanner这个对象完成的，是spring自己new的一个ClassPathBeanDefinitionScanner（后续分析会说到）

正如前面代码的注释：

这里的scanner仅仅是为了程序员能够在外部调用AnnotationConfigApplicationContext对象的scan方法