IOC容器初始化创建单实例对象源码分析

Spring（IOC）

---

IOC：（Inversion（反转） Of  Control）：控制反转；
          控制：资源的获取方式；
                    主动式：（要什么资源都自己创建即可）
                              BookServlet{
   
                                        BookService bs = new BookService();
                                        AirPlane ap = new AirPlane();//复杂对象的创建是比较庞大的工程；
                              }
                    被动式：资源的获取不是我们自己创建，而是交给一个容器来创建和设置；
                              BookServlet{
   
                                        BookService bs;
                                        public void test01(){
   
                                                      bs.checkout();// 
                                        }
                              }

容器：管理所有的组件（有功能的类）；假设，BookServlet受容器管理，BookService也受容器管理；容器可以自动的探查出那些组件（类）需要用到另一写组件（类）；容器帮我们创建BookService对象，并把BookService对象赋值过去；
容器：主动的new资源变为被动的接受资源；

DI：（Dependency Injection）依赖注入；
容器能知道哪个组件（类）运行的时候，需要另外一个类（组件）；容器通过反射的形式，将容器中准备好的BookService对象注入（利用反射给属性赋值）到BookServlet中；

只要IOC容器管理的组件，都能使用容器提供的强大功能；

---

IOC源码分析：

IOC：
1、IOC是一个容器
2、容器启动的时候创建所有单实例对象
3、我们可以直接从容器中获取到这个对象

---

SpringIOC：
1）、ioc容器的启动过程？启动期间都做了什么（什么时候创建所有单实例bean）
2）、ioc是如何创建这些单实例bean，并如何管理的；到底保存在了那里？
思路：
从HelloWorld开始，调试每个方法的作用；
1、ClassPathXMLApplicationContext构造器

ApplicationContext ioc =new ClassPathXmlApplicationContext("ioc.xml")
this(new String[] {
   configLocation}, true, null);

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
            throws BeansException {
   

        super(parent);
        setConfigLocations(configLocations);
        if (refresh) {
   
               //所有单实例bean创建完成
            refresh();
        }
    }

BeanFactory：Bean工厂；

refresh();实现；Spring；BeanFactory的流程；也是ioc容器的创建流程

@Override
    public void refresh() throws BeansException, IllegalStateException {
   
        synchronized (this.startupShutdownMonitor) {
   //同步锁，这里用来保证多线程情况下，ioc容器只被创建一次
            // Prepare this context for refreshing.
            prepareRefresh();//准备容器刷新；

            // Tell the subclass to refresh the internal bean factory.
               //Spring解析xml配置文件将要创建的所有bean的配置信息保存起来，观看Spring对xml的解析
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);//bean工厂准备一些其他东西，毕竟bean工厂很大

            try {
   
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);//bean工厂的后置处理器

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);//注册工厂的后置处理器
        
                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);//注册spring自己里边的一些后置处理器

                // Initialize message source for this context.
                //支持国际化功能的；
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
               //留给子类的方法，用来支持国际化功能的
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
               //初始化所有单实例bean的地方
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
   
                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }
        }
    }

finishBeanFactoryInitialization(beanFactory);实现
AbstractApplicationContext：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   
        // Initialize conversion service for this context.初始化类型转化
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
   
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName