Spring Ioc源码阅读

1
2
3

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
   this(new String[] {configLocation}, true, null);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

   super(parent);
    // 遍历configLocations，处理每一个元素，替换其中的占位符，并把结果赋值给this.configLocations
   setConfigLocations(configLocations);
   if (refresh) {
      refresh();
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public void setConfigLocations(@Nullable String... locations) {
   if (locations != null) {
      Assert.noNullElements(locations, "Config locations must not be null");
      this.configLocations = new String[locations.length];
      for (int i = 0; i < locations.length; i++) {
      // 处理占位符
         this.configLocations[i] = resolvePath(locations[i]).trim();
      }
   }
   else {
      this.configLocations = null;
   }
}

 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

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
       //准备refresh，主要是打印日志，标记启动状态closed为false，active为true，初始化一些占位符
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
       // 获取BeanFactory
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
       // 准备beanFactory，设置classloader，设置忽略一些自动装配接口，注册一些bean
       //注册的bean有environment，systemProperties，systemEnvironment
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
          //允许对beanFactory的后置处理，需要bean实现BeanFactoryPostProcessor接口
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
          //调用上面提到的BeanFactoryPostProcessor接口的实现类的postProcessBeanFactory方法
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
          //注册BeanPostProcessor的实现类
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
          //初始化MessageSource
         initMessageSource();

         // Initialize event multicaster for this context.
          //初始化事件广播器
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
          //可以初始化一些特殊的bean，默认方法为空
         onRefresh();

         // Check for listener beans and register them.
          //注册事件监听器
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
          // 完成单例bean的初始化
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
          //refresh结束，发布相应的事件
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

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

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

1
2
3
4

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   refreshBeanFactory();
   return getBeanFactory();
}

 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 (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
       // 创建beanFactory，new DefaultListableBeanFactory(getInternalParentBeanFactory())
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
       // 传入beanFactory，并设置允许是否运行beanDefinition的覆盖和是否允许循环引用
      customizeBeanFactory(beanFactory);
       // 加载bean定义
      loadBeanDefinitions(beanFactory);
      this.beanFactory = beanFactory;
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
    // 设置用哪个EntityResolver读取解析xml，调用DelegatingEntityResolver的构造方法，设置
    // dtdResolver类型为BeansDtdResolver，schemaResolver类型为PluggableSchemaResolver
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,
		// then proceed with actually loading the bean definitions.
    // 设置是否使用xml验证，默认true
		initBeanDefinitionReader(beanDefinitionReader);
    // 加载beanDefinitions
		loadBeanDefinitions(beanDefinitionReader);
	}

1
2
3
4

public ResourceEntityResolver(ResourceLoader resourceLoader) {
   super(resourceLoader.getClassLoader());
   this.resourceLoader = resourceLoader;
}

1
2
3
4

public DelegatingEntityResolver(@Nullable ClassLoader classLoader) {
   this.dtdResolver = new BeansDtdResolver();
   this.schemaResolver = new PluggableSchemaResolver(classLoader);
}

 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

public class BeansDtdResolver implements EntityResolver {

   private static final String DTD_EXTENSION = ".dtd";

   private static final String DTD_NAME = "spring-beans";

   private static final Log logger = LogFactory.getLog(BeansDtdResolver.class);


   @Override
   @Nullable
   public InputSource resolveEntity(@Nullable String publicId, @Nullable String systemId) throws IOException {
      if (logger.isTraceEnabled()) {
         logger.trace("Trying to resolve XML entity with public ID [" + publicId +
               "] and system ID [" + systemId + "]");
      }

       //如果xml的引用资源uri不为null且以.dtd结束,这里会将对外部资源的uri表示转换并获取jar包内已有的
       //可以在无网络连接的情况下正常使用
      if (systemId != null && systemId.endsWith(DTD_EXTENSION)) {
         int lastPathSeparator = systemId.lastIndexOf('/');
         int dtdNameStart = systemId.indexOf(DTD_NAME, lastPathSeparator);
         if (dtdNameStart != -1) {
             //spring-beans.dtd
            String dtdFile = DTD_NAME + DTD_EXTENSION;
            if (logger.isTraceEnabled()) {
               logger.trace("Trying to locate [" + dtdFile + "] in Spring jar on classpath");
            }
            try {
                //创建resource，实际文件位置在spring-beans这个jar包内的当前类的路径下
                //当前包org.springframework.beans.factory.xml，在包内可以找到spring-beans.dtd文件
               Resource resource = new ClassPathResource(dtdFile, getClass());
               InputSource source = new InputSource(resource.getInputStream());
               source.setPublicId(publicId);
               source.setSystemId(systemId);
               if (logger.isTraceEnabled()) {
                  logger.trace("Found beans DTD [" + systemId + "] in classpath: " + dtdFile);
               }
               return source;
            }
            catch (FileNotFoundException ex) {
               if (logger.isDebugEnabled()) {
                  logger.debug("Could not resolve beans DTD [" + systemId + "]: not found in classpath", ex);
               }
            }
         }
      }

      // Fall back to the parser's default behavior.
      return null;
   }


   @Override
   public String toString() {
      return "EntityResolver for spring-beans DTD";
   }

}

  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

public class PluggableSchemaResolver implements EntityResolver {

   /**
    * The location of the file that defines schema mappings.
    * Can be present in multiple JAR files.
    */
   public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";


   private static final Log logger = LogFactory.getLog(PluggableSchemaResolver.class);

   @Nullable
   private final ClassLoader classLoader;

   private final String schemaMappingsLocation;

   /** Stores the mapping of schema URL -> local schema path. */
   @Nullable
   private volatile Map<String, String> schemaMappings;


   /**
    * Loads the schema URL -> schema file location mappings using the default
    * mapping file pattern "META-INF/spring.schemas".
    * @param classLoader the ClassLoader to use for loading
    * (can be {@code null}) to use the default ClassLoader)
    * @see PropertiesLoaderUtils#loadAllProperties(String, ClassLoader)
    */
   public PluggableSchemaResolver(@Nullable ClassLoader classLoader) {
      this.classLoader = classLoader;
       //设置映射文件的位置在spring-beans的jar包内的META-INF/spring.schemas
      this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION;
   }

   /**
    * Loads the schema URL -> schema file location mappings using the given
    * mapping file pattern.
    * @param classLoader the ClassLoader to use for loading
    * (can be {@code null}) to use the default ClassLoader)
    * @param schemaMappingsLocation the location of the file that defines schema mappings
    * (must not be empty)
    * @see PropertiesLoaderUtils#loadAllProperties(String, ClassLoader)
    */
   public PluggableSchemaResolver(@Nullable ClassLoader classLoader, String schemaMappingsLocation) {
      Assert.hasText(schemaMappingsLocation, "'schemaMappingsLocation' must not be empty");
      this.classLoader = classLoader;
      this.schemaMappingsLocation = schemaMappingsLocation;
   }


   @Override
   @Nullable
   public InputSource resolveEntity(@Nullable String publicId, @Nullable String systemId) throws IOException {
      if (logger.isTraceEnabled()) {
         logger.trace("Trying to resolve XML entity with public id [" + publicId +
               "] and system id [" + systemId + "]");
      }

      if (systemId != null) {
          //获取schemaMapping
         String resourceLocation = getSchemaMappings().get(systemId);
         if (resourceLocation == null && systemId.startsWith("https:")) {
            // Retrieve canonical http schema mapping even for https declaration
             //从map中获取，相当于把网络上的uri转换成jar包内的文件的路径
            resourceLocation = getSchemaMappings().get("http:" + systemId.substring(6));
         }
         if (resourceLocation != null) {
            Resource resource = new ClassPathResource(resourceLocation, this.classLoader);
            try {
               InputSource source = new InputSource(resource.getInputStream());
               source.setPublicId(publicId);
               source.setSystemId(systemId);
               if (logger.isTraceEnabled()) {
                  logger.trace("Found XML schema [" + systemId + "] in classpath: " + resourceLocation);
               }
               return source;
            }
            catch (FileNotFoundException ex) {
               if (logger.isDebugEnabled()) {
                  logger.debug("Could not find XML schema [" + systemId + "]: " + resource, ex);
               }
            }
         }
      }

      // Fall back to the parser's default behavior.
      return null;
   }

   /**
    * Load the specified schema mappings lazily.
    */
   private Map<String, String> getSchemaMappings() {
      Map<String, String> schemaMappings = this.schemaMappings;
       //如果还没加载过就去加载
      if (schemaMappings == null) {
         synchronized (this) {
            schemaMappings = this.schemaMappings;
            if (schemaMappings == null) {
               if (logger.isTraceEnabled()) {
                  logger.trace("Loading schema mappings from [" + this.schemaMappingsLocation + "]");
               }
               try {
                   //读取META-INF/spring.schemas这个资源文件
                  Properties mappings =
                        PropertiesLoaderUtils.loadAllProperties(this.schemaMappingsLocation, this.classLoader);
                  if (logger.isTraceEnabled()) {
                     logger.trace("Loaded schema mappings: " + mappings);
                  }
                  schemaMappings = new ConcurrentHashMap<>(mappings.size());
                   //将资源转换成map
                  CollectionUtils.mergePropertiesIntoMap(mappings, schemaMappings);
                  this.schemaMappings = schemaMappings;
               }
               catch (IOException ex) {
                  throw new IllegalStateException(
                        "Unable to load schema mappings from location [" + this.schemaMappingsLocation + "]", ex);
               }
            }
         }
      }
      return schemaMappings;
   }


   @Override
   public String toString() {
      return "EntityResolver using schema mappings " + getSchemaMappings();
   }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
   // 默认为空，getConfigResources直接返回null
    Resource[] configResources = getConfigResources();
   if (configResources != null) {
       //传入Resource的方式加载BeanDefinition
      reader.loadBeanDefinitions(configResources);
   }
    // 获取之前setConfigLocations设置的configLocations
   String[] configLocations = getConfigLocations();
   if (configLocations != null) {
       // 传入路径的方式，内部会将路径转换成Resource，再调用上面的方法
      reader.loadBeanDefinitions(configLocations);
   }
}

1
2
3
4
5
6
7
8
9

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
   Assert.notNull(resources, "Resource array must not be null");
   int count = 0;
   for (Resource resource : resources) {
      count += loadBeanDefinitions(resource);
   }
    //发现的beanDefinition的数量
   return count;
}

1

int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;

1
2
3

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
   return loadBeanDefinitions(new EncodedResource(resource));
}

 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

//encodedResource，代表xml资源，并运行用来解析文件的编码
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
   Assert.notNull(encodedResource, "EncodedResource must not be null");
   if (logger.isTraceEnabled()) {
      logger.trace("Loading XML bean definitions from " + encodedResource);
   }

    //通过ThreadLocal获取currentResources
   Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

   if (!currentResources.add(encodedResource)) {
      throw new BeanDefinitionStoreException(
            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
   }

   try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
       //由InputStream创建xml的输入源InputSource对象
      InputSource inputSource = new InputSource(inputStream);
      if (encodedResource.getEncoding() != null) {
          //设置编码
         inputSource.setEncoding(encodedResource.getEncoding());
      }
       //读取BeanDefinition
      return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException(
            "IOException parsing XML document from " + encodedResource.getResource(), ex);
   }
   finally {
      currentResources.remove(encodedResource);
      if (currentResources.isEmpty()) {
         this.resourcesCurrentlyBeingLoaded.remove();
      }
   }
}

 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

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {

   try {
       //读取资源成xml文档对象
      Document doc = doLoadDocument(inputSource, resource);
       //注册beanDefinition
      int count = registerBeanDefinitions(doc, resource);
      if (logger.isDebugEnabled()) {
         logger.debug("Loaded " + count + " bean definitions from " + resource);
      }
      return count;
   }
   catch (BeanDefinitionStoreException ex) {
      throw ex;
   }
   catch (SAXParseException ex) {
      throw new XmlBeanDefinitionStoreException(resource.getDescription(),
            "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
   }
   catch (SAXException ex) {
      throw new XmlBeanDefinitionStoreException(resource.getDescription(),
            "XML document from " + resource + " is invalid", ex);
   }
   catch (ParserConfigurationException ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
            "Parser configuration exception parsing XML from " + resource, ex);
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
            "IOException parsing XML document from " + resource, ex);
   }
   catch (Throwable ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
            "Unexpected exception parsing XML document from " + resource, ex);
   }
}

1
2
3
4
5

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
//传入参数分别是inputSource:输入源,之前设置的entityResolver,errorHandler,当前资源的验证模式,是否xml命名空间感知
    return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
         getValidationModeForResource(resource), isNamespaceAware());
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
      ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

   DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
   if (logger.isTraceEnabled()) {
      logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
   }
   DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
   // 读取成Document对象
    return builder.parse(inputSource);
}

1
2
3
4
5
6
7

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
   int countBefore = getRegistry().getBeanDefinitionCount();
    //调用相关方法
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
   return getRegistry().getBeanDefinitionCount() - countBefore;
}

1
2
3
4

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
   this.readerContext = readerContext;
   doRegisterBeanDefinitions(doc.getDocumentElement());
}

 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

protected void doRegisterBeanDefinitions(Element root) {
   // Any nested <beans> elements will cause recursion in this method. In
   // order to propagate and preserve <beans> default-* attributes correctly,
   // keep track of the current (parent) delegate, which may be null. Create
   // the new (child) delegate with a reference to the parent for fallback purposes,
   // then ultimately reset this.delegate back to its original (parent) reference.
   // this behavior emulates a stack of delegates without actually necessitating one.
   BeanDefinitionParserDelegate parent = this.delegate;
   this.delegate = createDelegate(getReaderContext(), root, parent);

   if (this.delegate.isDefaultNamespace(root)) {
       // 读取资源文件中定义的profile
      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
      if (StringUtils.hasText(profileSpec)) {
         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
         // We cannot use Profiles.of(...) since profile expressions are not supported
         // in XML config. See SPR-12458 for details.
          // 验证是否是当前active的profile，如果不符合则直接返回
         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
            if (logger.isDebugEnabled()) {
               logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                     "] not matching: " + getReaderContext().getResource());
            }
            return;
         }
      }
   }

    //前置处理，空实现
   preProcessXml(root);
    // 解析beanDefinitions
   parseBeanDefinitions(root, this.delegate);
    //解析后处理，空实现
   postProcessXml(root);

   this.delegate = parent;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    //判断是否为默认的namespace，即http://www.springframework.org/schema/beans
   if (delegate.isDefaultNamespace(root)) {
      NodeList nl = root.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
         if (node instanceof Element) {
            Element ele = (Element) node;
             // 如果是默认的namespace
            if (delegate.isDefaultNamespace(ele)) {
               parseDefaultElement(ele, delegate);
            }
            else {
                //处理自定义的，通过this.namespaceHandlerResolver根据namespaceUri确定NamespaceHandler
                //比如aop里有AopNamespaceHandler，可以解析aop的namespace的config，aspectj-autoproxy，scoped-proxy，spring-configured这几种element
               delegate.parseCustomElement(ele);
            }
         }
      }
   }
   else {
      delegate.parseCustomElement(root);
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    // 解析import
   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
      importBeanDefinitionResource(ele);
   }
    //解析alias
   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
      processAliasRegistration(ele);
   }
    //解析bean
   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
      processBeanDefinition(ele, delegate);
   }
    //解析beans
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // recurse
       //递归调用之前的doRegisterBeanDefinitions
      doRegisterBeanDefinitions(ele);
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // Register the final decorated instance.
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // Send registration event.
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

1
2
3

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
   return parseBeanDefinitionElement(ele, null);
}

 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

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    //获取bean的id
   String id = ele.getAttribute(ID_ATTRIBUTE);
    //获取bean的name
   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

   List<String> aliases = new ArrayList<>();
    //如果name有内容
   if (StringUtils.hasLength(nameAttr)) {
       //通过name中的分隔符将定义的多个name分开
      String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
       //将得到的name数值添加到别名
      aliases.addAll(Arrays.asList(nameArr));
   }

   String beanName = id;
    // 如果id没有内容且别名list不为空
   if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
       //拿出别名list中第一个元素设为beanName
      beanName = aliases.remove(0);
      if (logger.isTraceEnabled()) {
         logger.trace("No XML 'id' specified - using '" + beanName +
               "' as bean name and " + aliases + " as aliases");
      }
   }

   if (containingBean == null) {
       //验证beanName是否有和其它的重复，在集合usedNames中查找，已经存在就error，否则在该集合中添加当前的beanName和别名list
      checkNameUniqueness(beanName, aliases, ele);
   }
//解析element
   AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
   if (beanDefinition != null) {
      if (!StringUtils.hasText(beanName)) {
         try {
            if (containingBean != null) {
               beanName = BeanDefinitionReaderUtils.generateBeanName(
                     beanDefinition, this.readerContext.getRegistry(), true);
            }
            else {
               beanName = this.readerContext.generateBeanName(beanDefinition);
               // Register an alias for the plain bean class name, if still possible,
               // if the generator returned the class name plus a suffix.
               // This is expected for Spring 1.2/2.0 backwards compatibility.
               String beanClassName = beanDefinition.getBeanClassName();
               if (beanClassName != null &&
                     beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                     !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                  aliases.add(beanClassName);
               }
            }
            if (logger.isTraceEnabled()) {
               logger.trace("Neither XML 'id' nor 'name' specified - " +
                     "using generated bean name [" + beanName + "]");
            }
         }
         catch (Exception ex) {
            error(ex.getMessage(), ele);
            return null;
         }
      }
      String[] aliasesArray = StringUtils.toStringArray(aliases);
       //以BeanDefinitionHolder方式返回
      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
   }

   return null;
}

 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

public AbstractBeanDefinition parseBeanDefinitionElement(
      Element ele, String beanName, @Nullable BeanDefinition containingBean) {

   this.parseState.push(new BeanEntry(beanName));

   String className = null;
   if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
       //获取class
      className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
   }
   String parent = null;
   if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
       //获取parent
      parent = ele.getAttribute(PARENT_ATTRIBUTE);
   }

   try {
       //创建beanDefintion，new GenericBeanDefinition()并设置parent，beanClass或beanClassName
      AbstractBeanDefinition bd = createBeanDefinition(className, parent);

       //解析各种attribute，如scope，autowiremode，init-method等并设置到beanDefinition中
      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

       //解析meta
      parseMetaElements(ele, bd);
       //解析lookup
      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
       //解析replacedMethod
      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

       //解析构造函数参数
      parseConstructorArgElements(ele, bd);
       //解析property
      parsePropertyElements(ele, bd);
       //解析qualifier
      parseQualifierElements(ele, bd);

      bd.setResource(this.readerContext.getResource());
      bd.setSource(extractSource(ele));

      return bd;
   }
   catch (ClassNotFoundException ex) {
      error("Bean class [" + className + "] not found", ele, ex);
   }
   catch (NoClassDefFoundError err) {
      error("Class that bean class [" + className + "] depends on not found", ele, err);
   }
   catch (Throwable ex) {
      error("Unexpected failure during bean definition parsing", ele, ex);
   }
   finally {
      this.parseState.pop();
   }

   return null;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
       //如果需要装饰beanDefinition
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // Register the final decorated instance.
          //注册beanDefinition
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // Send registration event.
       //发送注册事件,空实现
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public static void registerBeanDefinition(
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
      throws BeanDefinitionStoreException {

   // Register bean definition under primary name.
    //获取beanName
   String beanName = definitionHolder.getBeanName();
    // 在DefaultListableBeanFactory中的beanDefinitionMap，以beanName为key，beanDefinition为value放到beanDefinitionMap中
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

   // Register aliases for bean name, if any.
   String[] aliases = definitionHolder.getAliases();
   if (aliases != null) {
      for (String alias : aliases) {
          //注册别名，在SimpleAliasRegistry中的aliasMap放入key为alias，value为beanName并做一些相关的检查
         registry.registerAlias(beanName, alias);
      }
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

protected final void refreshBeanFactory() throws BeansException {
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      customizeBeanFactory(beanFactory);
      loadBeanDefinitions(beanFactory);
      this.beanFactory = beanFactory;
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

1
2
3
4

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   refreshBeanFactory();
   return getBeanFactory();
}

1
2
3
4
5
6
7
8

public final ConfigurableListableBeanFactory getBeanFactory() {
   DefaultListableBeanFactory beanFactory = this.beanFactory;
   if (beanFactory == null) {
      throw new IllegalStateException("BeanFactory not initialized or already closed - " +
            "call 'refresh' before accessing beans via the ApplicationContext");
   }
   return 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
55
56
57
58
59
60
61
62
63

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      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.
         registerBeanPostProcessors(beanFactory);

         // 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.
         finishBeanFactoryInitialization(beanFactory);

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

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

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

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

 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

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // Initialize conversion service for this context.
    //初始化conversion service
   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));
   }

   // Register a default embedded value resolver if no bean post-processor
   // (such as a PropertyPlaceholderConfigurer bean) registered any before:
   // at this point, primarily for resolution in annotation attribute values.
    //如果没有beanPostProcessor就注册一个默认的
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    //初始化LoadTimeWeaverAware bean
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

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

   // Allow for caching all bean definition metadata, not expecting further changes.
    //冻结配置，设置configurationFrozen为true，设置frozenBeanDefinitionNames为当前beanDefinitionNames
   beanFactory.freezeConfiguration();

   // Instantiate all remaining (non-lazy-init) singletons.
    //提前初始化单例非懒加载的bean，和直接用一些beanFactory不同，这里先把bean都初始化了
   beanFactory.preInstantiateSingletons();
}

 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

public void preInstantiateSingletons() throws BeansException {
   if (logger.isTraceEnabled()) {
      logger.trace("Pre-instantiating singletons in " + this);
   }

   // Iterate over a copy to allow for init methods which in turn register new bean definitions.
   // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   // Trigger initialization of all non-lazy singleton beans...
    //加载所有的非懒加载的单例bean
   for (String beanName : beanNames) {
       //合并parent bean的配置并获取为RootBeanDefinition
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
       //检查beanDefinition，不能是abstract，需要是singleton，且不是懒加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
          //判断是否为factoryBean
         if (isFactoryBean(beanName)) {
             //factoryBean需要在beanName前添加前缀'&'
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
               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);
               }
            }
         }
          //如果不是factoryBean直接getBean，一般的bean都是直接到这里
         else {
            getBean(beanName);
         }
      }
   }

   // Trigger post-initialization callback for all applicable beans...
    //完成以上所有bean的初始化后，调用实现了SmartInitializingSingleton接口的bean的afterSingletonsInstantiated方法
   for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
      if (singletonInstance instanceof SmartInitializingSingleton) {
         SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                //这一行就是调用afterSingletonsInstantiated方法
               smartSingleton.afterSingletonsInstantiated();
               return null;
            }, getAccessControlContext());
         }
         else {
             //这一行就是调用afterSingletonsInstantiated方法
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

1
2
3

public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

  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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

protected <T> T doGetBean(
      String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
      throws BeansException {

    //获取一个典范的beanName，对别名和之前提到的factoryBean做了一些处理
   String beanName = transformedBeanName(name);
   Object bean;

   // Eagerly check singleton cache for manually registered singletons.
    //尝试获取单例，一般这里由于还没有创建会返回null
   Object sharedInstance = getSingleton(beanName);
    //条件中sharedInstance不为null且args为null说明是在尝试获取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);
   }
//
   else {
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      if (isPrototypeCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
      }

      // Check if bean definition exists in this factory.
       //检查这个factory中是否已经存在该beanDefinition
      BeanFactory parentBeanFactory = getParentBeanFactory();
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
         // Not found -> check parent.
         String nameToLookup = originalBeanName(name);
         if (parentBeanFactory instanceof AbstractBeanFactory) {
            return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                  nameToLookup, requiredType, args, typeCheckOnly);
         }
         else if (args != null) {
            // Delegation to parent with explicit args.
            return (T) parentBeanFactory.getBean(nameToLookup, args);
         }
         else if (requiredType != null) {
            // No args -> delegate to standard getBean method.
            return parentBeanFactory.getBean(nameToLookup, requiredType);
         }
         else {
            return (T) parentBeanFactory.getBean(nameToLookup);
         }
      }

      if (!typeCheckOnly) {
          //标记当前bean为已创建，实际是在AbstractBeanFactory的集合alreadyCreated中添加该beanName
         markBeanAsCreated(beanName);
      }

      try {
          //从mergedBeanDefinitions取出beanDefinition进行判断
          //如果已经存在且不需要合并，则直接返回
          //否则从之前obtainFreshBeanFactory加载beanDefinition后放入的beanDefinitionMap中获取beanDefinition并再调用getMergedBeanDefinition(beanName, getBeanDefinition(beanName))进行merge
          //完成后将在mergedBeanDefinition中放入，key为beanName，值为合并后的mergedBeanDefinition
         RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
          //检查这个mergedBeanDefinition
         checkMergedBeanDefinition(mbd, beanName, args);

         // Guarantee initialization of beans that the current bean depends on.
          //通过beanDefinition获取定义的depends-on的bean
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
            for (String dep : dependsOn) {
                //判断依赖关系，从dependentBeanMap中取得key为beanName对应的集合，如果该集合包含了beanName
                //说明这里的beanName对应的bean和dep对应的bean互相为depends-on，就会报错
               if (isDependent(beanName, dep)) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
               }
                //注册依赖关系，在dependentBeanMap中，会放入key为dep，值为beanName的Set
                //即dependentBeanMap.computeIfAbsent方法
                //然后尝试添加beanName到集合中
                //在dependenciesForBeanMap中，会放入key为beanName，value为dep的Set
                //且尝试添加dep到集合中
               registerDependentBean(dep, beanName);
               try {
                   //这里让被依赖的bean先初始化，这里的getBean就是之前的getBean
                   //初始化dep时会重新走到上方的isDependent方法处
                  getBean(dep);
               }
               catch (NoSuchBeanDefinitionException ex) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
               }
            }
         }
//假设这里A，B互相为depends-on
//getBean(A)	在初始化A时
//beanName = A
//dependsOn = [B]
//isDepedent(A,B) --> false
//registerDependentBean(B, A)
//
//	dependentBeanMap内部情况
//		key	 value
//		B         {A}
//	dependenciesForBeanMap内部情况
//		key 	 value
//		A         {B}
//          
//然后加载A依赖的bean B
//getBean(B)
//beanName = B
//dependsOn = [A]
//isDependent(B,A)方法
//dependentBeanMap.get(B) --> {A}
//{A}.contains(A) --> return true

          

          //这里开始创建bean
          
         // Create bean instance.          
          //如果是单例
         if (mbd.isSingleton()) {
             //getSingleton(String beanName, ObjectFactory<?> singletonFactory)
             //传入lambda
            sharedInstance = getSingleton(beanName, () -> {
               try {
                   // 在上面的getSingleton中方法内部将会使用这个singletonFactory并调用其getObject方法在这里的实现
                  return createBean(beanName, mbd, args);
               }
               catch (BeansException ex) {
                  // Explicitly remove instance from singleton cache: It might have been put there
                  // eagerly by the creation process, to allow for circular reference resolution.
                  // Also remove any beans that received a temporary reference to the bean.
                  destroySingleton(beanName);
                  throw ex;
               }
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }

          //如果是prototype
         else if (mbd.isPrototype()) {
            // It's a prototype -> create a new instance.
            Object prototypeInstance = null;
            try {
               beforePrototypeCreation(beanName);
               prototypeInstance = createBean(beanName, mbd, args);
            }
            finally {
               afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
         }

          //其它类型的scope
         else {
            String scopeName = mbd.getScope();
            if (!StringUtils.hasLength(scopeName)) {
               throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
            }
            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, () -> {
                  beforePrototypeCreation(beanName);
                  try {
                     return createBean(beanName, mbd, args);
                  }
                  finally {
                     afterPrototypeCreation(beanName);
                  }
               });
               bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
            }
            catch (IllegalStateException ex) {
               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",
                     ex);
            }
         }
      }
      catch (BeansException ex) {
         cleanupAfterBeanCreationFailure(beanName);
         throw ex;
      }
   }

   // Check if required type matches the type of the actual bean instance.
    //检查类型并返回bean
   if (requiredType != null && !requiredType.isInstance(bean)) {
      try {
         T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
         if (convertedBean == null) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
         }
         return convertedBean;
      }
      catch (TypeMismatchException ex) {
         if (logger.isTraceEnabled()) {
            logger.trace("Failed to convert bean '" + name + "' to required type '" +
                  ClassUtils.getQualifiedName(requiredType) + "'", ex);
         }
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
   }
   return (T) bean;
}

1
2
3

public Object getSingleton(String beanName) {
   return getSingleton(beanName, true);
}

 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 Object getSingleton(String beanName, boolean allowEarlyReference) {
    //从singletonObjects这个map中获取，key为beanName的bean
   Object singletonObject = this.singletonObjects.get(beanName);
    
    //如果为null且singletonCurrentlyInCreation这个set中有beanName
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
          //从earlySingletonObjects这个map中获取key为beanName的bean
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
             //从singletonFactories中获取key为beanName的objectFactory
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
                //使用objectFactory的getObject创建earlySingletonObject
               singletonObject = singletonFactory.getObject();
                //放入earlySingletonObjects中
               this.earlySingletonObjects.put(beanName, singletonObject);
                //从singletonFactories中移除这个objectFactory
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

 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

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(beanName, "Bean name must not be null");
   synchronized (this.singletonObjects) {
       //先尝试从singletonObjects这个map中获取key为beanName的bean
      Object singletonObject = this.singletonObjects.get(beanName);
       //这里不存在，如果已经存在了将会直接返回
      if (singletonObject == null) {
         if (this.singletonsCurrentlyInDestruction) {
            throw new BeanCreationNotAllowedException(beanName,
                  "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                  "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
         }
         if (logger.isDebugEnabled()) {
            logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
         }
          //前置方法，判断其不在inCreationCheckExclusions中，同时尝试在singletonCurrentlyInCreation这个集合中添加beanName
          //如果添加失败说明已经正在创建该bean了，抛出异常
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
             //这里会调用之前传入的objectFactory的lambda中的createBean方法
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
         catch (IllegalStateException ex) {
            // Has the singleton object implicitly appeared in the meantime ->
            // if yes, proceed with it since the exception indicates that state.
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               throw ex;
            }
         }
         catch (BeanCreationException ex) {
            if (recordSuppressedExceptions) {
               for (Exception suppressedException : this.suppressedExceptions) {
                  ex.addRelatedCause(suppressedException);
               }
            }
            throw ex;
         }
         finally {
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = null;
            }
             //后置方法，判断其不在inCreationCheckExclusions中，并尝试从singletonCurrentlyInCreation集合中移除beanName，如果移除失败也会抛出异常
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
             //在singletonObjects这个map中添加key为beanName，value为singletonObject
             //在singletonObejcts中移除key为beanName的键值对
             //在earlySingletonObjects中移除key为beanName的键值对
             //在registeredSingletons这个集合中添加beanName
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

 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

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

   if (logger.isTraceEnabled()) {
      logger.trace("Creating instance of bean '" + beanName + "'");
   }
   RootBeanDefinition mbdToUse = mbd;

   // 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);
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }

    //准备method overrides
   // Prepare method overrides.
   try {
      mbdToUse.prepareMethodOverrides();
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
   }

   try {
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
       //给BeanPostProcessors一个返回代理对象的机会
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
         return bean;
      }
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
            "BeanPostProcessor before instantiation of bean failed", ex);
   }

   try {
       //创建bean
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isTraceEnabled()) {
         logger.trace("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
   }
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      // A previously detected exception with proper bean creation context already,
      // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
      throw ex;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
   }
}

  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

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

   // Instantiate the bean.
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
    //不是factoryBean的情况
   if (instanceWrapper == null) {
       //创建bean实例
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
    //取出instanceWrapper中的bean实例
   Object bean = instanceWrapper.getWrappedInstance();
   Class<?> beanType = instanceWrapper.getWrappedClass();
   if (beanType != NullBean.class) {
      mbd.resolvedTargetType = beanType;
   }

   // Allow post-processors to modify the merged bean definition.
    //允许post-processors修改mergedBeanDefinition
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Post-processing of merged bean definition failed", ex);
         }
         mbd.postProcessed = true;
      }
   }

   // Eagerly cache singletons to be able to resolve circular references
   // even when triggered by lifecycle interfaces like BeanFactoryAware.
    //是否为单例，允许循环引用，且当期bean正在创建中（在singletonCurrentlyInCreation集合中）
   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
         isSingletonCurrentlyInCreation(beanName));
   if (earlySingletonExposure) {
      if (logger.isTraceEnabled()) {
         logger.trace("Eagerly caching bean '" + beanName +
               "' to allow for resolving potential circular references");
      }
       //添加key为beanName，value为下面的lambda的objectFactory到singletonFactories中
       //移除earlySingletonObjects中的key为beanName的value
       //在registeredSingletons集合中添加beanName
       //lambda对应返回earlyBeanReference，一般情况会返回传入的bean
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
   }

   // Initialize the bean instance.
   Object exposedObject = bean;
   try {
       //给bean设值
      populateBean(beanName, mbd, instanceWrapper);
       //各种回调，init-method，BeanPostProcessor等
      exposedObject = initializeBean(beanName, exposedObject, mbd);
   }
   catch (Throwable ex) {
      if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
         throw (BeanCreationException) ex;
      }
      else {
         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
      }
   }

    //与循环引用相关
   if (earlySingletonExposure) {
       //与以前的getSingleton不同，这次allowEarlyReference为false
       //从之前提到的singletonObjects这个map中获取key为beanName的bean
       //如果为null且当前bean还在创建过程中，就从earlySingletonObjects这个map中获取
       //由于allowEarlyReference为false这里不允许获取singletonFactories中beanName对应的objectFactory创建早期对象
      Object earlySingletonReference = getSingleton(beanName, false);
      if (earlySingletonReference != null) {
         if (exposedObject == bean) {
            exposedObject = earlySingletonReference;
         }
         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            String[] dependentBeans = getDependentBeans(beanName);
            Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
            for (String dependentBean : dependentBeans) {
               if (!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 " +
                     "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
            }
         }
      }
   }

   // Register bean as disposable.
   try {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
   }

   return exposedObject;
}

 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

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   // Make sure bean class is actually resolved at this point.
   Class<?> beanClass = resolveBeanClass(mbd, beanName);

    //检验bean的class和访问权限
   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());
   }

   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }
    //工厂方法相关
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // Shortcut when re-creating the same 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) {
          //构造函数方式的autowire
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
          //没有构造函数autowire的需求，无参构造
         return instantiateBean(beanName, mbd);
      }
   }

   // Candidate constructors for autowiring?
    //如果是有参数构造函数
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
       //有参构造函数autowire
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   // Preferred constructors for default construction?
   ctors = mbd.getPreferredConstructors();
   if (ctors != null) {
      return autowireConstructor(beanName, mbd, ctors, null);
   }

   // No special handling: simply use no-arg constructor.
    //无特殊处理，使用无参构造函数
   return instantiateBean(beanName, mbd);
}