Spring的IOC初始化流程

目录

1、理解IOC/DI/DL

1.1、IOC -(Inversion Of Control)

1.2、DL-(Dependency looking )

1.3、DI-(Dependency injection )

2、Spring容器启动流程

3、Spring容器启动源码分析

4、小结

---

前言

• Spring的出现就是为了更好的管理Bean，而IOC/DI/DL又是Spirng的核心，IOC在Spring中可以简单的理解为一个Map容器，帮我们管理控制着Bean的生命周期。
• IOC -Inversion of control：控制反转，不是什么技术，而是一种设计思想，把对象的使用和创建分开了。

1、理解IOC/DI/DL

一切从Bean开始，IOC其实就是对我们的Bean进行管理；例如Bean加载，实例化，注册和管理。

例如，拿我们的SpringMVC为例，spring MVC本质上就是一个servlet，遵循了servlet的规范；在启动tomcat的时候，init()方法会完成以下工作：

• 第一步：JVM会扫描我们的jar或者war包，读取加载配置class文件，进行环境等变量的准备配置；
• 第二步：继续扫描业务字节码文件，包括相关的类，注解等class文件的全路径；
• 第三步：把第二步扫描出来的类通过反射进行实例化instance，然后注册到 IOC容器Map中；
• 第四步：完成 依赖查找注入DL 和 DI,实例化之后bean与bean之间的关系；例如加了@Resource @Autowire等注解的变量关系；
• 第五步：完成HandlerMapping的初始化，将加了@Controller和@RequestMapping的注解的url和method关系缓存到Map容器中；
• 第六步：容器启动完成，可以使用；

其中的3-4-5步骤都是在进行IOC的实现，将bean交给Spring容器托管。

 

继续理解什么是IOC/ID/DL，通过一段经常见的小代码来简单解释分析一下：

常见的Bean配置类：

@Configuration //配置类
public class AutowiredPersonConfig {
   
    @Bean
    public Person person(){
        return new Person();
    }

}

功能代码实现的：IOC ，依赖注入和依赖查找。

@SpringBootApplication
public class SpringBootMainApp {

    @Resource //DI 依赖注入
    private Person person;

    public static void main(String[] args) {
       
        //IOC,所谓的控制反转，容器载入类，将Bean实例化，然后交给spring容器Map托管；
        ApplicationContext app = new AnnotationConfigApplicationContext(AutowiredPersonConfig.class);
  
        //DL 依赖查找，在容器中查找id=person的Bean实例对象；
        Person person = (Person) app.getBean("person");
        // TODO HERE
    }
}

分析：容器启动载入类AnnotaionConfigApplicationContext完成Bean的装载和注册，@Resource里面就简单的实现了bean的依赖查找和注入。

1.1、IOC -(Inversion Of Control)

    IOC-控制反转， 简单理解就是一个大的Map集合，主要用来存放Bean对象，new Person();  根据容器载入类来加载Bean对象；

    Spring的IOC有很多的Map容器。例如上面的代码，当服务在启动的时候，JVM会扫描我们的jar包，找到class文件中的配置类AutowiredPersonConfig.class，然后将相关加了@Configuratio和@Bean注解的实例Bean Person加入到容器map中，实际等价于做了如下操作：

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
singletonObjects.put("person",new Person());

没有IOC之前，我们要使用对象的时候就需要自己先创建一个对象，自己控制对象的生产，获取相应的资源，另外每次产生一个对象就会往JVM内存中写入一些数据，占用了内存，也增加垃圾回收的行能消耗；

但是有了IOC之后，管理和控制就发生了反转：

• 控制了什么？对象的new创建和生命周期，相关的依赖资源获取；
• 反转给谁？管理权反转给Spring，由Spring的 ioc容器来控制Bean生命周期；

这个简单的过程其实就是IOC的过程，

 

1.2、DL-(Dependency looking )

DI-依赖查找。完成了Bean的加载，实例化和注册后，当我们要使用的时候，也就是依赖查找与注入的过程：

@Resource //DI&DL 依赖查找&注入
private Person person;

实际上等价于执行了下面代码：

第一步：判断是否加了相关的注解信息：

先判断如果变量加了@Resource注解

if (field.isAnnotationPresent(Resource.class)) {
    //todo 进行属性赋值；
}

第二步：完成DL-依赖查找，从容器map中获取实例Bean Person:

Person person = singletonObjects.get("person");

1.3、DI-(Dependency injection )

第三步：完成DI-依赖注入，通过反射将第一步从容器map中取到的person值设置到 private Person person; 这个变量中。

从MAP容器中获取Person对应的bean实例，并注入到变量person中，完成依赖注入：

field.setAccessible(true);
field.set(personInstance, person));

其实这也就是完成了person实例变量的依赖查找和注入过程。

2、Spring容器启动流程

下面来看一下Spring容器启动的主要流程：

ioc容器的初始化与Bean的创建：

• 第一步： refresh，容器刷新启动的时候，读取扫描jar／war包中的启动类配置文件bean.xml，载入类和application.properties文件；
• 第二步： 实例化BeanFactory这个Spring的最顶层的容器接口,创建完beanFactory，Spring就有了生产和获取getBean()的能力;另外，BeanFactory还提供一些后置处理器来保证我们的单实例非懒加载的业务bean正确创建；声明顶层map容器，初始化BeanFactory，使容器有getBean的能力；
• 第三步： finishBeanFactoryInitialization，对剩下的非懒加载单实例业务Bean进行实例化，继续扫描我们的jar或者war包，class文件，得到加了@Controller/@Component/@Service/@Repository等注解的所有要实例化的Bean的全路径名beanDefinationName；
• 第四步：通过BeanName开始从缓存也就是ioc容器map中直接获取bean实例：通过getBean()-doGetBean() ->getSingleton("beanName") —> map.getBean ("beanName")，先看IOC容器map缓存中是否有我们的singletonBean，有就 直接return，流程结束；

如果map缓存中没已实例化的Bean，则进行创建：

• 第一步：创建对象 ， createBean (),拿到class类对象，通过反射得到构造函数， 创建对象，new Person();
• 第二步：属性赋值 ； populateBean()：person. setName("king")
• 第三步：执行初始化方法 initializeBean ，代理对象通过applyBeanPostProcessorsBeforeInitializatio n和applyBeanPostProcessorsAfterInitialization进行增强bean的初始化前后增强 ；
• 至此，bean的创建完成，将单实例bean注册到ioc容器map中；
• finishRefresh();Spring发送容器事件消息，我启动完成了，你可以做事情了；

3、Spring容器启动源码分析

下面通过源码具体分析一下Spring容器启动的主流程，从容器刷新开始：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
   this();
   register(annotatedClasses);
   refresh(); //统一入口
}

refresh() 刷新开始：
@Override //容器刷新入口：
public void refresh() throws BeansException, IllegalStateException {
    //调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      //1、告诉子类启动refreshBeanFactory()方法，实例化创建BeanFactory，用来获取和创建Bean；
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      //为BeanFactory配置容器特性，例如类加载器、事件处理器等
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         //aop相关bean的创建
         //为BeanFactory注册BeanPost事件处理器.和业务bean执行的时机不一样而已，其他都一样；
         //BeanPostProcessor是Bean后置处理器的创建，用于监听容器触发的事件
         registerBeanPostProcessors(beanFactory);

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

         // Instantiate all remaining (non-lazy-init) singletons.
         //2、初始化所有剩余的非懒加载的单实例 — 业务Bean—也就是java中写的Bean文件；
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         //容器创建完成，为什么是finish，因为spring中有很多的事件监听机制，告诉监听者我启动完了，你可以做一些事情了；
         finishRefresh();
      }

开始创建非懒加载的单实例业务Bean：

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

   // Stop using the temporary ClassLoader for type matching.
   beanFactory.setTempClassLoader(null);

   // Allow for caching all bean definition metadata, not expecting further changes.
   beanFactory.freezeConfiguration();

   // Instantiate all remaining (non-lazy-init) singletons.
   //实例化所有剩下的非懒加载单实例业务Bean
   beanFactory.preInstantiateSingletons();
}

得到所有需要实例化的单实例Bean的全路径名，bean信息的定义 -用来生成这个bean的，然后挨个循环实例化：

@Override
public void preInstantiateSingletons() throws BeansException {

    String FACTORY_BEAN_PREFIX = "&";

   //得到所有的需要实例化的Bean的名字
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   // Trigger initialization of all non-lazy singleton beans…
    //挨个循环获取或者创建这个beanName;
   for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         if (isFactoryBean(beanName)) {
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
               final FactoryBean<?> factory = (FactoryBean<?>) bean;
               boolean isEagerInit;
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                  isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                              ((SmartFactoryBean<?>) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean<?>) factory).isEagerInit());
               }
               if (isEagerInit) {
                  getBean(beanName);
               }
            }
         }
         else {//获取或者创建这个bean
            getBean(beanName);
         }
      }
   }

在创建一个bean之前，先到ioc容器map中去获取相关的bean，如果该bean已经创建，则直接获取返回，不再创建，如果容器map中没有，则进行创建。这也是单例的体现，只创建一次，每次获取的对象都是同一个，可以验证打印它的地址是相同的。

@Override //获取bean信息
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
   return doGetBean(name, requiredType, null, false);
}
继续获取bean：
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

   final String beanName = transformedBeanName(name);
   Object bean;


    //将bean标记为已创建
    if (!typeCheckOnly) {
       markBeanAsCreated(beanName);
    }
   // Eagerly check singleton cache for manually registered singletons.
    //通过bean的名字到我们的 IOC大map-其实就是一个缓存 中获取 bean；
   Object sharedInstance = getSingleton(beanName);
    //如果缓存中有这个bean，则直接返回；
    if (sharedInstance != null && args == null) {
       if (logger.isTraceEnabled()) {
          if (isSingletonCurrentlyInCreation(beanName)) {
             logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                   "' that is not fully initialized yet - a consequence of a circular reference");
          }
          else {
             logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
          }
       }
       bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    //如果缓存中没有这个bean，则直接开始创建这个bean；
    else {
    if (mbd.isSingleton()) {
       sharedInstance = getSingleton(beanName, () -> {
          try {
             return createBean(beanName, mbd, args);
          }

从缓存容器map中获取bean单实例；

//private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //直接在map中get
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) { //同步获取；
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
    //如果容器中有bean，则直接返回；
   return singletonObject;
}

如果容器中有这个单实例bean则直接返回创建的流程结束；如果缓存中还没有我们需要的实例Bean，这时候就会开始创建我们的Bean实例：

创建createBean实例的具体步骤：

• 第一步：通过反射创建对象，new Person();
• 第二步：属性赋值；person.set("king")
• 第三步：执行Bean初始化方法，对于动态代理的对象Bean进行init前后拦截增强；

具体实现如下：

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {

     try {
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        //给个机会返回一个代理对象，这里什么都没做，因为aop的bean是普通的bean的创建过程；
       Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
       if (bean != null) {
          return bean;
       }
    }

   // Make sure bean class is actually resolved at this point, and
   // clone the bean definition in case of a dynamically resolved Class
   // which cannot be stored in the shared merged bean definition.
   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    try {
        //开始创建
       Object beanInstance = doCreateBean(beanName, mbdToUse, args);
       if (logger.isTraceEnabled()) {
          logger.trace("Finished creating instance of bean '" + beanName + "'");
       }
       return beanInstance;
}

创建bean，这里已经有内存地址了，也就是完成了对象的实例化：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {

   // Instantiate the bean.
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) { 
      //这里bean先创建对象，已经有内存地址；相当于Person person = new Person();
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }

Spring是通过反射来创建对象，通过createBeanInstance()发现具体创建对象步骤如下：

@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
   // Don't override the class with CGLIB if no overrides.
   if (!bd.hasMethodOverrides()) {
      Constructor<?> constructorToUse;
      synchronized (bd.constructorArgumentLock) {
         constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
                    //反射获取构造函数
                  constructorToUse = clazz.getDeclaredConstructor();
            }
            catch (Throwable ex) {
               throw new BeanInstantiationException(clazz, "No default constructor found", ex);
            }
         }
    }
        //第一步：反射创建实例完成 等价于Person person = new Person();
      return BeanUtils.instantiateClass(constructorToUse);
   }
    Object exposedObject = bean;
    try {
        //第二步：属性的赋值和初始化，等价于 person.setName("king");
       populateBean(beanName, mbd, instanceWrapper);
        //第三步：bean的初始化
       exposedObject = initializeBean(beanName, exposedObject, mbd);
    }

initializedBean主要是对bean完成一些初始化工作，比如在做动态代理的时候，这里就用到了，对当前的Bean初始化执行前和执行后做一些增强的处理工作，   

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
       AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
          invokeAwareMethods(beanName, bean);
          return null;
       }, getAccessControlContext());
    }
   else {//对bean的初始化
      invokeAwareMethods(beanName, bean);
   }
    Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
        //对bean出世化的前置处理器
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

   try {
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
        //对bean初始化的后置处理器
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

至此，一个业务bean的实例化就完成了，结束之后，将这个bean放入到我们的IOC容器map中去，供后期业务 DI/DL使用；

 

4、小结

        IOC的主要任务就是创建对象Bean，同时通过DL和DI处理Bean之间的关联关系，创建的这些单例对象，所有线程共享，一次创建，到处使用。集中管理，统一分配，减少内存开销。

 

 

 

水滴石穿，积少成多。学习笔记，内容简单，用于复习，梳理巩固。

 

参考资料：

源码下砸： https://github.com/spring-projects/spring-framework

https://spring.io/projects/spring-framework#learn