title: 【学习之路】SpringIoC源码简单解析
draft: true
tags:

创建Spring HelloWrold

  1. public class IocTest {
  2.     public static void main(String[] args) {
  3.         // 在这行代码上上打上断点
  4.         ApplicationContext ioc = new ClassPathXmlApplicationContext("conf/ioc.xml");
  5.         Object person = ioc.getBean("person");
  6.         System.out.println(person);
  7.     }
  9. }

创建Person实体类

  1. @AllArgsConstructor
  2. @ToString
  3. @Data
  4. public class Person {
  6.     private String lastName;
  8.     private Integer age;
  10.     private String sex;
  12.     public Person(){
  13.         System.out.println("person创建了");
  14.     }
  15. }

创建IoC配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="person" class="com.zixuan.my_spring.Person">
  7.         <property name="lastName" value="张三"></property>
  8.         <property name="age" value="18"></property>
  9.         <property name="sex" value="男"></property>
  10.     </bean>
  12.     <bean id="person2" class="com.zixuan.my_spring.Person">
  13.         <property name="lastName" value="李四"></property>
  14.         <property name="age" value="30"></property>
  15.         <property name="sex" value="男"></property>
  16.     </bean>
  18.     <bean id="person3" class="com.zixuan.my_spring.Person">
  19.         <property name="lastName" value="王五"></property>
  20.         <property name="age" value="29"></property>
  21.         <property name="sex" value="男"></property>
  22.     </bean>
  24.     <bean id="person4" class="com.zixuan.my_spring.Person">
  25.     </bean>
  27. </beans>

源码解析

运行主方法，这时进入了ClassPathXmlApplicationContext这个类的构造器

  1. public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
  2.     // 点击this进入当前方法
  3.    this(new String[] {configLocation}, true, null);
  4. }

基本上所有的构造器都是调用this

SpringIoC源码 - 图1

点击this后进入当前方法

  1. public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
  2.       throws BeansException {
  3.     // 可以试着放行方法，并且看控制台是否有打印
  4.    super(parent);
  5.    setConfigLocations(configLocations);
  6.    if (refresh) {
  7.        // 如果放行此方法，那么控制台就会打印所有创建Bean的信息
  8.       refresh();
  9.    }
  10. }

DeBug模式下按F7进入该方法,这时跳转到了AbstractApplicationContext这个类中

  1. @Override
  2. public void refresh() throws BeansException, IllegalStateException {
  3.     // 同步锁保证多线程状态下IoC线程只会创建一次
  4.    synchronized (this.startupShutdownMonitor) {
  5.        // 准备容器刷新
  6.       // Prepare this context for refreshing.
  7.       prepareRefresh();
  9.        // 创建一个ConfigurableListableBeanFactory打开当前类的继承树是BeanFactory的实现接口
  10.       // Tell the subclass to refresh the internal bean factory.
  11.        // 当前方法用于解析SpringIoC的XML文件，将XML文件中的Bean保存
  12.       ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  14.       // Prepare the bean factory for use in this context.
  15.       prepareBeanFactory(beanFactory);
  17.       try {
  18.          // Allows post-processing of the bean factory in context subclasses.
  19.          postProcessBeanFactory(beanFactory);
  20.             // Spring初始化自己所需的组件
  21.          // Invoke factory processors registered as beans in the context.
  22.          invokeBeanFactoryPostProcessors(beanFactory);
  24.          // Register bean processors that intercept bean creation.
  25.          registerBeanPostProcessors(beanFactory);
  27.           // Spring国际化功能
  28.          // Initialize message source for this context.
  29.          initMessageSource();
  31.          // Initialize event multicaster for this context.
  32.          initApplicationEventMulticaster();
  34.           // 留给子类的方法，方法内部是一个空方法
  35.          // Initialize other special beans in specific context subclasses.
  36.          onRefresh();
  38.          // Check for listener beans and register them.
  39.          registerListeners();
  41.          // 初始化所有没有懒加载的单列Bean，所有Bean加载内容在这个方法进行创建,进入当前方法查看Bean创建过程
  42.          // Instantiate all remaining (non-lazy-init) singletons.
  43.          finishBeanFactoryInitialization(beanFactory);
  45.          // Last step: publish corresponding event.
  46.          finishRefresh();
  47.       }
  49.       catch (BeansException ex) {
  50.          if (logger.isWarnEnabled()) {
  51.             logger.warn("Exception encountered during context initialization - " +
  52.                   "cancelling refresh attempt: " + ex);
  53.          }
  55.          // Destroy already created singletons to avoid dangling resources.
  56.          destroyBeans();
  58.          // Reset 'active' flag.
  59.          cancelRefresh(ex);
  61.          // Propagate exception to caller.
  62.          throw ex;
  63.       }
  65.       finally {
  66.          // Reset common introspection caches in Spring's core, since we
  67.          // might not ever need metadata for singleton beans anymore...
  68.          resetCommonCaches();
  69.       }
  70.    }
  71. }

进入finishBeanFactoryInitialization(beanFactory);

  1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  2.    // Initialize conversion service for this context.
  3.    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  4.          beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  5.       beanFactory.setConversionService(
  6.             beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  7.    }
  9.    // Register a default embedded value resolver if no bean post-processor
  10.    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
  11.    // at this point, primarily for resolution in annotation attribute values.
  12.    if (!beanFactory.hasEmbeddedValueResolver()) {
  13.       beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
  14.          @Override
  15.          public String resolveStringValue(String strVal) {
  16.             return getEnvironment().resolvePlaceholders(strVal);
  17.          }
  18.       });
  19.    }
  21.    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  22.    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  23.    for (String weaverAwareName : weaverAwareNames) {
  24.       getBean(weaverAwareName);
  25.    }
  27.    // Stop using the temporary ClassLoader for type matching.
  28.    beanFactory.setTempClassLoader(null);
  30.    // Allow for caching all bean definition metadata, not expecting further changes.
  31.    beanFactory.freezeConfiguration();
  33.     // 初始化所有的单列Bean，再次进入当前方法查看Bean创建过程
  34.    // Instantiate all remaining (non-lazy-init) singletons.
  35.    beanFactory.preInstantiateSingletons();
  36. }

再次进入beanFactory.preInstantiateSingletons();又跳转到了DefaultListableBeanFactory类中

  1. @Override
  2. public void preInstantiateSingletons() throws BeansException {
  3.    if (logger.isDebugEnabled()) {
  4.       logger.debug("Pre-instantiating singletons in " + this);
  5.    }
  7.    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  8.    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  9.     // 拿到所有要创建Bean的名称并加锁
  10.    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
  12.     // 通过增强for循环依次创建Bean
  13.    // Trigger initialization of all non-lazy singleton beans...
  14.    for (String beanName : beanNames) {
  15.        // 获取Bean的详细信息，判断当前Bean是否是抽象，是否是单列，是否是懒加载
  16.       RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  17.       if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  18.          if (isFactoryBean(beanName)) { // 判断当前Bean是否是工厂Bean，是否实现了FactoryBean接口的Bean
  19.             final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
  20.             boolean isEagerInit;
  21.             if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  22.                isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
  23.                   @Override
  24.                   public Boolean run() {
  25.                      return ((SmartFactoryBean<?>) factory).isEagerInit();
  26.                   }
  27.                }, getAccessControlContext());
  28.             }
  29.             else {
  30.                isEagerInit = (factory instanceof SmartFactoryBean &&
  31.                      ((SmartFactoryBean<?>) factory).isEagerInit());
  32.             }
  33.             if (isEagerInit) {
  34.                getBean(beanName);
  35.             }
  36.          }
  37.          else {
  38.              // 当前方法如果放行就会创建一个Bean，这个方法中又Bean的具体实现
  39.             getBean(beanName);
  40.          }
  41.       }
  42.    }
  44.    // Trigger post-initialization callback for all applicable beans...
  45.    for (String beanName : beanNames) {
  46.       Object singletonInstance = getSingleton(beanName);
  47.       if (singletonInstance instanceof SmartInitializingSingleton) {
  48.          final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  49.          if (System.getSecurityManager() != null) {
  50.             AccessController.doPrivileged(new PrivilegedAction<Object>() {
  51.                @Override
  52.                public Object run() {
  53.                   smartSingleton.afterSingletonsInstantiated();
  54.                   return null;
  55.                }
  56.             }, getAccessControlContext());
  57.          }
  58.          else {
  59.             smartSingleton.afterSingletonsInstantiated();
  60.          }
  61.       }
  62.    }
  63. }

进入getBean(beanName)跳转到AbstractBeanFactory类中

  1. public Object getBean(String name) throws BeansException {
  2.     return this.doGetBean(name, (Class)null, (Object[])null, false);
  3. }

再次进入doGetBean中

  1. protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
  2.     final String beanName = this.transformedBeanName(name);
  3.     // 从已经注册的单实例Bean中检查是否有没有当前Bean
  4.     Object sharedInstance = this.getSingleton(beanName);
  5.     Object bean;
  6.     if (sharedInstance != null && args == null) {
  7.         if (this.logger.isDebugEnabled()) {
  8.             if (this.isSingletonCurrentlyInCreation(beanName)) {
  9.                 this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
  10.             } else {
  11.                 this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
  12.             }
  13.         }
  15.         bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
  16.     } else {
  17.         if (this.isPrototypeCurrentlyInCreation(beanName)) {
  18.             throw new BeanCurrentlyInCreationException(beanName);
  19.         }
  21.         BeanFactory parentBeanFactory = this.getParentBeanFactory();
  22.         if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
  23.             String nameToLookup = this.originalBeanName(name);
  24.             if (args != null) {
  25.                 return parentBeanFactory.getBean(nameToLookup, args);
  26.             }
  28.             return parentBeanFactory.getBean(nameToLookup, requiredType);
  29.         }
  31.         // 标记Bean已经创建        
  32.         if (!typeCheckOnly) {
  33.             this.markBeanAsCreated(beanName);
  34.         }
  36.         try {
  37.             // 获取Bean的定义信息
  38.             final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
  39.             this.checkMergedBeanDefinition(mbd, beanName, args);
  40.             // 拿到创建当前需要创建的Bean，depends-on属性，如果有就循环创建
  41.             String[] dependsOn = mbd.getDependsOn();
  42.             String[] var11;
  43.             if (dependsOn != null) {
  44.                 var11 = dependsOn;
  45.                 int var12 = dependsOn.length;
  47.                 for(int var13 = 0; var13 < var12; ++var13) {
  48.                     String dep = var11[var13];
  49.                     if (this.isDependent(beanName, dep)) {
  50.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  51.                     }
  53.                     this.registerDependentBean(dep, beanName);
  55.                     try {
  56.                         this.getBean(dep);
  57.                     } catch (NoSuchBeanDefinitionException var24) {
  58.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
  59.                     }
  60.                 }
  61.             }
  62.             // 如果mbd是单列的就创建Bean实列
  63.             if (mbd.isSingleton()) {
  64.                 // 获取当前Bean，进入当前方法
  65.                 sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
  66.                     public Object getObject() throws BeansException {
  67.                         try {
  68.                            // 创建Bean过程
  69.                             return AbstractBeanFactory.this.createBean(beanName, mbd, args);
  70.                         } catch (BeansException var2) {
  71.                             AbstractBeanFactory.this.destroySingleton(beanName);
  72.                             throw var2;
  73.                         }
  74.                     }
  75.                 });
  76.                 bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  77.             } else if (mbd.isPrototype()) {
  78.                 var11 = null;
  80.                 Object prototypeInstance;
  81.                 try {
  82.                     this.beforePrototypeCreation(beanName);
  83.                     prototypeInstance = this.createBean(beanName, mbd, args);
  84.                 } finally {
  85.                     this.afterPrototypeCreation(beanName);
  86.                 }
  88.                 bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  89.             } else {
  90.                 String scopeName = mbd.getScope();
  91.                 Scope scope = (Scope)this.scopes.get(scopeName);
  92.                 if (scope == null) {
  93.                     throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  94.                 }
  96.                 try {
  97.                     Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
  98.                         public Object getObject() throws BeansException {
  99.                             AbstractBeanFactory.this.beforePrototypeCreation(beanName);
  101.                             Object var1;
  102.                             try {
  103.                                 var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
  104.                             } finally {
  105.                                 AbstractBeanFactory.this.afterPrototypeCreation(beanName);
  106.                             }
  108.                             return var1;
  109.                         }
  110.                     });
  111.                     bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  112.                 } catch (IllegalStateException var23) {
  113.                     throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
  114.                 }
  115.             }
  116.         } catch (BeansException var26) {
  117.             this.cleanupAfterBeanCreationFailure(beanName);
  118.             throw var26;
  119.         }
  120.     }
  122.     if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
  123.         try {
  124.             return this.getTypeConverter().convertIfNecessary(bean, requiredType);
  125.         } catch (TypeMismatchException var25) {
  126.             if (this.logger.isDebugEnabled()) {
  127.                 this.logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
  128.             }
  130.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  131.         }
  132.     } else {
  133.         return bean;
  134.     }
  135. }

进入到getSingleton(beanName, new ObjectFactory<Object>())

  1. public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  2.    Assert.notNull(beanName, "'beanName' must not be null");
  3.    synchronized (this.singletonObjects) {
  4.        // 先从singletonObjects中通过bean的名称获取bean对象，
  5.        // singletonObjects是当前类定义的一个Map，也就是Bean存储在一个Map中
  6.       Object singletonObject = this.singletonObjects.get(beanName);
  7.       if (singletonObject == null) {
  8.          if (this.singletonsCurrentlyInDestruction) {
  9.             throw new BeanCreationNotAllowedException(beanName,
  10.                   "Singleton bean creation not allowed while singletons of this factory are in destruction " +
  11.                   "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
  12.          }
  13.          if (logger.isDebugEnabled()) {
  14.             logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
  15.          }
  16.          beforeSingletonCreation(beanName);
  17.          boolean newSingleton = false;
  18.          boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  19.          if (recordSuppressedExceptions) {
  20.             this.suppressedExceptions = new LinkedHashSet<Exception>();
  21.          }
  22.          try {
  23.              // 通过反射创建Bean对象
  24.             singletonObject = singletonFactory.getObject();
  25.             newSingleton = true;
  26.          }
  27.          catch (IllegalStateException ex) {
  28.             // Has the singleton object implicitly appeared in the meantime ->
  29.             // if yes, proceed with it since the exception indicates that state.
  30.             singletonObject = this.singletonObjects.get(beanName);
  31.             if (singletonObject == null) {
  32.                throw ex;
  33.             }
  34.          }
  35.          catch (BeanCreationException ex) {
  36.             if (recordSuppressedExceptions) {
  37.                for (Exception suppressedException : this.suppressedExceptions) {
  38.                   ex.addRelatedCause(suppressedException);
  39.                }
  40.             }
  41.             throw ex;
  42.          }
  43.          finally {
  44.             if (recordSuppressedExceptions) {
  45.                this.suppressedExceptions = null;
  46.             }
  47.             afterSingletonCreation(beanName);
  48.          }
  49.          if (newSingleton) {
  50.              // 添加单实例Bean存储到singletonObject中
  51.             addSingleton(beanName, singletonObject);
  52.          }
  53.       }
  54.       return (singletonObject != NULL_OBJECT ? singletonObject : null);
  55.    }
  56. }

singletonObject是一个Map，当前bean的名字为key，value为当前存储的Bean对象

SpringIoC源码 - 图2

进入addSingleton(beanName, singletonObject);

  1. protected void addSingleton(String beanName, Object singletonObject) {
  2.    synchronized (this.singletonObjects) {
  3.        // 将Bean对象加入到Map中
  4.       this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
  5.       this.singletonFactories.remove(beanName);
  6.       this.earlySingletonObjects.remove(beanName);
  7.       this.registeredSingletons.add(beanName);
  8.    }
  9. }