Spring容器初始化过程

一.springIoc过程
​​​​​

1.资源文件定位
2.解析

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

解析主要是在BeanDefinitionReader中完成的，最常用的实现类是XmlBeanDefinitionReader，其中的loadBeanDefinitions()方法，负责读取Resource,最终解析的结果都封装为BeanDefinitionHolder

3.注册:
然后bean的注册是在BeanFactory里完成的，BeanFactory接口最常见的一个实现类是DefaultListableBeanFactory，它实现了BeanDefinitionRegistry接口，
所以其中的registerBeanDefinition()方法，
其实就是将BeanDefinition的name和实例，保存到一个Map中

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
。。。。。。。。。。。。。。。。。。。。。
this.beanDefinitionMap.put(beanName, beanDefinition);//提供后续实例化bean需要
this.beanDefinitionNames.add(beanName);
4.实例化
注册也完成之后，在BeanFactory的getBean()方法之中，会完成初始化，也就是依赖注入的过程
大体上的流程就是这样
public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory) ;   //创建beanFactory,进行一些属性设置，addBeanPostProcessor

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);  //后置处理工作 ,到这个BeanFactory 设置完成

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);  
                //核心后置处理器接口BeanFactoryPostProcessors，BeanDefinitionRegistryPostProcessor

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);//注册bean后置处理器 （遍历后置处理器创建bean，做前后拦截）

                // Initialize message source for this context.
                initMessageSource();  //国际化资源 Use empty MessageSource to be able to accept getMessage calls.

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster(); //初始化事件派发器 applicationEventMulticaster

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners(); //注册监听器，进行事件派发(如果没有监听器滤过) listener.onApplicationEvent(event);

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory); //将容器中所有单实例Bean(非懒加载)做初始化 核心***********
                 1）从一个全局Map去拿这个Bean，拿不到继续
                 2）获得这个bean所依赖的Bean
                 3)populateBean(beanName, mbd, instanceWrapper);Bean 属性赋值                 
                // Last step: publish corresponding event.
                finishRefresh();
            }
            
finishBeanFactoryInitialization：源码解析
1.如果是factoryBean，通过getBean 创建key=&beanName
2.否的话getBean
getBean
    1.Object sharedInstance = getSingleton(beanName);//从一级缓存->二级缓存->三级缓存,如果能从三级缓存拿到
        singletonObject = singletonFactory.getObject();
        this.earlySingletonObjects.put(beanName, singletonObject);//放到二级缓存
        this.singletonFactories.remove(beanName);        
    2.createBean
    3.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation
        InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 
    5.doCreateBean
    6.MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition
    7.addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 
    解决循环依赖，createBean之后,populteBean 之前，如果一级缓存没有
                this.singletonFactories.put(beanName, singletonFactory); //放到三级缓存
                this.earlySingletonObjects.remove(beanName);//从二级缓存移除
                this.registeredSingletons.add(beanName);
    8.populateBean(beanName, mbd, instanceWrapper);
      exposedObject = initializeBean(beanName, exposedObject, mbd);
    9.getSingleton返回
      addSingleton(beanName, singletonObject);放到一级缓存中

容器启动加载配置类信息 -->refresh()-->创建beanFactory,（注册后置处理器，国际化资源）--》finishBeanFactoryInitialization(beanFactory);-->getBean->doCreateBean->
beanwrapper（Bean配置了初始化前和初始化后的处理器，则试图返回一个需要创建//Bean的代理对象  ）->populated(属性赋值)->
initializeBean（//使用BeanUtils实例化，通过反射机制调用”构造方法.newInstance(arg)”来进行实例化,((InitializingBean) bean).afterPropertiesSet();）->processor

二.bean的生命周期

bean的生命周期:指   bean创建-----初始化----销毁  的过程,bean后置处理器会在bean初始化方法进行拦截
bean的生命周期是由容器进行管理的
配置方式4种
1.指定初始化和销毁方法 <之前在beanx.xml, 可以指定init-method和destory-mothod>
2.在配置类里通过@Bean(initMethod="init", destroyMethod="destroy")
3.让Bean实现 InitializingBean 和 DisposableBean
4.可以使用JSR250规则定义的(java规范)两个注解来实现
     @PostConstruct: 在Bean创建完成,且属于赋值完成后进行初始化,属于JDK规范的注解
     @PreDestroy: 在bean将被移除之前进行通知, 在容器销毁之前进行清理工作
三.
BeanPostProcessor类[interface]: bean的后 置处理器,在bean初始化之前调用进行拦截
     作用:在bean初始化前后进行一些处理工作,方式，实现里面两个方法
     
四.
Spring属性注入(四种)
1.set方法注入(最重要):基础类型，包装类型，list
2.使用有参数构造注入
  <bean name="user2" class="com.rr.bean.User">
       <constructor-arg name="name" value="Tony"></constructor-arg>
       <constructor-arg name="car" ref="car"></constructor-arg>
    </bean>
3.接口注入
spring依赖注入的第三种方式：接口注入
有时候资源并非来自于自身的系统，而是来自于外界，
比如说数据库连接资源完全可以在Tomcat下配置，
然后通过JNDI的方式去获取它，这样的数据库连接资源就属于开发工程外的资源

4.基于注解的注入，注入依赖@Autowaire
@Component：可以用于注册所有bean
@Repository：主要用于注册dao层的bean
@Controller：主要用于注册控制层的bean
@Service：主要用于注册服务层的bean
五。注入类型
1 数组
2 list集合
3 map集合
4 properties类型