Spring的IOC底层原理

1、创建BeanFactory容器

2、加载配置文件，解析xml的bean定义信息，包装成BeanDenifiton

3、执行BeanFactoryPostProcessor

准备工作：准备BeanFactoryPostProcessor，监听器，广播器

4、实例化操作

5、初始化操作

6、获取对象

7、程序使用对象

8、销毁对象

---

1、首先

//首先主类是源码分析入口，点击“ClassPathXmlApplicationContext”，进入类的构造器
ApplicationContext context = 
new ClassPathXmlApplicationContext("spring-config.xml");

---

进入“ClassPathXmlApplicationContext”的构造器内，其中有一个构造器执行了refresh()方法

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
super(parent);
this.setConfigLocations(configLocations);//设置加载地址，即"spring-config.xml"
if (refresh) {
this.refresh();
        }

    }

进入refresh()方法，最重要的就是this这些方法的实现

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();//准备刷新
            ConfigurableListableBeanFactory beanFactory =
            this.obtainFreshBeanFactory();        //获得新的BeanFactory
            this.prepareBeanFactory(beanFactory); //准备BeanFactory

            try {
                this.postProcessBeanFactory(beanFactory);//后置处理器，空方法，aop在此处理
                //调用各种BeanFactory后处理器
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //注册 Bean 后处理器，真正调用的是getBean()方法
                this.registerBeanPostProcessors(beanFactory);
                //为上下文初始化消息源，国际化
                this.initMessageSource();   
                //初始化应用事件多播器
                this.initApplicationEventMulticaster();
                this.onRefresh();   //刷新
                //注册监听器
                this.registerListeners();  
                //完成 Bean 工厂初始化
                this.finishBeanFactoryInitialization(beanFactory); 
                this.finishRefresh(); //完成刷新
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans(); //销毁 Bean
                this.cancelRefresh(var9);  //取消刷新
                throw var9;
            } finally {
                this.resetCommonCaches();  //重置通用缓存
            }

        }
    }

进入this.obtainFreshBeanFactory()；子方法

   protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        this.refreshBeanFactory();//刷新BeanFactory，在此方法内会对BeanFactory进行一系列设置
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
        }

        return beanFactory;
    }

进入this.refreshBeanFactory(); 方法，一直找到实现该方法的子类内部（在AbstractRefreshableApplicationContext类内）

protected final void refreshBeanFactory() throws BeansException {
        if (this.hasBeanFactory()) {  //此处表示如果已经创建了BeanFactory，则销毁，关闭 
            this.destroyBeans();
            this.closeBeanFactory();
        }
  try {
            //执行createBeanFactory()方法创建Bean工厂
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            //设置Bean工厂 序列化 ID
            beanFactory.setSerializationId(this.getId());
            //定制BeanFactory，设置相关属性
            this.customizeBeanFactory(beanFactory);
            //加载 Bean 定义，进行XML文件读取及解析
            this.loadBeanDefinitions(beanFactory);
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }

至此，BeanFactory创建完毕，并且在this.loadBeanDefinitions(beanFactory);方法内将XML等配置文件的内容封装BeanDenifition对象，即beanDenifitionMap、beanDenifitionNames

2、回到 有13个this的AbstractApplicationContext类的prepareBeanFactory()方法内，对创建完的BeanFactory填充属性，都是一些set方法或register注册方法

 protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        beanFactory.setBeanClassLoader(this.getClassLoader());
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
        beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
        if (beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

3、回到有13个 this 的AbstractApplicationContext类的

invokeBeanFactoryPostProcessors(beanFactory)方法，对BeanFactory进行属性填充

4、回到有13个 this 的AbstractApplicationContext类的

finishBeanFactoryInitialization()方法内，找到

beanFactory.preInstantiateSingletons();方法，进入方法

public void preInstantiateSingletons() throws BeansException {
 if (this.logger.isDebugEnabled()) {
   this.logger.debug("Pre-instantiating singletons in " + this);
   }
//将生成的beanDenifition对象添加到集合中
  List<String> beanNames = new ArrayList(this.beanDefinitionNames);
  Iterator var2 = beanNames.iterator();

 ************************省略一堆方法，中间是一系列判断


   } else {
               //直到最后getBean()方法，从容器中取得bean对象
               this.getBean(beanName);
          }
 }

5、进入getBean()方法内；

 
public Object getBean(String name) throws BeansException {

        //真正做事的地方，获取bean
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

6、进入doGetBean()方法内；

 protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
        final String beanName = this.transformedBeanName(name);
        //后去单例对象，容器中没有，为null
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if (sharedInstance != null && args == null) {
            if (this.logger.isDebugEnabled()) {

**************省略一些代码

 try {
         this.beforePrototypeCreation(beanName);
         //容器中没有对象，创建对象
         prototypeInstance = this.createBean(beanName, mbd, args);

  } finally {
      this.afterPrototypeCreation(beanName);
   }

7、在createBean()方法所在类中，一直找，找到

doCreateBean()方法中，会有下面的方法，创建bean实例

if (instanceWrapper == null) {
            //创建bean实例
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

8、进入createBeanInstance()方法内；

 protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
        //获取class文件
        Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);

************

       //获取构造器
       Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);

******************

9、会发现构造器参数为空，只有执行无参构造器创建对象

执行实例化策略，实例化

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
 

  if (System.getSecurityManager() != null) {
   beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
    public Object run() {
//执行实例化策略，实例化
return AbstractAutowireCapableBeanFactory.this.getInstantiationStrategy().instantiate(mbd, beanName, AbstractAutowireCapableBeanFactory.this);
                    }
                }, this.getAccessControlContext());



}

10、进入this.getInstantiationStrategy().instantiate()方法，

return BeanUtils.instantiateClass(constructorToUse, new Object[0]);

11、再进入instantiateClass()方法，终于完成对象创建

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
        Assert.notNull(ctor, "Constructor must not be null");

        try {
            ReflectionUtils.makeAccessible(ctor);
            //终于找到对象的创建，反射实现
            return ctor.newInstance(args);

***********
}

12、回到AbstractAutowireCapableBeanFactory类，对bean进行属性填充，populateBean()方法实现

   protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {

 PropertyValues pvs = mbd.getPropertyValues();
        if (bw == null) {
            if (!((PropertyValues)pvs).isEmpty()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
        } else {


***************
}

13、在initializeBean()方法内，对ApplicationContext和BeanFactory对象进行属性设置

 protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                public Object run() {
                    
                    AbstractAutowireCapableBeanFactory.this.invokeAwareMethods(beanName, bean);
                    return null;
                }
            }, this.getAccessControlContext());
        } else {
             //执行Aware接口方法
            this.invokeAwareMethods(beanName, bean);
        }
 Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //执行before方法
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }

try {
            //执行初始化方法
            this.invokeInitMethods(beanName, wrappedBean, mbd);
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
        }

   if (mbd == null || !mbd.isSynthetic()) {
            //执行after方法
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        //返回bean
        return wrappedBean;
    }
}

14、进入this.invokeAwareMethods(beanName, bean);方法内；

只对BeanNameAware、BeanClassLoaderAware、BeanFactoryAware这几个接口属性进行了设置

   private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware)bean).setBeanName(beanName);
            }

            if (bean instanceof BeanClassLoaderAware) {
                ((BeanClassLoaderAware)bean).setBeanClassLoader(this.getBeanClassLoader());
            }

            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware)bean).setBeanFactory(this);
            }
        }

    }

15、至此，对象实例化、初始化完成，程序使用

16、this.destroyBeans();方法销毁对象