Spring IOC 从实例读源码

更为完整的笔记的传送门 Github

实例

public class Main {    public static void main(String[] args) {        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");        UserService userService = (UserService) applicationContext.getBean("userService");        userService.login();    }}public interface UserService {    void login();}@Service("userService")public class UserServiceImpl implements UserService{    @Override    public void login() {        System.out.println("login...");    }}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="        http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/context        http://www.springframework.org/schema/context/spring-context.xsd        ">    <context:component-scan            base-package=                    "cn.sinjinsong.ioc"/></beans>

约定

方法调用顺序约定

这里用 1.1) 、1.2) 来表示1)方法中的比较重要的步骤1和步骤2。
另外并不是从一开始就进行编号，而是到重要的方法时才开始编号。

public class Main {    public static void main(String[] args) {        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");        UserService userService = (UserService) applicationContext.getBean("userService");        userService.login();    }}

比如Main类中的main方法记为1)，则可以将new ClassPathXmlApplicationContext记为1.1)，将getBean记为1.2)。

关注点约束

我们只关注源码中的核心的业务逻辑，由于Spring过于复杂，所以哪怕只掌握其核心逻辑就很不容易了。另外文章是从实例看源码的，所以可能源码中有多条执行路径，但我们只关注实例中经过的逻辑，其他的执行路径可能会被忽略。

IOC概述

IOC本质上是Spring管理一个容器，容器是BeanFactory的实现，容器中管理了所有用户指定的bean（xml或注解），最底层就是一个Map

bean的注册

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

called（调用了）

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

called

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)        throws BeansException {    super(parent);    setConfigLocations(configLocations);    if (refresh) {        refresh();    }}

从这里开始会涉及到bean的注册这个步骤中最重要的一个方法：refresh。
这个方法除了在普通Java项目中会被调用，在JavaWeb项目中使用到的WebApplicationContext中也会被调用。一定要注意这个方法。
refresh方法完成了beanFactory的整个加载过程。

public void refresh() throws BeansException, IllegalStateException {   synchronized (this.startupShutdownMonitor) {      // 准备 刷新的上下文环境      prepareRefresh();      // 初始化BeanFactory，并进行XML文件的读取      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();      // 对BeanFactory进行各种功能填充      prepareBeanFactory(beanFactory);      try {         // 子类覆盖方法做额外的处理         postProcessBeanFactory(beanFactory);         // 激活各种BeanFactory处理器         invokeBeanFactoryPostProcessors(beanFactory);         // 注册拦截Bean创建的Bean处理器，这里只是注册，真正的调用是在getBean的时候         registerBeanPostProcessors(beanFactory);         // 为上下文初始化Message源，即不同语言的消息体，国际化处理         initMessageSource();         // 初始化应用消息广播器，并放入applicationEventMulticaster bean中         initApplicationEventMulticaster();         // 留给子类来初始化其他bean         onRefresh();         // 在所有注册的bean中查找Listener bean，注册到消息广播器中         registerListeners();         // 初始化剩下的单例实例（除了lazy-init）         finishBeanFactoryInitialization(beanFactory);         // 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人         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();      }   }}

比较重要的方法有两个，一个是obtainFreshBeanFactory，读取到所有的beanDefinition（bean的定义，比如xml配置文件中的中定义的，或者@Component、@Service等标记的bean），并保存到beanFactroy中；另一个是finishBeanFactoryInitialization，加载所有非延迟加载的、单例的bean
从这里开始进行方法的编号。

1) obtainFreshBeanFactory（加载beanDefinition）

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {   refreshBeanFactory();   ConfigurableListableBeanFactory beanFactory = getBeanFactory();   if (logger.isDebugEnabled()) {      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);   }   return beanFactory;}主要逻辑在refreshBeanFactory中实现

1.1) refreshBeanFactory

protected final void refreshBeanFactory() throws BeansException {   if (hasBeanFactory()) {      destroyBeans();      closeBeanFactory();   }   try {      DefaultListableBeanFactory beanFactory = createBeanFactory();      beanFactory.setSerializationId(getId());      customizeBeanFactory(beanFactory);    //该方法最终调用XmlBeanDefinitionReader类中loadBeanDefinitions(EncodedResource)      loadBeanDefinitions(beanFactory);      synchronized (this.beanFactoryMonitor) {         this.beanFactory = beanFactory;      }   }   catch (IOException ex) {      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);   }}

1.1.1) loadBeanDefinitions(beanFactory) （创建reader）

创建了XmlBeanDefinitionReader ，用它去读取xml配置文件。

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);   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));   // Allow a subclass to provide custom initialization of the reader,   // then proceed with actually loading the bean definitions.   initBeanDefinitionReader(beanDefinitionReader);   // 主要逻辑   loadBeanDefinitions(beanDefinitionReader);}

1.1.1.1) loadBeanDefinitions(beanDefinitionReader)

执行时configResources为null，configLocations为一个String []{“applicationContext.xml”}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {   Resource[] configResources = getConfigResources();   if (configResources != null) {      reader.loadBeanDefinitions(configResources);   }   String[] configLocations = getConfigLocations();   if (configLocations != null) {      // 交由reader去加载beanDefinition      reader.loadBeanDefinitions(configLocations);   }}

1.1.1.1.1) XmlBeanDefinitionReader.loadBeanDefinitions（解析标签）

public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {   Assert.notNull(locations, "Location array must not be null");   int counter = 0;   for (String location : locations) {      counter += loadBeanDefinitions(location);   }   return counter;}

called loadBeanDefinitions(location,null)
location就是applicationContext.xml

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {   ResourceLoader resourceLoader = getResourceLoader();   if (resourceLoader == null) {      throw new BeanDefinitionStoreException(            "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");   }   if (resourceLoader instanceof ResourcePatternResolver) {      // Resource pattern matching available.      try {         Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);         // 加载         int loadCount = loadBeanDefinitions(resources);         if (actualResources != null) {            for (Resource resource : resources) {               actualResources.add(resource);            }         }         if (logger.isDebugEnabled()) {            logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");         }         return loadCount;      }      catch (IOException ex) {         throw new BeanDefinitionStoreException(               "Could not resolve bean definition resource pattern [" + location + "]", ex);      }   }   else {      // Can only load single resources by absolute URL.      Resource resource = resourceLoader.getResource(location);      int loadCount = loadBeanDefinitions(resource);      if (actualResources != null) {         actualResources.add(resource);      }      if (logger.isDebugEnabled()) {         logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");      }      return loadCount;   }}

called loadBeanDefinitions(resources)
resource是有一个元素的数组，该元素为applicationContext.xml，Spring将该xml文件抽象为一个Resource

    public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {        Assert.notNull(resources, "Resource array must not be null");        int counter = 0;        for (Resource resource : resources) {            counter += loadBeanDefinitions(resource);        }        return counter;    }

called loadBeanDefinitions(resource)

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {   // 将resouce又封装了一层，变为EncodedResource   return loadBeanDefinitions(new EncodedResource(resource));}

called loadBeanDefinitions(new EncodedResource(resource))
这里是将xml文件读进来，变为inputStream

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {   Assert.notNull(encodedResource, "EncodedResource must not be null");   if (logger.isInfoEnabled()) {      logger.info("Loading XML bean definitions from " + encodedResource.getResource());   }   Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();   if (currentResources == null) {      currentResources = new HashSet<EncodedResource>(4);      this.resourcesCurrentlyBeingLoaded.set(currentResources);   }   if (!currentResources.add(encodedResource)) {      throw new BeanDefinitionStoreException(            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");   }   try {      InputStream inputStream = encodedResource.getResource().getInputStream();      try {         InputSource inputSource = new InputSource(inputStream);         if (encodedResource.getEncoding() != null) {            inputSource.setEncoding(encodedResource.getEncoding());         }         // 真正的加载beanDefinition         return doLoadBeanDefinitions(inputSource, encodedResource.getResource());      }      finally {         inputStream.close();      }   }   catch (IOException ex) {      throw new BeanDefinitionStoreException(            "IOException parsing XML document from " + encodedResource.getResource(), ex);   }   finally {      currentResources.remove(encodedResource);      if (currentResources.isEmpty()) {         this.resourcesCurrentlyBeingLoaded.remove();      }   }}

called doLoadBeanDefinitions(inputSource, encodedResource.getResource())
这里是把inputStream转为了一个document，document是XML DOM解析方式的解析结果，详情请了解XML DOM。
直接看把document转为beanDefinitions的过程。

doLoadBeanDefinitions

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)      throws BeanDefinitionStoreException {   try {      Document doc = doLoadDocument(inputSource, resource);      return registerBeanDefinitions(doc, resource);   }   catch (BeanDefinitionStoreException ex) {      throw ex;   }   ...}

called registerBeanDefinitions(doc, resource)

registerBeanDefinitions

又将解析document的任务委托给了BeanDefinitionDocumentReader

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

called documentReader.registerBeanDefinitions(doc, createReaderContext(resource))

documentReader.registerBeanDefinitions

实现类是DefaultBeanDefinitionDocumentReader

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {   this.readerContext = readerContext;   logger.debug("Loading bean definitions");   Element root = doc.getDocumentElement();   doRegisterBeanDefinitions(root);}

called doRegisterBeanDefinitions

doRegisterBeanDefinitions

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)) {      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);      if (StringUtils.hasText(profileSpec)) {         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {            if (logger.isInfoEnabled()) {               logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +                     "] not matching: " + getReaderContext().getResource());            }            return;         }      }   }   preProcessXml(root);   // 核心逻辑   parseBeanDefinitions(root, this.delegate);   postProcessXml(root);   this.delegate = parent;}

called parseBeanDefinitions(root, this.delegate)

parseBeanDefinitions（解析标签）

这里会将默认标签和自定义标签分开解析，我们在applicationContext.xml中定义了一个component-scan标签，Spring将其视为自定义标签。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {   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;            if (delegate.isDefaultNamespace(ele)) {               // 默认标签               parseDefaultElement(ele, delegate);            }            else {               // 自定义标签               delegate.parseCustomElement(ele);            }         }      }   }   else {      delegate.parseCustomElement(root);   }}

called delegate.parseCustomElement(ele)

NamespaceHandlerSupport.parse

这里用到的deletgate是NamespaceHandlerSupport类型的。

public BeanDefinition parse(Element element, ParserContext parserContext) {   return findParserForElement(element, parserContext).parse(element, parserContext);}

a) findParserForElement（查找parser）

返回的parser是ComponentScanBeanDefinitionParser类型。

private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {   String localName = parserContext.getDelegate().getLocalName(element);   BeanDefinitionParser parser = this.parsers.get(localName);   if (parser == null) {      parserContext.getReaderContext().fatal(            "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);   }   return parser;}

b) ComponentScanBeanDefinitionParser.parse

public BeanDefinition parse(Element element, ParserContext parserContext) {   String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);   basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);   String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,         ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);   // Actually scan for bean definitions and register them.   ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);   Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);   registerComponents(parserContext.getReaderContext(), beanDefinitions, element);   return null;}

1) ClassPathBeanDefinitionScanner.doScan（解析注解定义的bean）

该方法会根据component-scan中定义的包名去classpath搜索所有的class文件，读入class文件，然后判断是否有@Component等注解，然后将其转为beanDefinition。最后放入beanFactory的成员变量Map<beanName,beanDefinition>中。有两个关键方法：findCandidateComponents和registerBeanDefinition。前者会找到所有需要管理的bean对应的beanDefinitions，后者会将其注册到BeanFactory中。

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {   Assert.notEmpty(basePackages, "At least one base package must be specified");   Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();   for (String basePackage : basePackages) {      Set<BeanDefinition> candidates = findCandidateComponents(basePackage);      for (BeanDefinition candidate : candidates) {         ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);         candidate.setScope(scopeMetadata.getScopeName());         String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);         if (candidate instanceof AbstractBeanDefinition) {            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);         }         if (candidate instanceof AnnotatedBeanDefinition) {            AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);         }         if (checkCandidate(beanName, candidate)) {            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);            definitionHolder =                  AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);            beanDefinitions.add(definitionHolder);            registerBeanDefinition(definitionHolder, this.registry);         }      }   }   return beanDefinitions;}

1.1) findCandidateComponents

该方法会分为三个步骤：
1. 拿到所有的未经筛选的class文件，并抽象为Resource
2. 读取所有的class文件
3. 逐个判断是否是需要的bean

public Set<BeanDefinition> findCandidateComponents(String basePackage) {   Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();   try {      String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +            resolveBasePackage(basePackage) + '/' + this.resourcePattern;// 这里是未加筛选的拿到了所有class文件      Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);      boolean traceEnabled = logger.isTraceEnabled();      boolean debugEnabled = logger.isDebugEnabled();      for (Resource resource : resources) {         if (traceEnabled) {            logger.trace("Scanning " + resource);         }         if (resource.isReadable()) {            try {// 这里会把class文件读进来               MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);// 判断class文件是否是注册在Spring中的bean类型               if (isCandidateComponent(metadataReader)) {                  ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);                  sbd.setResource(resource);                  sbd.setSource(resource);                  if (isCandidateComponent(sbd)) {                     if (debugEnabled) {                        logger.debug("Identified candidate component class: " + resource);                     }                     candidates.add(sbd);                  }                  else {                     if (debugEnabled) {                        logger.debug("Ignored because not a concrete top-level class: " + resource);                     }                  }               }               else {                  if (traceEnabled) {                     logger.trace("Ignored because not matching any filter: " + resource);                  }               }            }            catch (Throwable ex) {               throw new BeanDefinitionStoreException(                     "Failed to read candidate component class: " + resource, ex);            }         }         else {            if (traceEnabled) {               logger.trace("Ignored because not readable: " + resource);            }         }      }   }   catch (IOException ex) {      throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);   }   return candidates;}

1.1.1) PathMatchingResourcePatternResolver.getResources

public Resource[] getResources(String locationPattern) throws IOException {   Assert.notNull(locationPattern, "Location pattern must not be null");   if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {      // a class path resource (multiple resources for same name possible)      if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {         // a class path resource pattern         return findPathMatchingResources(locationPattern);      }      else {         // all class path resources with the given name         return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));      }   }   else {      // Only look for a pattern after a prefix here      // (to not get fooled by a pattern symbol in a strange prefix).      int prefixEnd = locationPattern.indexOf(":") + 1;      if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {         // a file pattern         return findPathMatchingResources(locationPattern);      }      else {         // a single resource with the given name         return new Resource[] {getResourceLoader().getResource(locationPattern)};      }   }}

1.1.1.1) findPathMatchingResources

protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {   String rootDirPath = determineRootDir(locationPattern);   String subPattern = locationPattern.substring(rootDirPath.length());// 根路径，component-scan中配置的包名   Resource[] rootDirResources = getResources(rootDirPath);   Set<Resource> result = new LinkedHashSet<Resource>(16);   for (Resource rootDirResource : rootDirResources) {      rootDirResource = resolveRootDirResource(rootDirResource);      URL rootDirURL = rootDirResource.getURL();      if (equinoxResolveMethod != null) {         if (rootDirURL.getProtocol().startsWith("bundle")) {            rootDirURL = (URL) ReflectionUtils.invokeMethod(equinoxResolveMethod, null, rootDirURL);            rootDirResource = new UrlResource(rootDirURL);         }      }      if (rootDirURL.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {         result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirURL, subPattern, getPathMatcher()));      }      else if (ResourceUtils.isJarURL(rootDirURL) || isJarResource(rootDirResource)) {         result.addAll(doFindPathMatchingJarResources(rootDirResource, rootDirURL, subPattern));      }      else {         result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));      }   }   if (logger.isDebugEnabled()) {      logger.debug("Resolved location pattern [" + locationPattern + "] to resources " + result);   }   return result.toArray(new Resource[result.size()]);}

1.1.1.1.1) doFindPathMatchingFileResources

protected Set<Resource> doFindPathMatchingFileResources(Resource rootDirResource, String subPattern)      throws IOException {   File rootDir;   try {      rootDir = rootDirResource.getFile().getAbsoluteFile();   }   catch (IOException ex) {      if (logger.isWarnEnabled()) {         logger.warn("Cannot search for matching files underneath " + rootDirResource +               " because it does not correspond to a directory in the file system", ex);      }      return Collections.emptySet();   }   return doFindMatchingFileSystemResources(rootDir, subPattern);}

called doFindMatchingFileSystemResources

protected Set<Resource> doFindMatchingFileSystemResources(File rootDir, String subPattern) throws IOException {   if (logger.isDebugEnabled()) {      logger.debug("Looking for matching resources in directory tree [" + rootDir.getPath() + "]");   }   // 读取文件夹下面的文件   Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern);   Set<Resource> result = new LinkedHashSet<Resource>(matchingFiles.size());   for (File file : matchingFiles) {      result.add(new FileSystemResource(file));   }   return result;}

1.1.1.1.1.1) retrieveMatchingFiles

protected Set<File> retrieveMatchingFiles(File rootDir, String pattern) throws IOException {   if (!rootDir.exists()) {      // Silently skip non-existing directories.      if (logger.isDebugEnabled()) {         logger.debug("Skipping [" + rootDir.getAbsolutePath() + "] because it does not exist");      }      return Collections.emptySet();   }   if (!rootDir.isDirectory()) {      // Complain louder if it exists but is no directory.      if (logger.isWarnEnabled()) {         logger.warn("Skipping [" + rootDir.getAbsolutePath() + "] because it does not denote a directory");      }      return Collections.emptySet();   }   if (!rootDir.canRead()) {      if (logger.isWarnEnabled()) {         logger.warn("Cannot search for matching files underneath directory [" + rootDir.getAbsolutePath() +               "] because the application is not allowed to read the directory");      }      return Collections.emptySet();   }   String fullPattern = StringUtils.replace(rootDir.getAbsolutePath(), File.separator, "/");   if (!pattern.startsWith("/")) {      fullPattern += "/";   }   fullPattern = fullPattern + StringUtils.replace(pattern, File.separator, "/");   Set<File> result = new LinkedHashSet<File>(8);   // 真正的逻辑   doRetrieveMatchingFiles(fullPattern, rootDir, result);   return result;}

1.1.1.1.1.1.1) doRetrieveMatchingFiles（递归方法）

protected void doRetrieveMatchingFiles(String fullPattern, File dir, Set<File> result) throws IOException {   if (logger.isDebugEnabled()) {      logger.debug("Searching directory [" + dir.getAbsolutePath() +            "] for files matching pattern [" + fullPattern + "]");   }// 拿到component-scan目录下的所有class文件   File[] dirContents = dir.listFiles();   if (dirContents == null) {      if (logger.isWarnEnabled()) {         logger.warn("Could not retrieve contents of directory [" + dir.getAbsolutePath() + "]");      }      return;   }   Arrays.sort(dirContents);   for (File content : dirContents) {      String currPath = StringUtils.replace(content.getAbsolutePath(), File.separator, "/");      if (content.isDirectory() && getPathMatcher().matchStart(fullPattern, currPath + "/")) {         if (!content.canRead()) {            if (logger.isDebugEnabled()) {               logger.debug("Skipping subdirectory [" + dir.getAbsolutePath() +                     "] because the application is not allowed to read the directory");            }         }         else {            doRetrieveMatchingFiles(fullPattern, content, result);         }      }      if (getPathMatcher().match(fullPattern, currPath)) {         result.add(content);      }   }}

1.1.2) CachingMetadataResourceFactory.getMetadataReader（读取class文件）

public MetadataReader getMetadataReader(Resource resource) throws IOException {   if (getCacheLimit() <= 0) {      // 真正的逻辑      return super.getMetadataReader(resource);   }   synchronized (this.metadataReaderCache) {      MetadataReader metadataReader = this.metadataReaderCache.get(resource);      if (metadataReader == null) {         metadataReader = super.getMetadataReader(resource);         this.metadataReaderCache.put(resource, metadataReader);      }      return metadataReader;   }}

1.1.2.1) SimpleMetadataReader.getMetadataReader

该类封装了Class文件中的各种信息，保存在ClassMatadata和AnnotationMetadata中。

final class SimpleMetadataReader implements MetadataReader {   private final Resource resource;   private final ClassMetadata classMetadata;   private final AnnotationMetadata annotationMetadata;}

public MetadataReader getMetadataReader(Resource resource) throws IOException {   return new SimpleMetadataReader(resource, this.resourceLoader.getClassLoader());}

SimpleMetadataReader(Resource resource, ClassLoader classLoader) throws IOException {   // 打开文件流   InputStream is = new BufferedInputStream(resource.getInputStream());   ClassReader classReader;   try {      classReader = new ClassReader(is);   }   catch (IllegalArgumentException ex) {      throw new NestedIOException("ASM ClassReader failed to parse class file - " +            "probably due to a new Java class file version that isn't supported yet: " + resource, ex);   }   finally {      is.close();   }   AnnotationMetadataReadingVisitor visitor = new AnnotationMetadataReadingVisitor(classLoader);   // 按照class文件格式读取class文件，并将读到的信息保存到visitor中   classReader.accept(visitor, ClassReader.SKIP_DEBUG);   // 保存下来   this.annotationMetadata = visitor;   // (since AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisitor)   this.classMetadata = visitor;   this.resource = resource;}

1.1.3) isCandidateComponent（是否是需要的bean）

 protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {   for (TypeFilter tf : this.excludeFilters) {      if (tf.match(metadataReader, this.metadataReaderFactory)) {         return false;      }   }   for (TypeFilter tf : this.includeFilters) {      if (tf.match(metadataReader, this.metadataReaderFactory)) {         return isConditionMatch(metadataReader);      }   }   return false;}

1.1.3.1) AbstractTypeHierarchyTraversingFilter.match

关注一下matchSelf方法

public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)      throws IOException {   // This method optimizes avoiding unnecessary creation of ClassReaders   // as well as visiting over those readers.   if (matchSelf(metadataReader)) {      return true;   }   ClassMetadata metadata = metadataReader.getClassMetadata();   if (matchClassName(metadata.getClassName())) {      return true;   }   if (this.considerInherited) {      if (metadata.hasSuperClass()) {         // Optimization to avoid creating ClassReader for super class.         Boolean superClassMatch = matchSuperClass(metadata.getSuperClassName());         if (superClassMatch != null) {            if (superClassMatch.booleanValue()) {               return true;            }         }         else {            // Need to read super class to determine a match...            try {               if (match(metadata.getSuperClassName(), metadataReaderFactory)) {                  return true;               }            }            catch (IOException ex) {               logger.debug("Could not read super class [" + metadata.getSuperClassName() +                     "] of type-filtered class [" + metadata.getClassName() + "]");            }            }      }   }   if (this.considerInterfaces) {      for (String ifc : metadata.getInterfaceNames()) {         // Optimization to avoid creating ClassReader for super class         Boolean interfaceMatch = matchInterface(ifc);         if (interfaceMatch != null) {            if (interfaceMatch.booleanValue()) {               return true;            }         }         else {            // Need to read interface to determine a match...            try {               if (match(ifc, metadataReaderFactory)) {                  return true;               }            }            catch (IOException ex) {               logger.debug("Could not read interface [" + ifc + "] for type-filtered class [" +                     metadata.getClassName() + "]");            }         }      }   }   return false;}

called matchSelf

protected boolean matchSelf(MetadataReader metadataReader) {   AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();   return metadata.hasAnnotation(this.annotationType.getName()) ||         (this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName()));}

this.annotationType是@Component类型，所以
metadata.hasAnnotation(this.annotationType.getName())当类上注解了@Component时为true。
这里因为@Service等也注解了@Component了，所以@Service、@Controller等在这里都被视为@Component

public boolean hasMetaAnnotation(String metaAnnotationType) {   Collection<Set<String>> allMetaTypes = this.metaAnnotationMap.values();   for (Set<String> metaTypes : allMetaTypes) {      if (metaTypes.contains(metaAnnotationType)) {         return true;      }   }   return false;}

1.2) registerBeanDefinition（将beanDefinition记录到BeanFactory）

protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);}

DefaultListableBeanFactory.registerBeanDefinition（保存beanDefinition）

标签解析完毕后会将beanName和beanDefinition作为key和value放入beanfactory的beanDefinitionMap中。

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)      throws BeanDefinitionStoreException {   Assert.hasText(beanName, "Bean name must not be empty");   Assert.notNull(beanDefinition, "BeanDefinition must not be null");   if (beanDefinition instanceof AbstractBeanDefinition) {      try {         ((AbstractBeanDefinition) beanDefinition).validate();      }      catch (BeanDefinitionValidationException ex) {         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,               "Validation of bean definition failed", ex);      }   }   BeanDefinition oldBeanDefinition;   oldBeanDefinition = this.beanDefinitionMap.get(beanName);   if (oldBeanDefinition != null) {      if (!isAllowBeanDefinitionOverriding()) {         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,               "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +               "': There is already [" + oldBeanDefinition + "] bound.");      }      else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE         if (this.logger.isWarnEnabled()) {            this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +                  "' with a framework-generated bean definition: replacing [" +                  oldBeanDefinition + "] with [" + beanDefinition + "]");         }      }      else if (!beanDefinition.equals(oldBeanDefinition)) {         if (this.logger.isInfoEnabled()) {            this.logger.info("Overriding bean definition for bean '" + beanName +                  "' with a different definition: replacing [" + oldBeanDefinition +                  "] with [" + beanDefinition + "]");         }      }      else {         if (this.logger.isDebugEnabled()) {            this.logger.debug("Overriding bean definition for bean '" + beanName +                  "' with an equivalent definition: replacing [" + oldBeanDefinition +                  "] with [" + beanDefinition + "]");         }      }      this.beanDefinitionMap.put(beanName, beanDefinition);   }   else {      if (hasBeanCreationStarted()) {         // Cannot modify startup-time collection elements anymore (for stable iteration)         synchronized (this.beanDefinitionMap) {            this.beanDefinitionMap.put(beanName, beanDefinition);            List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);            updatedDefinitions.addAll(this.beanDefinitionNames);            updatedDefinitions.add(beanName);            this.beanDefinitionNames = updatedDefinitions;            if (this.manualSingletonNames.contains(beanName)) {               Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);               updatedSingletons.remove(beanName);               this.manualSingletonNames = updatedSingletons;            }         }      }      else {         // Still in startup registration phase         this.beanDefinitionMap.put(beanName, beanDefinition);         this.beanDefinitionNames.add(beanName);         this.manualSingletonNames.remove(beanName);      }      this.frozenBeanDefinitionNames = null;   }   if (oldBeanDefinition != null || containsSingleton(beanName)) {      resetBeanDefinition(beanName);   }}

注册完毕后beanDefinitionMap是这样的：

2) finishBeanFactoryInitialization（初始化非lazy-load且singleton的bean）

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {   // Initialize conversion service for this context.   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {      beanFactory.setConversionService(            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));   }   // 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.   if (!beanFactory.hasEmbeddedValueResolver()) {      beanFactory.addEmbeddedValueResolver(new StringValueResolver() {         @Override         public String resolveStringValue(String strVal) {            return getEnvironment().resolvePlaceholders(strVal);         }      });   }   // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.   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.   beanFactory.freezeConfiguration();   // Instantiate all remaining (non-lazy-init) singletons.   // 主要逻辑   beanFactory.preInstantiateSingletons();}

2.1) ConfigurableListableBeanFactory.preInstantiateSingletons

DefaultListableBeanFactory.preInstantiateSingletons
这里调用了部分bean的getBean方法，即加载bean。这就是为什么最开始的时候说注册bean的过程也包含了加载bean。

public void preInstantiateSingletons() throws BeansException {   if (this.logger.isDebugEnabled()) {      this.logger.debug("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<String>(this.beanDefinitionNames);   // Trigger initialization of all non-lazy singleton beans...   for (String beanName : beanNames) {      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {         if (isFactoryBean(beanName)) {            final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);            boolean isEagerInit;            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {               isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {                  @Override                  public Boolean run() {                     return ((SmartFactoryBean<?>) factory).isEagerInit();                  }               }, getAccessControlContext());            }            else {               isEagerInit = (factory instanceof SmartFactoryBean &&                     ((SmartFactoryBean<?>) factory).isEagerInit());            }            if (isEagerInit) {               getBean(beanName);            }         }         else {            getBean(beanName);         }      }   }   // Trigger post-initialization callback for all applicable beans...   for (String beanName : beanNames) {      Object singletonInstance = getSingleton(beanName);      if (singletonInstance instanceof SmartInitializingSingleton) {         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;         if (System.getSecurityManager() != null) {            AccessController.doPrivileged(new PrivilegedAction<Object>() {               @Override               public Object run() {                  smartSingleton.afterSingletonsInstantiated();                  return null;               }            }, getAccessControlContext());         }         else {            smartSingleton.afterSingletonsInstantiated();         }      }   }}

注意getBean时会将已经加载过的、单例的bean进行缓存，下次getBean的时候会从缓存中读取。

bean的加载

bean的加载就是根据beanDefinition实例化bean的过程。可以说getBean方法就是bean的加载，该方法非常重要。并且getBean方法是缓存化的，在2) finishBeanFactoryInitialization中调用的getBean的执行流程和main方法中applicationContext.getBean的执行流程是不同的。

FactoryBean（用户定制）

Spring通过反射机制利用bean的class属性指定实现类来实例化bean。
Spring提供了一个FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化bean的逻辑。
FactoryBean

public interface FactoryBean<T> {// 返回bean示例，如果isSingleton()返回true，那么该实例会放到Spring容器中单例缓存池中   T getObject() throws Exception;   Class<?> getObjectType();   boolean isSingleton();}

ObjectFactory（Spring使用）

public interface ObjectFactory<T> {   T getObject() throws BeansException;}

比较：

FactoryBean：
这个接口使你可以提供一个复杂的逻辑来生成Bean。它本质是一个Bean，但这个Bean不是用来注入到其它地方像Service、Dao一样使用的，它是用来生成其它Bean使用的。实现了这个接口后，Spring在容器初始化时，把实现这个接口的Bean取出来，使用接口的getObject()方法来生成我们要想的Bean。当然，那些生成Bean的业务逻辑也要写getObject()方法中。
ObjectFactory：
它的目的也是作为一个工厂，来生成Object（这个接口只有一个方法getObject()）。这个接口一般被用来，包装一个factory，通过个这工厂来返回一个新实例（prototype类型）。这个接口和FactoryBean有点像，但FactoryBean的实现是被当做一个SPI（Service Provider Interface）实例来使用在BeanFactory里面；ObjectFactory的实现一般被用来注入到其它Bean中，作为API来使用。就像ObjectFactoryCreatingFactoryBean的例子，它的返回值就是一个ObjectFactory，这个ObjectFactory被注入到了Bean中，在Bean通过这个接口的实例，来取得我们想要的Bean。
总的来说，FactoryBean和ObjectFactory都是用来取得Bean，但使用的方法和地方不同，FactoryBean被配置好后，Spring调用getObject()方法来取得Bean，ObjectFactory配置好后，在Bean里面可以取得ObjectFactory实例，需要我们手动来调用getObject()来取得Bean。

getBean

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

doGetBean

有三个方法非常关键：getSingleton，createBean和getObjectForBeanInstance。

protected <T> T doGetBean(      final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)      throws BeansException {   final String beanName = transformedBeanName(name);   Object bean;   // Eagerly check singleton cache for manually registered singletons.// 检查缓存中或者实例工厂中是否有对应的实例（解决循环依赖的问题）// Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光，也就是将ObjectFactory加入到缓存中，一旦下个bean创建时需要上个bean则直接使用ObjectFactory。// 直接尝试从缓存获取或者从singletonFactories中的ObjectFactory中获取   Object sharedInstance = getSingleton(beanName);   if (sharedInstance != null && args == null) {// 已经创建过了      if (logger.isDebugEnabled()) {         if (isSingletonCurrentlyInCreation(beanName)) {            logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +                  "' that is not fully initialized yet - a consequence of a circular reference");         }         else {            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");         }      }    // 返回对应的实例（从缓存中只得到了bean的原始状态，还需要对bean进行实例化）      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.      BeanFactory parentBeanFactory = getParentBeanFactory();// 如果beanDefinitionMap（已经加载了的类）中不包含beanName，则尝试从parentBeanFactory处理      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {         // Not found -> check parent.         String nameToLookup = originalBeanName(name);         if (args != null) {            // Delegation to parent with explicit args.// 递归            return (T) parentBeanFactory.getBean(nameToLookup, args);         }         else {            // No args -> delegate to standard getBean method.            return parentBeanFactory.getBean(nameToLookup, requiredType);         }      }      // 从这里开始创建bean，先进行记录      if (!typeCheckOnly) {         markBeanAsCreated(beanName);      }      try {    // 将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition；转换的时候如果父类bean不为空的话，那么会合并父类的属性。         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);         checkMergedBeanDefinition(mbd, beanName, args);         // Guarantee initialization of beans that the current bean depends on.     // 若存在依赖则需要递归实例化依赖的bean         String[] dependsOn = mbd.getDependsOn();         if (dependsOn != null) {            for (String dep : dependsOn) {               if (isDependent(beanName, dep)) {                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");               }// 缓存依赖调用               registerDependentBean(dep, beanName);               getBean(dep);            }         }         // Create bean instance.    // 真正的创建bean         if (mbd.isSingleton()) {    // 单例            sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {               @Override               public Object getObject() throws BeansException {                  try {                     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);         }         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);         }         else {    // 在指定的scope上实例化bean            String scopeName = mbd.getScope();            final 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, new ObjectFactory<Object>() {                  @Override                  public Object getObject() throws BeansException {                     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.   if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {      try {         return getTypeConverter().convertIfNecessary(bean, requiredType);      }      catch (TypeMismatchException ex) {         if (logger.isDebugEnabled()) {            logger.debug("Failed to convert bean '" + name + "' to required type '" +                  ClassUtils.getQualifiedName(requiredType) + "'", ex);         }         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());      }   }   return (T) bean;}

1) getSingleton(beanName)（借助缓存或singletonFactories）

逻辑：
1）从singletonObjects中获取
2）获取不到再从earlySingletonObjects里面获取
3）还是获取不到，再尝试从singletonFactories里面获取beanName对应的ObjectFactory，然后调用这个ObjectFactory的getObject来创建bean，并放到earlySingletonObjects里面去，并且从singletonFactories中remove掉这个ObjectFactory。
成员变量Map：
1）singletonObjects：bean name-> bean instance
2）singltonFactories：bean name -> ObjectFactory
3）earlySingletonObjects：bean name -> bean instance，与1）不同的是，当一个单例bean被放在这里面后，那么当bean还在创建过程中，就可以通过getBean获取到了，目的是用来检测循环依赖（这个问题最后再解释）。
4）registeredSingletons：用来保存当前所有已注册的bean。

protected Object getSingleton(String beanName, boolean allowEarlyReference) {   Object singletonObject = this.singletonObjects.get(beanName);   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {      synchronized (this.singletonObjects) {         singletonObject = this.earlySingletonObjects.get(beanName);         if (singletonObject == null && allowEarlyReference) {            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);            if (singletonFactory != null) {               singletonObject = singletonFactory.getObject();               this.earlySingletonObjects.put(beanName, singletonObject);               this.singletonFactories.remove(beanName);            }         }      }   }   return (singletonObject != NULL_OBJECT ? singletonObject : null);}

2) getSingleton(beanName,ObjectFactory)（从头创建单例bean）

从头创建一个单例的bean需要经过getSingleton(beanName,ObjectFactory)和createBean两个关键方法。
逻辑：
1）检查缓存是否已经加载过
2）若没有加载，则记录beanName的正在加载状态
3）加载单例前 记录加载状态
4）通过ObjectFactory的Object方法实例化bean
5）加载单例后 清除加载状态
6）将结果记录至缓存并删除加载bean过程中所记录的各种辅助状态
7）返回处理结果

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {   Assert.notNull(beanName, "'beanName' must not be null");   synchronized (this.singletonObjects) {// 检查对应的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 + "'");         }    // 记录加载状态         beforeSingletonCreation(beanName);         boolean newSingleton = false;         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);         if (recordSuppressedExceptions) {            this.suppressedExceptions = new LinkedHashSet<Exception>();         }         try {            // 初始化bean，在这里调用了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;            }            // 清除加载状态            afterSingletonCreation(beanName);         }         if (newSingleton) {            // 加入缓存            addSingleton(beanName, singletonObject);         }      }      return (singletonObject != NULL_OBJECT ? singletonObject : null);   }}

2.1) beforeSingletonCreation （记录加载状态）

记录加载状态，通过this.singletonsCurrentlyInCreation.add(beanName)将当前正在创建的bean记录在缓存中，这样便可以对循环依赖进行检测。

protected void beforeSingletonCreation(String beanName) {   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {      throw new BeanCurrentlyInCreationException(beanName);   }}

2.2) afterSingletonCreation（清除加载状态）

当bean加载结束后需要移除缓存中对该bean的正在加载状态的记录。

protected void afterSingletonCreation(String beanName) {   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {      throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");   }}

2.3) addSingleton（结果记录至缓存）

将结果记录至缓存中并删除加载bean过程中所记录的各种辅助状态

protected void addSingleton(String beanName, Object singletonObject) {   synchronized (this.singletonObjects) {      this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));      this.singletonFactories.remove(beanName);      this.earlySingletonObjects.remove(beanName);      this.registeredSingletons.add(beanName);   }}

3) createBean（创建单例或多例的bean，在3中有被调用）

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {   if (logger.isDebugEnabled()) {      logger.debug("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，根据设置的class属性或者根据className来解析Class   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {      mbdToUse = new RootBeanDefinition(mbd);      mbdToUse.setBeanClass(resolvedClass);   }   // 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.// 给BeanPostProcessor一个机会来返回代理来替代真正的实例      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);   }   // 实际创建bean   Object beanInstance = doCreateBean(beanName, mbdToUse, args);   if (logger.isDebugEnabled()) {      logger.debug("Finished creating instance of bean '" + beanName + "'");   }   return beanInstance;}

3.1) AbstractBeanDefinition.prepareMethodOverrides（决定实例化策略->反射 or CGLIB）

验证及准备覆盖的方法
在Spring配置中存在lookup-method和replace-method两个配置功能，而这两个配置的加载其实就是将配置统一存放在BeanDefinition中的methodOverrides属性里，这两个功能实现原理其实是在bean实例化的时候如果检测到存在methodOverrides属性，会动态地为当前bean生成代理并使用对应的拦截器为bean做增强处理，相关逻辑实现在bean的实例化部分详细介绍。

public void prepareMethodOverrides() throws BeanDefinitionValidationException {   // Check that lookup methods exists.   MethodOverrides methodOverrides = getMethodOverrides();   if (!methodOverrides.isEmpty()) {      Set<MethodOverride> overrides = methodOverrides.getOverrides();      synchronized (overrides) {         for (MethodOverride mo : overrides) {            prepareMethodOverride(mo);         }      }   }}

3.2) resolveBeforeInstantiation（可能会创建代理过的bean）

如果该方法返回bean不为空，则跳过后续实际创建bean的过程，直接返回代理后的bean。
与AOP有关！

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {   Object bean = null;   if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {      // Make sure bean class is actually resolved at this point.      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {         Class<?> targetType = determineTargetType(beanName, mbd);         if (targetType != null) {            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);            if (bean != null) {               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);            }         }      }      mbd.beforeInstantiationResolved = (bean != null);   }   return bean;}

3.2.1) applyBeanPostProcessorsBeforeInstantiation（实例化前的后处理器应用）

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {   for (BeanPostProcessor bp : getBeanPostProcessors()) {      if (bp instanceof InstantiationAwareBeanPostProcessor) {         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;         Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);         if (result != null) {            return result;         }      }   }   return null;}

3.2.2) applyBeanPostProcessorsAfterInitialization（实例化后的后处理器应用）

Spring中的规则是在bean的初始化后尽可能保证将注册的后处理器的postProcessAfterInitialization方法应用到该bean中，因为如果返回的bean不为空，那么便不会再次经历普通bean的创建过程。
注意！这里可能会与AOP和Transaction有关。

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)      throws BeansException {   Object result = existingBean;   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {      result = beanProcessor.postProcessAfterInitialization(result, beanName);      if (result == null) {         return result;      }   }   return result;}

3.3) doCreateBean（创建常规bean）

逻辑：
1）如果是单例，则需要首先清除缓存
2）实例化bean，将BeanDefinition转换为BeanWrapper。
转换过程：
①如果存在工厂方法，则使用工厂方法进行初始化
②一个类有多个构造函数，每个构造函数都有不同的参数，所以需要根据参数锁定构造函数并进行初始化
③如果既不存在工厂方法也不存在带有参数的构造函数，则使用默认的构造函数进行bean的初始化。
3）MergedBeanDefinitionPostProcessor的应用
bean合并后的处理，Autowired注解正是通过此方法实现诸如类型的预解析。
4）依赖处理
A和B都是单例，B依赖于A，不是直接去再次创建A，而是通过放入缓存中的ObjectFactory来创建实例
5）属性填充
6）循环依赖检查
7）注册DisposableBean
如果配置了destroy-method，这里需要注册以便于在销毁时候调用。
8）完成创建并返回

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)      throws BeanCreationException {   // Instantiate the bean.   BeanWrapper instanceWrapper = null;   if (mbd.isSingleton()) {      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);   }// 根据指定bean使用对应的策略创建新的实例，如：工厂方法；构造器注入；简单初始化   if (instanceWrapper == null) {      instanceWrapper = createBeanInstance(beanName, mbd, args);   }   final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);   Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);   mbd.resolvedTargetType = beanType;   // Allow post-processors to modify the merged bean definition.   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正在创建中// 检测循环依赖   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&         isSingletonCurrentlyInCreation(beanName));   if (earlySingletonExposure) {      if (logger.isDebugEnabled()) {         logger.debug("Eagerly caching bean '" + beanName +               "' to allow for resolving potential circular references");      }// 为避免后期循环依赖，可以在bean初始化完成前 将创建实例的ObjectFactory加入工厂      addSingletonFactory(beanName, new ObjectFactory<Object>() {         @Override         public Object getObject() throws BeansException {    // 对bean再一次依赖引用，主要应用SmartInstantiationAware BeanPostProcessor ，其中AOP就是在这里将advice动态织入bean中，若没有则直接返回bean，不做任何处理            return getEarlyBeanReference(beanName, mbd, bean);         }      });   }   // 填充bean，将属性值注入   // Initialize the bean instance.   Object exposedObject = bean;   try {// 3.3.3      populateBean(beanName, mbd, instanceWrapper);      if (exposedObject != null) {   // 3.3.4    // 调用初始化方法，比如init-method         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) {      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<String>(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 " +                     "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");            }         }      }   }   // 注册DisposableBean   // Register bean as disposable.   try {      registerDisposableBeanIfNecessary(beanName, bean, mbd);   }   catch (BeanDefinitionValidationException ex) {      throw new BeanCreationException(            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);   }   return exposedObject;}

3.3.1) createBeanInstance（实例化bean）

逻辑：
1）如果在RootBeanDefinition中存在factoryMethodName属性，或者说在配置文件中配置了factory-method，那么Spring会尝试使用instantiateUsingFactoryMethod方法根据RootBeanDefinition中的配置生成bean的实例。
2）解析构造方法并进行构造方法的实例化。因为一个bean对应的类中可能会有多个构造方法，而每个构造方法的参数不同，Spring再根据参数及类型去判断最终会使用哪个构造方法进行实例化。但是，判断的过程是个比较消耗性能的步骤，所以采用缓存机制，如果已经解析过，则不需要重复解析而是直接从RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod缓存的值去取，否则需要再次解析，并将解析的结果添加至RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {   // Make sure bean class is actually resolved at this point.// 解析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);   }   // 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) {         return autowireConstructor(beanName, mbd, null, null);      }      else {         return instantiateBean(beanName, mbd);      }   }   // 需要根据参数解析构造方法   // Need to determine the constructor...   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);   if (ctors != null ||         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {// 构造方法自动注入      return autowireConstructor(beanName, mbd, ctors, args);   }   // 使用默认构造方法   // No special handling: simply use no-arg constructor.   return instantiateBean(beanName, mbd);}

我们没有配置工厂方法，并且也没有设置使用有参数的构造方法初始化，所以会采用最简单的策略——无参数构造方法初始化。

3.3.1.1) instantiateBean（无参数的构造方法的实例化）

getInstantiationStrategy()可能会返回直接实例化或者cglib实例化两种策略。

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

3.3.1.1.1) InstantiationStrategy.instantiate

以SimpleInstantiationStrategy为例（反射实例化）：

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {   // Don't override the class with CGLIB if no overrides.// 如果有需要覆盖或者动态替换的方法，则使用cglib进行动态代理，因为可以在创建代理的同时将动态方法织入类中，但是如果没有需要动态改变的方法，为了方便直接反射就可以了   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 {      // Must generate CGLIB subclass.      return instantiateWithMethodInjection(bd, beanName, owner);   }}

以CglibSubclassingInstantiationStrategy为例（cglib实例化）：

public Object instantiate(Constructor<?> ctor, Object... args) {   Class<?> subclass = createEnhancedSubclass(this.beanDefinition);   Object instance;   if (ctor == null) {      instance = BeanUtils.instantiateClass(subclass);   }   else {      try {         Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());         instance = enhancedSubclassConstructor.newInstance(args);      }      catch (Exception ex) {         throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),               "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);      }   }   // SPR-10785: set callbacks directly on the instance instead of in the   // enhanced class (via the Enhancer) in order to avoid memory leaks.   Factory factory = (Factory) instance;   factory.setCallbacks(new Callback[] {NoOp.INSTANCE,         new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),         new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});   return instance;}

3.3.2) getEarlyBeanReference（应用后处理器，检测循环依赖）

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {   Object exposedObject = bean;   if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {      for (BeanPostProcessor bp : getBeanPostProcessors()) {         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);            if (exposedObject == null) {               return null;            }         }      }   }   return exposedObject;}

3.3.3) polulateBean（属性值注入）

逻辑：
1）InstantiationAwareBeanPostProcessor处理器的postProcessAfterInstantiation函数的应用，此函数可以控制程序是否继续进行属性填充。
2）根据注入类型（byName/byType），提取依赖的bean，并统一存入PropertyValues中。
3）应用InstantiationAwareBeanPostProcessor处理器的postProcessPropertyValues方法，对属性获取完毕填充前 对属性的再次处理，典型应用是RequiredAnnotationBeanPostProcessor类中对属性的验证
4）将所有PropertyValues中的属性填充至BeanWrapper中。

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {   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;      }   }   // 给InstantiationAwareBeanPostProcessor最后一次机会在属性设置前来改变bean// 如：可以用来支持属性注入的类型   // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the   // state of the bean before properties are set. This can be used, for example,   // to support styles of field injection.   boolean continueWithPropertyPopulation = true;   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {      for (BeanPostProcessor bp : getBeanPostProcessors()) {         if (bp instanceof InstantiationAwareBeanPostProcessor) {            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;    // 返回值为是否继续填充bean            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);      // Add property values based on autowire by name if applicable.      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {// 根据名称自动注入，存入PropertyValues         autowireByName(beanName, mbd, bw, newPvs);      }      // Add property values based on autowire by type if applicable.      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {// 根据类型自动注入，存入PropertyValues         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;               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);}

3.3.4) initializeBean（调用init-method方法）

AbstractAutowireCapableBeanFactory
主要是调用用户设定的初始化方法，还有一些其他工作

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {   if (System.getSecurityManager() != null) {      AccessController.doPrivileged(new PrivilegedAction<Object>() {         @Override         public Object run() {// 激活Aware方法            invokeAwareMethods(beanName, bean);            return null;         }      }, getAccessControlContext());   }   else {      invokeAwareMethods(beanName, bean);   }   Object wrappedBean = bean;   if (mbd == null || !mbd.isSynthetic()) {// 应用后处理器      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);   }   try {// 激活用户自定义的init方法      invokeInitMethods(beanName, wrappedBean, mbd);   }   catch (Throwable ex) {      throw new BeanCreationException(            (mbd != null ? mbd.getResourceDescription() : null),            beanName, "Invocation of init method failed", ex);   }   if (mbd == null || !mbd.isSynthetic()) {      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);   }   return wrappedBean;}

3.3.4.1) invokeAwareMethods

Aware
Spring中提供一些Aware相关接口，比如BeanFactoryAware、ApplicationContextAware等，实现这些Aware接口的bean被初始化后，可以取得一些相对应的资源。
如实现BeanFactoryAware的bean在初始化后，Spring容器将会注入BeanFactory的实例。

private void invokeAwareMethods(final String beanName, final Object bean) {   if (bean instanceof Aware) {      if (bean instanceof BeanNameAware) {         ((BeanNameAware) bean).setBeanName(beanName);      }      if (bean instanceof BeanClassLoaderAware) {         ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());      }      if (bean instanceof BeanFactoryAware) {         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);      }   }}

3.3.4.2) BeanPostProcessor

调用用户自定义初始化方法之前和之后分别会调用BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法，使 用户可以根据自己的业务需求进行响应的处理。

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)      throws BeansException {   Object result = existingBean;   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {      result = beanProcessor.postProcessBeforeInitialization(result, beanName);      if (result == null) {         return result;      }   }   return result;}public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)      throws BeansException {   Object result = existingBean;   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {      result = beanProcessor.postProcessAfterInitialization(result, beanName);      if (result == null) {         return result;      }   }   return result;}

3.3.4.3) invokeInitMethods（激活自定义的init方法）

客户定制的初始化方法除了使用配置init-method外，还有使自定义的bean实现InitializingBean接口。并在afterPropertiesSet中实现自己的初始化业务逻辑。
init-method和afterPropertiesSet都是在初始化bean时执行，执行顺序是afterPropertiesSet先执行，init-method后执行。
该方法中实现了这两个步骤的初始化方法调用。

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)      throws Throwable {   // 首先检查是否是InitializingBean，如果是的话需要调用afterPropertiesSet方法   boolean isInitializingBean = (bean instanceof InitializingBean);   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {      if (logger.isDebugEnabled()) {         logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");      }      if (System.getSecurityManager() != null) {         try {            AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {               @Override               public Object run() throws Exception {                  ((InitializingBean) bean).afterPropertiesSet();                  return null;               }            }, getAccessControlContext());         }         catch (PrivilegedActionException pae) {            throw pae.getException();         }      }      else {         ((InitializingBean) bean).afterPropertiesSet();      }   }   if (mbd != null) {      String initMethodName = mbd.getInitMethodName();      if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&            !mbd.isExternallyManagedInitMethod(initMethodName)) {         invokeCustomInitMethod(beanName, bean, mbd);      }   }}

3.3.5) getSingleton(beanName,allowEarlyReference)

protected Object getSingleton(String beanName, boolean allowEarlyReference) {   Object singletonObject = this.singletonObjects.get(beanName);   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {      synchronized (this.singletonObjects) {         singletonObject = this.earlySingletonObjects.get(beanName);         if (singletonObject == null && allowEarlyReference) {            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);            if (singletonFactory != null) {               singletonObject = singletonFactory.getObject();               this.earlySingletonObjects.put(beanName, singletonObject);               this.singletonFactories.remove(beanName);            }         }      }   }   return (singletonObject != NULL_OBJECT ? singletonObject : null);}

3.3.6) registerDisposableBeanIfNecessary（注册DisposableBean）

对于销毁方法的扩展，除了配置属性destroy-method，用户还可以注册后处理器DestructionAwareBeanPostProcessor来统一处理bean的销毁方法。

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {   AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);   if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {      if (mbd.isSingleton()) {    // 单例模式下，注册需要销毁的bean，此方法中会处理实现DisposableBean的bean，并且对所有的bean使用DestructionAwareBeanPostProcessors处理         // Register a DisposableBean implementation that performs all destruction         // work for the given bean: DestructionAwareBeanPostProcessors,         // DisposableBean interface, custom destroy method.         registerDisposableBean(beanName,               new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));      }      else {// 自定义scope的处理         // A bean with a custom scope...         Scope scope = this.scopes.get(mbd.getScope());         if (scope == null) {            throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");         }         scope.registerDestructionCallback(beanName,               new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));      }   }}

4) getObjectForBeanInstance（从bean 的实例中获取对象）

无论是从缓存中获取到的bean还是通过不同的scope策略加载的bean都只是最原始的bean状态，并不一定是我们最终想要的bean。
比如，我们需要对FactoryBean进行处理，那么这里得到的其实是FactoryBean的初始状态，但是我们真正需要的是FactoryBean中定义的factory-method（getObject方法）方法中返回的bean，而getObjectForBeanInstance就是完成这个工作的。

下面这个方法完成了以下任务：
1）对FactoryBean正确性的验证
2）对非FactoryBean不做任何处理
3）对bean进行转换
4）将从Factory解析bean的工作委托给getObjectFromFactoryBean。
因为我们没有实现FactroyBean接口，所以直接返回。

protected Object getObjectForBeanInstance(      Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {   // Don't let calling code try to dereference the factory if the bean isn't a factory.   if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {      throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());   }   // Now we have the bean instance, which may be a normal bean or a FactoryBean.   // If it's a FactoryBean, we use it to create a bean instance, unless the   // caller actually wants a reference to the factory.   if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {      return beanInstance;   }   Object object = null;   if (mbd == null) {      object = getCachedObjectForFactoryBean(beanName);   }   if (object == null) {      // Return bean instance from factory.      FactoryBean<?> factory = (FactoryBean<?>) beanInstance;      // Caches object obtained from FactoryBean if it is a singleton.      if (mbd == null && containsBeanDefinition(beanName)) {         mbd = getMergedLocalBeanDefinition(beanName);      }      boolean synthetic = (mbd != null && mbd.isSynthetic());      object = getObjectFromFactoryBean(factory, beanName, !synthetic);   }   return object;}

4.1.1) doGetObjectFromFactoryBean

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)      throws BeanCreationException {   Object object;   try {      if (System.getSecurityManager() != null) {         AccessControlContext acc = getAccessControlContext();         try {            object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {               @Override               public Object run() throws Exception {                     return factory.getObject();                  }               }, acc);         }         catch (PrivilegedActionException pae) {            throw pae.getException();         }      }      else {         object = factory.getObject();      }   }   catch (FactoryBeanNotInitializedException ex) {      throw new BeanCurrentlyInCreationException(beanName, ex.toString());   }   catch (Throwable ex) {      throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);   }   // Do not accept a null value for a FactoryBean that's not fully   // initialized yet: Many FactoryBeans just return null then.   if (object == null && isSingletonCurrentlyInCreation(beanName)) {      throw new BeanCurrentlyInCreationException(            beanName, "FactoryBean which is currently in creation returned null from getObject");   }   return object;}

循环依赖

A类持有B类引用，B类持有C类引用，C类持有A类引用，形成循环依赖。
Spring容器循环依赖包括构造器循环依赖和setter循环依赖。

构造器循环依赖

表示通过构造器注入构成的循环依赖，此依赖是无法解决的，只能抛出BeanCurrentlyInCreationException异常表示循环依赖。
如在创建CircleA类时，构造器需要CircleB类，那将去创建CircleB，在创建CircleB类时又发现需要CircleC类，则又去创建CircleC，最终在创建CircleC时发现又需要CircleA；从而形成一个环，没办法创建。
Spring容器将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中，因此如果在创建Bean过程中发现自己已经在“当前创建Bean池”里时将抛出BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。

setter循环依赖

表示通过setter注入方式构成的循环依赖。
对于setter注入造成的依赖是通过Spring容器提前暴露刚完成构造器注入但未完成其他步骤（如setter注入）的Bean来完成的，而且只能解决单例作用域的Bean循环依赖。
1、Spring容器创建单例“circleA” Bean，首先根据无参构造器创建Bean，并暴露一个“ObjectFactory ”用于返回一个提前暴露一个创建中的Bean，并将“circleA” 标识符放到“当前创建Bean池”；然后进行setter注入“circleB”；
2、Spring容器创建单例“circleB” Bean，首先根据无参构造器创建Bean，并暴露一个“ObjectFactory”用于返回一个提前暴露一个创建中的Bean，并将“circleB” 标识符放到“当前创建Bean池”，然后进行setter注入“circleC”；
3、Spring容器创建单例“circleC” Bean，首先根据无参构造器创建Bean，并暴露一个“ObjectFactory ”用于返回一个提前暴露一个创建中的Bean，并将“circleC” 标识符放到“当前创建Bean池”，然后进行setter注入“circleA”；进行注入“circleA”时由于提前暴露了“ObjectFactory”工厂从而使用它返回提前暴露一个创建中的Bean；
4、最后在依赖注入“circleB”和“circleA”，完成setter注入。

对于“prototype”作用域Bean，Spring容器无法完成依赖注入，因为“prototype”作用域的Bean，Spring容器不进行缓存，因此无法提前暴露一个创建中的Bean。

总结

可以用一张流程图来解释整个bean的注册、bean的加载过程。这两张示例图来自网络，侵删。

bean的注册

bean的加载

认识

1. Spring中的代码可以说是非常复杂， 但也非常的严谨。几乎每个方法中都有Assert，检验入参，也有抛出异常等，并对异常进行处理。往往一个方法中大部分代码都是安全校验，最后会调用一个doXXX的方法来执行核心逻辑。这是值得我们学习的
2. Spring中大量使用模板方法模式，在定义Abstract父类时就为子类扩展留下余地。复杂继承体系实现了代码最大可能的可复用与可扩展。
3. 大量缓存的使用。可以说大量的资源都是可以缓存的，Spring的缓存机制换来了性能的提升。
4. 单一职责原则。Spring代码中有着非常多的责任委托，把与当前类业务关系不是非常紧密的交给其他的类来实现，避免把一个类写的非常膨胀。虽然Spring中类、方法非常多，但是很少有类或方法代码量非常大的，大部分都会分解业务逻辑，保证起码单个方法是可读的。
5. 并发机制。Spring代码中有着大量的synchronized(object)，保证某段代码是原子执行的，避免多线程之间互相干扰，而我们自己的业务代码很少去显式地使用同步，这也是值得思考的。

心得

1. 阅读源码有两种方式，一种是直接照的源码或者源码书，比如《Spring源码深度解析》看下去，另一种是写一个示例然后debug看代码。前者可能看的比较头疼，后者可能会忽略其他的执行流程。两者最好结合起来做。
2. 不必把每处都搞懂，重点关注核心逻辑，尽量把源码和自己接触过、用过的东西结合，比如IOC始于XML或注解，最终落地到反射或者CGLIB。
3. 我的这篇文章可能忽略了一些部分，比如BeanFactory继承体系、Resource继承体系等，可以在网上搜索相应资料。