Sping学习---Spring容器初始化过程（一）

前言：本文章以配置类实例化Spring容器为例

初始化：调用new AnnotationConfigApplicationContext(XXX.class)

AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext(Appconfig.class);

其调用构造方法如下，由构造方法内容可知，需先调用无参构造，然后再调用register()方法注册配置类，最后调用refresh()刷新容器

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();
		register(componentClasses);
		refresh();
}

下面我们依次对构造方法中的各方法依次解析：

1.默认无参构造方法：this();

       1.1由于AnnotationConfigApplicationContext类  继承 GenericApplicationContext类，所以调用AnnotationConfigApplicationContext的无参构造前会调用其父类的无参构造 ，该方法产生了一个BeanFactory：DefaultListableBeanFactory。而这个工厂中有以下两个重要属性：Map<String, BeanDefinition> beanDefinitionMap，List<String> beanDefinitionNames，这二者用于存储Spring容器中注册的bean，并为bean实例化时提供原料。

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

      1.2调用本类构造方法

public AnnotationConfigApplicationContext() {
        //生成被注解的bean定义读取器
        //完成了spring容器中内部BeanDefinition的注入
		this.reader = new AnnotatedBeanDefinitionReader(this);
        
		//生成类路径bean定义扫描器
        //可以用来扫描包或者类，继而转化为BeanDefinition
		//但是实际上spring默认扫描器不是scanner这个对象，而是在后面自己又重新new了一个ClassPathBeanDefintionScanner
		//这里的scanner仅仅是为了程序员能够手动调用AnnotationConfigApplicationContext对象的scan方法
		this.scanner = new ClassPathBeanDefinitionScanner(this);
}

             1.2.1 下面我们来解析AnnotatedBeanDefinitionReader()调用过程

                      -- >org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(org.springframework.beans.factory.support.BeanDefinitionRegistry)

                        -->org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(org.springframework.beans.factory.support.BeanDefinitionRegistry, org.springframework.core.env.Environment)

                           -->org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry)

                             --> org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry)

                               -->org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object)                                     (就是该方法中注册了5个Spring内部的BeanDefinition,即RootBeanDefinition)，其代码如下：

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

		//获取bean工厂
		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);

		if (beanFactory != null) {
			//设置bean实例化顺序比较器,添加AnnotationAwareOrderComparator类的对象，主要去排序
			//AnnotationAwareOrderComparator是OrderComparator的子类，用来支持Spring的Ordered类、@Order注解和@Priority注解。
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			//ContextAnnotationAutowireCandidateResolver处理延迟加载
			//用于推断一个特定的beanDefinition是否能作为指定依赖的候选者的策略接口
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
		//此处注册了5个spring的内部bean,其类型为RootBeanDefinition
		//其中ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor，BeanFactoryPostProcessor
		//EventListenerMethodProcessor实现了BeanFactoryPostProcessor
		//DefaultEventListenerFactory实现EventListenerFactory
		//其他实现了BeanPostProcessor
        //由于我使用的是spring5.1,相比以往的spring内部bean注入，剔除了RequiredAnnotationBeanPostProcessor
        //注意这里列出的只是其类型名，注入到容器的名称为internal+类型名
        //spring的拓展点：BeanDefinitionRegistryPostProcessor，BeanFactoryPostProcessor，BeanFactory等，其中BeanDefinitionRegistryPostProcessor 继承了BeanFactoryPostProcessor
		
        //注入ConfigurationClassPostProcessor，是spring中非常重要的一个bean后置处理器，用于处理@Configuration，@Import等注解及包扫描，后续会详细讲解
		//注意：spring初始化时内部bean中只有ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor，这是后续判断处理的一个标准
        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));
		}
        
        //spring中的一个bean后置处理器，用于处理@Autowired注解
		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));
		}

        //spring中的一个bean的后置处理器，处理一些公共注解的，可以处理@PostConstruct和@PreDestroy还有@Resource等 
		// 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));
		}

        //初始化过程中并没有注入这个bean
		// 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));
		}

        //spring中的一个bean的后置处理器，实现该接口或添加@EventListener注解，实现对spring容器事件的监听
		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;
}

                                 -->org.springframework.context.annotation.AnnotationConfigUtils#registerPostProcessor

                                   -->org.springframework.beans.factory.support.BeanDefinitionRegistry#registerBeanDefinition

                                     -->org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition 注册BeanDefinition，主要代码如下：

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

		.............

		.............

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);//判断是否已经注册
		if (existingDefinition != null) {
			.............
            进行一些日志处理
            .............
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
             //注册bean，并将beanName及beanDefinition添加到beanDefinitionMap与beanDefinitionNames中
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}

至此，Spring内部bean注册完成后，AnnotatedBeanDefinitionReader方法执行完毕。

ClassPathBeanDefintionScanner方法由于在spring容器初始化过程中调用的不是此处方法，所以延后。