Spring IOC源码分析

发表于 | 分类于 | 次阅读

本文从源码的角度解析spring ioc的实现原理。

Spring容器可以分为两类：

  • BeanFactory

  • ApplicationContext

通常我们讲到Spring容器，一般是指ApplicationContext，因为通过上图我们可以看到ApplicationContext实际上也是BeanFactory下面的一个类。

创建BeanFactory及Bean的注册

Spring里建立一个ApplicationContext是通过以下一行语句进行：

1
ApplicationContext context=new ClassPathXmlApplicationContext("classpath:application.xml");

简单的理解就是通过读取配置文件返回一个Spring容器ApplicationContext，那么具体的过程肯定是要通过分析ClassPathXmlApplicationContext的构造器开始。可以看到设置了配置文件地址后调用的refresh就是我们需要的核心方法。

1
2
3
4
5
6
7
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
        super(parent);
        this.setConfigLocations(configLocations);
        if (refresh) {
            this.refresh();  //核心方法
        }
    }

refresh()方法是在一个上层类AbstractApplicationContext中定义的，它的行为比较多，我们可以重点关注这一行

ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();代码，返回创建了一个beanFactory，这个实际上就是一个Bean工厂，它的注册中心里包含了从配置文件中解析出来的BeanDefinition，也就是Bean对象，注册中心是一个concurrentHashMap<beanName, Object>。只是这些bean还没有初始化。

//ClassPathXmlApplicationContext.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            //准备工作
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                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();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }
        }
    }

下面我们的就refresh方法中的核心流程进行分析。

prepareRefresh()负责创建bean之前的准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符等。

接下来是比较重要的obtainFreshBeanFactory()方法，这里会创建BeanFactory，加载Bean并注册Bean。

//AbstractApplicationContext.java

1
2
3
4
5
6
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    //创建beanFactory
    this.refreshBeanFactory();
    //返回beanFactory
    return this.getBeanFactory();
}

//AbstractApplicationContext的子类AbstractRefreshableApplicationContext.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
protected final void refreshBeanFactory() throws BeansException {
    //如果已经有beanFactory则关闭它
    if (this.hasBeanFactory()) {
        this.destroyBeans();
        this.closeBeanFactory();
    }

    try {
        //真实的BeanFactory
        DefaultListableBeanFactory beanFactory = this.createBeanFactory();
        beanFactory.setSerializationId(this.getId());
        this.customizeBeanFactory(beanFactory);
        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);
    }
}

通过图1可以看到在BeanFactory的继承树最下面的一个类就是DefaultListableBeanFactory，虽然在继承体系中，ApplicationContext继承自BeanFactory，但它不能被理解为BeanFactory的实现类，而是它内部持有一个BeanFactory的实例（DefaultListableBeanFactory），以后所有的与BeanFactory有关的操作都是委托给DefaultListableBeanFactory实例来做的。

可以看到，ConfigurableListableBeanFactory继承了BeanFactory下面的三个子类，而它唯一的一个实现类就是DefaultListableBeanFactory，而且DefaultListableBeanFactory还从右边继承了AbstractAutowireCapableBeanFactory，这是用来自动装配（Autowire）bean实例的类，所以可以说，DefaultListableBeanFactory这个BeanFactory可以做到最多的事，因此实例化它作为bean工厂。

创建了BeanFactory实例后接下来看refreshBeanFactory里的这两个方法

this.customizeBeanFactory(beanFactory);
this.loadBeanDefinitions(beanFactory);

customizeBeanFactory方法比较简单，设置是否允许覆盖BeanDefinition以及是否允许循环引用。

1
2
3
4
5
6
7
8
9
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    if (this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }

    if (this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences);
    }
}

关于BeanDefinition，这也是一个比较重要的类，可以理解为Spring中的每一个Bean都是一个BeanDefinition实例，它是由配置文件中的每一个<bean>解析出来的。

接下来是比较重要的loadBeanDefinition()方法，它完成了Bean的加载与注册工作。

1
2
3
4
5
6
7
8
9
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    //给beanFactory实例化一个beanDefinitionReader，通过它去读取BeanDefinition
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    this.initBeanDefinitionReader(beanDefinitionReader);
    this.loadBeanDefinitions(beanDefinitionReader);
}
1
2
3
4
5
6
7
8
9
10
11
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        Resource[] configResources = this.getConfigResources();
        if (configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }

        String[] configLocations = this.getConfigLocations();
        if (configLocations != null) {
            reader.loadBeanDefinitions(configLocations);
        }
    }

在spring中，把资源配置文件抽象为Resource实例，通过BeanDefinition解析Resource实例获取BeanDefition。这个过程我们就暂时忽略不讲，具体可以看BeanDefinitionReaderUtils这个类。我们接下来要关注bean的注册过程，同样是在这个类中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
        String beanName = definitionHolder.getBeanName();
        //注册这个bean
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            String[] var4 = aliases;
            int var5 = aliases.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                String alias = var4[var6];
                registry.registerAlias(beanName, alias);
            }
        }

    }

registry.registerBaenDefinition()这个方法回到了DefaultListableBeanFactory中。实际上仔细观察DefaultListableBeanFactory类的定义，可以看到它实际上是实现了BeanDefinitionRegistry接口，也就是说这个BeanFactory包括了BeanDefinition注册中心。

这个registerBeanDefinition方法比较长，我们只看它重要的地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
            ......
            ......
            //一系列if-else 判断是否可以正常注册bean
            ......
            ......
            } else {
                //这是正常情况应该到达的分支
                //把<beanName, beanDefinition>加入hashmap，即加入注册中心
                this.beanDefinitionMap.put(beanName, beanDefinition);
                //把beanName加入arraylist，按序保存每个beanName
                this.beanDefinitionNames.add(beanName);
                // 这是个 LinkedHashSet，代表的是手动注册的 singleton bean，
                // 注意这里是 remove 方法，到这里的 Bean 当然不是手动注册的
                // 手动指的是通过调用以下方法注册的 bean ：
                //     registerSingleton(String beanName, Object singletonObject)
                this.removeManualSingletonName(beanName);
            }

            this.frozenBeanDefinitionNames = null;
        }

        if (existingDefinition != null || this.containsSingleton(beanName)) {
            this.resetBeanDefinition(beanName);
        }
    }

至此，我们的BeanFactory完成了创建，以及把配置文件里的bean添加到了注册中心里。

初始化Bean实例

上面的篇幅都仅仅讲了Bean的发现与注册，我们继续看refresh方法后面的部分，可以看到在实例化bean之前还有比较多的操作，不过我们可以把它理解为对BeanFactory或Bean的一些额外扩展或操作，暂时可以略过不细看，应该着眼于重点this.finishBeanFactoryInitialization(beanFactory);实例化操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            //准备工作
            this.prepareRefresh();
            //创建BeanFactory，注册BeanDefinition
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            //// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
            this.prepareBeanFactory(beanFactory);

            try {
                // 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
                // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】

        			  // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
         				// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
                this.postProcessBeanFactory(beanFactory);
              
                // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 回调方法
                this.invokeBeanFactoryPostProcessors(beanFactory);
              
                // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
         				// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
        			  // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。这里仅仅是注册，之后会看到回调这两方法的时机
                this.registerBeanPostProcessors(beanFactory);
              
                // 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
                this.initMessageSource();
                
                // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
                this.initApplicationEventMulticaster();
              
                // 从方法名就可以知道，典型的模板方法(钩子方法)，不展开说
         				// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
                this.onRefresh();
              
                // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
                this.registerListeners();
              
                //重点！！！初始化所有的singleton bean（lazy-init 的除外）
                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();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }
        }
    }

我们来总结一下，到目前为止，应该说 BeanFactory 已经创建完成，并且所有的实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化并且其中的 postProcessBeanFactory(factory) 方法已经得到回调执行了。而且 Spring 已经“手动”注册了一些特殊的 Bean，如 environment、systemProperties 等。接下来，在finishBeanFactoryInitialization(beanFactory)方法中，如果没有设置懒加载，容器初始化了所有的单例Bean。

//AbstractApplicationContext.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> {
            return this.getEnvironment().resolvePlaceholders(strVal);
        });
    }

    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    String[] var3 = weaverAwareNames;
    int var4 = weaverAwareNames.length;

    for(int var5 = 0; var5 < var4; ++var5) {
        String weaverAwareName = var3[var5];
        this.getBean(weaverAwareName);
    }

    beanFactory.setTempClassLoader((ClassLoader)null);
    beanFactory.freezeConfiguration();
    //开始初始化
    beanFactory.preInstantiateSingletons();
}

preInstantiateSingletons()方法又回到了DefaultListableBeanFactory里。需要关注的是getBean()方法

//DefaultListableBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Pre-instantiating singletons in " + this);
        }

        List<String> beanNames = new ArrayList(this.beanDefinitionNames);
        //迭代器访问每个beanName
        Iterator var2 = beanNames.iterator();

        while(true) {
            String beanName;
            Object bean;
            do {
                while(true) {
                    RootBeanDefinition bd;
                    do {
                        do {
                            do {
                                if (!var2.hasNext()) {
                                    var2 = beanNames.iterator();
                                     // 到这里说明所有的非懒加载的 singleton beans 已经完成了初始化
                                     // 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里得到回调，忽略
                                    while(var2.hasNext()) {
                                        
                                        beanName = (String)var2.next();
                                        Object singletonInstance = this.getSingleton(beanName);
                                        // 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现，此处忽略，直接跳过
                                        if (singletonInstance instanceof SmartInitializingSingleton) {
                                            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                            if (System.getSecurityManager() != null) {
                                                AccessController.doPrivileged(() -> {
                                                    smartSingleton.afterSingletonsInstantiated();
                                                    return null;
                                                }, this.getAccessControlContext());
                                            } else {
                                                smartSingleton.afterSingletonsInstantiated();
                                            }
                                        }
                                    }

                                    return;
                                }

                                beanName = (String)var2.next();
                                bd = this.getMergedLocalBeanDefinition(beanName);
                            } while(bd.isAbstract());
                        } while(!bd.isSingleton());
                    } while(bd.isLazyInit());

                    if (this.isFactoryBean(beanName)) {
                        bean = this.getBean("&" + beanName);
                        break;
                    }
                  
                    //对于普通的bean只需要调用这里的getBean方法
                    this.getBean(beanName);
                  
                }
            } while(!(bean instanceof FactoryBean));

            FactoryBean<?> factory = (FactoryBean)bean;
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                SmartFactoryBean var10000 = (SmartFactoryBean)factory;
                ((SmartFactoryBean)factory).getClass();
                isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
            } else {
                isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
            }

            if (isEagerInit) {
                this.getBean(beanName);
            }
        }
    }

//AbstractBeanFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
public Object getBean(String name) throws BeansException {
      return this.doGetBean(name, (Class)null, (Object[])null, false);
  }

 protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
      String beanName = this.transformedBeanName(name);
      // 检查下是不是已经创建过了
      Object sharedInstance = this.getSingleton(beanName);
      // 注意跟着这个，这个是返回值
      Object bean;
      if (sharedInstance != null && args == null) {
          if (this.logger.isTraceEnabled()) {
              if (this.isSingletonCurrentlyInCreation(beanName)) {
                  this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
              } else {
                  this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
              }
          }

          bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
      } else {
          //如果创建过了prototype类型的以beanName为名的bean就抛异常
          if (this.isPrototypeCurrentlyInCreation(beanName)) {
              throw new BeanCurrentlyInCreationException(beanName);
          }
          //检查这个BeanDefinition是否在容器中
          BeanFactory parentBeanFactory = this.getParentBeanFactory();
          if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
              String nameToLookup = this.originalBeanName(name);
              if (parentBeanFactory instanceof AbstractBeanFactory) {
                  return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
              }

              if (args != null) {
                  return parentBeanFactory.getBean(nameToLookup, args);
              }

              if (requiredType != null) {
                  return parentBeanFactory.getBean(nameToLookup, requiredType);
              }

              return parentBeanFactory.getBean(nameToLookup);
          }

          if (!typeCheckOnly) {
              this.markBeanAsCreated(beanName);
          }
          //到这里，才要准备创建bean了。
          try {
              //初始化所有依赖的bean
              RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
              this.checkMergedBeanDefinition(mbd, beanName, args);
              String[] dependsOn = mbd.getDependsOn();
              String[] var11;
              if (dependsOn != null) {
                  var11 = dependsOn;
                  int var12 = dependsOn.length;

                  for(int var13 = 0; var13 < var12; ++var13) {
                      String dep = var11[var13];
                      if (this.isDependent(beanName, dep)) {
                          throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                      }

                      this.registerDependentBean(dep, beanName);

                      try {
                          this.getBean(dep);
                      } catch (NoSuchBeanDefinitionException var24) {
                          throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                      }
                  }
              }
              //如果是singleton的，创建singleton的实例
              if (mbd.isSingleton()) {
                  sharedInstance = this.getSingleton(beanName, () -> {
                      try {
                          //createBean方法执行具体的创建过程
                          return this.createBean(beanName, mbd, args);
                      } catch (BeansException var5) {
                          this.destroySingleton(beanName);
                          throw var5;
                      }
                  });
                  bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
              //创建prototype的实例
              } else if (mbd.isPrototype()) {
                  var11 = null;

                  Object prototypeInstance;
                  try {
                      this.beforePrototypeCreation(beanName);
                      prototypeInstance = this.createBean(beanName, mbd, args);
                  } finally {
                      this.afterPrototypeCreation(beanName);
                  }

                  bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
              } else {
                  // 如果不是 singleton 和 prototype 的话，需要委托给相应的实现类来处理
                  String scopeName = mbd.getScope();
                  Scope scope = (Scope)this.scopes.get(scopeName);
                  if (scope == null) {
                      throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                  }

                  try {
                      Object scopedInstance = scope.get(beanName, () -> {
                          this.beforePrototypeCreation(beanName);

                          Object var4;
                          try {
                              var4 = this.createBean(beanName, mbd, args);
                          } finally {
                              this.afterPrototypeCreation(beanName);
                          }

                          return var4;
                      });
                      bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                  } catch (IllegalStateException var23) {
                      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);
                  }
              }
          } catch (BeansException var26) {
              this.cleanupAfterBeanCreationFailure(beanName);
              throw var26;
          }
      }
      //最后，检查一下类型对不对，不对的话就抛异常，对的话就返回了
      if (requiredType != null && !requiredType.isInstance(bean)) {
          try {
              T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
              if (convertedBean == null) {
                  throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
              } else {
                  return convertedBean;
              }
          } catch (TypeMismatchException var25) {
              if (this.logger.isTraceEnabled()) {
                  this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
              }

              throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
          }
      } else {
          return bean;
      }
  }

接下来分析createBean方法，创建bean实例。

//AbstractAutowireCapableBeanFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Creating instance of bean '" + beanName + "'");
        }

        RootBeanDefinition mbdToUse = mbd;
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        try {
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var9) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
        }

        Object beanInstance;
        try {
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if (beanInstance != null) {
                return beanInstance;
            }
        } catch (Throwable var10) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
        }

        try {
            //创建bean实例
            beanInstance = this.doCreateBean(beanName, mbdToUse, args);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Finished creating instance of bean '" + beanName + "'");
            }

            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
            throw var7;
        } catch (Throwable var8) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
        }
    }

//AbstractAutowireCapableBeanFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        //初始化bean
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

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

        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                }

                mbd.postProcessed = true;
            }
        }

        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }

            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }
        //初始化bean实例
        Object exposedObject = bean;

        try {
            //装配bean的属性
            this.populateBean(beanName, mbd, instanceWrapper);
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;
                    int var13 = dependentBeans.length;

                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dependentBean = var12[var14];
                        if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }

                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }

其实比较重要的就是createBeanInstance()创建实例的方法与populateBean（）装配属性的方法，接下来我们依次看这两个方法。

createBeanInstance

创建Bean实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
   // 确保已经加载了此 class
   Class<?> beanClass = resolveBeanClass(mbd, beanName);

   // 校验一下这个类的访问权限
   if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
   }

   if (mbd.getFactoryMethodName() != null)  {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // 如果不是第一次创建，比如第二次创建 prototype bean。
   // 这种情况下，我们可以从第一次创建知道，采用无参构造函数，还是构造函数依赖注入 来完成实例化
   boolean resolved = false;
   boolean autowireNecessary = false;
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true;
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }
   if (resolved) {
      if (autowireNecessary) {
         // 构造函数依赖注入
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
         // 无参构造函数
         return instantiateBean(beanName, mbd);
      }
   }

   // 判断是否采用有参构造函数
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
      // 构造函数依赖注入
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   // 调用无参构造函数
   return instantiateBean(beanName, mbd);
}

调用无参构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
   try {
      Object beanInstance;
      final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
         beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {

               return getInstantiationStrategy().instantiate(mbd, beanName, parent);
            }
         }, getAccessControlContext());
      }
      else {
         // 实例化
         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }
      // 包装一下，返回
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);
      return bw;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
   }
}

实例化的操作在beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);中，也就是一个InstantiationStrategy实例的instantiate()方法进行了实例化的操作。

//SimpleInstantiationStrategy.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
@Override
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {

   // 如果不存在方法覆写，那就使用 java 反射进行实例化，否则使用 CGLIB,
   // 方法覆写 请参见附录"方法注入"中对 lookup-method 和 replaced-method 的介绍
   if (bd.getMethodOverrides().isEmpty()) {
      Constructor<?> constructorToUse;
      synchronized (bd.constructorArgumentLock) {
         constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
         if (constructorToUse == null) {
            final Class<?> clazz = bd.getBeanClass();
            if (clazz.isInterface()) {
               throw new BeanInstantiationException(clazz, "Specified class is an interface");
            }
            try {
               if (System.getSecurityManager() != null) {
                  constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                     @Override
                     public Constructor<?> run() throws Exception {
                        return clazz.getDeclaredConstructor((Class[]) null);
                     }
                  });
               }
               else {
                  constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
               }
               bd.resolvedConstructorOrFactoryMethod = constructorToUse;
            }
            catch (Throwable ex) {
               throw new BeanInstantiationException(clazz, "No default constructor found", ex);
            }
         }
      }
      // 利用构造方法进行实例化
      return BeanUtils.instantiateClass(constructorToUse);
   }
   else {
      // 存在方法覆写，利用 CGLIB 来完成实例化，需要依赖于 CGLIB 生成子类，这里就不展开了。
      // tips: 因为如果不使用 CGLIB 的话，存在 override 的情况 JDK 并没有提供相应的实例化支持
      return instantiateWithMethodInjection(bd, beanName, owner);
   }
}

bean属性注入

接下来是populateBean()注入属性的方法

// AbstractAutowireCapableBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
   // bean 实例的所有属性都在这里了
   PropertyValues pvs = mbd.getPropertyValues();

   if (bw == null) {
      if (!pvs.isEmpty()) {
         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
      }
      else {
         // Skip property population phase for null instance.
         return;
      }
   }

   // 到这步的时候，bean 实例化完成（通过工厂方法或构造方法），但是还没开始属性设值，
   // InstantiationAwareBeanPostProcessor 的实现类可以在这里对 bean 进行状态修改，
   // 我也没找到有实际的使用，所以我们暂且忽略这块吧
   boolean continueWithPropertyPopulation = true;
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // 如果返回 false，代表不需要进行后续的属性设值，也不需要再经过其他的 BeanPostProcessor 的处理
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
               continueWithPropertyPopulation = false;
               break;
            }
         }
      }
   }

   if (!continueWithPropertyPopulation) {
      return;
   }

   if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

      // 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
         autowireByName(beanName, mbd, bw, newPvs);
      }

      // 通过类型装配。复杂一些
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
         autowireByType(beanName, mbd, bw, newPvs);
      }

      pvs = newPvs;
   }

   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
   boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

   if (hasInstAwareBpps || needsDepCheck) {
      PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
      if (hasInstAwareBpps) {
         for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
               InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
               // 这里有个非常有用的 BeanPostProcessor 进到这里: AutowiredAnnotationBeanPostProcessor
               // 对采用 @Autowired、@Value 注解的依赖进行设值，这里的内容也是非常丰富的，不过本文不会展开说了，感兴趣的读者请自行研究
               pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
               if (pvs == null) {
                  return;
               }
            }
         }
      }
      if (needsDepCheck) {
         checkDependencies(beanName, mbd, filteredPds, pvs);
      }
   }
   // 设置 bean 实例的属性值
   applyPropertyValues(beanName, mbd, bw, pvs);
}

至此，实例化Bean及属性注入的过程都完成了。

本文仅关注BeanFactory的创建以及Bean的实例化过程，忽略了与Bean生命周期有关的一些重要的细节，比如BeanPostProcessor等，关于bean的生命周期可以参考这篇文章

总结

IOC容器的原理可以总结如下：

  • 容器创建DefaultListableBeanFactory，用来存放BeanDefinition以及负责后续的初始化实例工作。
  • ResourceLoad读取配置文件为Resource对象，BeanDefinitionReader读取Resource指向的配置文件，把每个<bean>解析为一个BeanDefinition对象，保存在BeanDefitionRegistry中，即BeanFactory的hashmap中。
  • 容器扫描DefaultListableBeanFactory注册中心中的每个BeanDefinition，经过一系列的调用，最终通过InstantiateStrategy对象利用反射或CGLib进行Bean的实例创建，以及通过BeanWrapper对Bean的属性进行注入。
  • 单例Bean缓存池：Spring 在DefaultSingletonBeanRegistry类中提供了一个用于缓存单实例 Bean 的缓存器，它是一个用HashMap实现的缓存器，单实例的Bean以beanName为键保存在这个HashMap中
0%