• Spring 源码阅读

     1. beanFactory

         The root interface for accessing a Spring bean container.

    2. BeanFactoryPostProcessor

         对bean定义进行后置处理，比如jdbc类读取配置的密码，用户名等。

    3.BeanPostProcessor

    1. public interface BeanPostProcessor {
    2.     Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;
    3.  
    4.     Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;
    5. }

     4. Enviroment接口，加载系统环境变量和属性值

    5. 源码部分

    1. @Override
    2. 	public void refresh() throws BeansException, IllegalStateException {
    3. 		synchronized (this.startupShutdownMonitor) {
    4. 			// Prepare this context for refreshing.
    5. 			prepareRefresh();
    6.  
    7. 			// Tell the subclass to refresh the internal bean factory.
    8. 			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    9.  
    10. 			// Prepare the bean factory for use in this context.
    11. 			prepareBeanFactory(beanFactory);
    12.  
    13. 			try {
    14. 				// Allows post-processing of the bean factory in context subclasses.
    15. 				postProcessBeanFactory(beanFactory);
    16.  
    17. 				// Invoke factory processors registered as beans in the context.
    18. 				invokeBeanFactoryPostProcessors(beanFactory);
    19.  
    20. 				// Register bean processors that intercept bean creation.
    21. 				registerBeanPostProcessors(beanFactory);
    22.  
    23. 				// Initialize message source for this context.
    24. 				initMessageSource();
    25.  
    26. 				// Initialize event multicaster for this context.
    27. 				initApplicationEventMulticaster();
    28.  
    29. 				// Initialize other special beans in specific context subclasses.
    30. 				onRefresh();
    31.  
    32. 				// Check for listener beans and register them.
    33. 				registerListeners();
    34.  
    35. 				// Instantiate all remaining (non-lazy-init) singletons.
    36. 				finishBeanFactoryInitialization(beanFactory);
    37.  
    38. 				// Last step: publish corresponding event.
    39. 				finishRefresh();
    40. 			}
    41.  
    42. 			catch (BeansException ex) {
    43. 				logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);
    44.  
    45. 				// Destroy already created singletons to avoid dangling resources.
    46. 				destroyBeans();
    47.  
    48. 				// Reset 'active' flag.
    49. 				cancelRefresh(ex);
    50.  
    51. 				// Propagate exception to caller.
    52. 				throw ex;
    53. 			}
    54. 		}

    1. 创建容器obtainfreshBeanFactory，-> refreshBeanFactory.  ->DefaultlistableBeanFactory， 

    2. 给beanFactory赋值  customizeBeanFactory

    1. /**
    2. 	 * This implementation performs an actual refresh of this context's underlying
    3. 	 * bean factory, shutting down the previous bean factory (if any) and
    4. 	 * initializing a fresh bean factory for the next phase of the context's lifecycle.
    5. 	 */
    6. 	@Override
    7. 	protected final void refreshBeanFactory() throws BeansException {
    8. 		if (hasBeanFactory()) {
    9. 			destroyBeans();
    10. 			closeBeanFactory();
    11. 		}
    12. 		try {
    13. 			DefaultListableBeanFactory beanFactory = createBeanFactory();
    14. 			beanFactory.setSerializationId(getId());
    15. 			customizeBeanFactory(beanFactory);
    16. 			loadBeanDefinitions(beanFactory);
    17. 			synchronized (this.beanFactoryMonitor) {
    18. 				this.beanFactory = beanFactory;
    19. 			}
    20. 		}
    21. 		catch (IOException ex) {
    22. 			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    23. 		}
    24. 	}

    3. 加载bean定义，以读取xml的ApplicationContext为例

    1. Override
    2. 	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    3. 		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
    4. 		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    5.  
    6. 		// Configure the bean definition reader with this context's
    7. 		// resource loading environment.
    8. 		beanDefinitionReader.setEnvironment(this.getEnvironment());
    9. 		beanDefinitionReader.setResourceLoader(this);
    10. 		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    11.  
    12. 		// Allow a subclass to provide custom initialization of the reader,
    13. 		// then proceed with actually loading the bean definitions.
    14. 		initBeanDefinitionReader(beanDefinitionReader);
    15. 		loadBeanDefinitions(beanDefinitionReader);
    16. 	}

    4. 调用beanFactoryProcessor的后置增强处理器

    invokeBeanFactoryPostProcessors(beanFactory);

    5. 注册beanPostProcessor

    doGetBean - createBean -doCreateBean, doGetBean 时getSingleton放到三级缓存中

    7. 

    1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    2. 		// Instantiate the bean.
    3. 		BeanWrapper instanceWrapper = null;
    4. 		if (mbd.isSingleton()) {
    5. 			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    6. 		}
    7. 		if (instanceWrapper == null) {
    8. 			instanceWrapper = createBeanInstance(beanName, mbd, args);
    9. 		}
    10. 		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    11. 		Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    12.  
    13. 		// Allow post-processors to modify the merged bean definition.
    14. 		synchronized (mbd.postProcessingLock) {
    15. 			if (!mbd.postProcessed) {
    16. 				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    17. 				mbd.postProcessed = true;
    18. 			}
    19. 		}
    20.  
    21. 		// Eagerly cache singletons to be able to resolve circular references
    22. 		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    23. 		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    24. 				isSingletonCurrentlyInCreation(beanName));
    25. 		if (earlySingletonExposure) {
    26. 			if (logger.isDebugEnabled()) {
    27. 				logger.debug("Eagerly caching bean '" + beanName +
    28. 						"' to allow for resolving potential circular references");
    29. 			}
    30. 			addSingletonFactory(beanName, new ObjectFactory() {
    31. 				@Override
    32. 				public Object getObject() throws BeansException {
    33. 					return getEarlyBeanReference(beanName, mbd, bean);
    34. 				}
    35. 			});
    36. 		}
    37.  
    38. 		// Initialize the bean instance.
    39. 		Object exposedObject = bean;
    40. 		try {
    41. 			populateBean(beanName, mbd, instanceWrapper);
    42. 			if (exposedObject != null) {
    43. 				exposedObject = initializeBean(beanName, exposedObject, mbd);
    44. 			}
    45. 		}
    46. 		catch (Throwable ex) {
    47. 			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
    48. 				throw (BeanCreationException) ex;
    49. 			}
    50. 			else {
    51. 				throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    52. 			}
    53. 		}
    54.  
    55. 		if (earlySingletonExposure) {
    56. 			Object earlySingletonReference = getSingleton(beanName, false);
    57. 			if (earlySingletonReference != null) {
    58. 				if (exposedObject == bean) {
    59. 					exposedObject = earlySingletonReference;
    60. 				}
    61. 				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    62. 					String[] dependentBeans = getDependentBeans(beanName);
    63. 					Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);
    64. 					for (String dependentBean : dependentBeans) {
    65. 						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
    66. 							actualDependentBeans.add(dependentBean);
    67. 						}
    68. 					}
    69. 					if (!actualDependentBeans.isEmpty()) {
    70. 						throw new BeanCurrentlyInCreationException(beanName,
    71. 								"Bean with name '" + beanName + "' has been injected into other beans [" +
    72. 								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
    73. 								"] in its raw version as part of a circular reference, but has eventually been " +
    74. 								"wrapped. This means that said other beans do not use the final version of the " +
    75. 								"bean. This is often the result of over-eager type matching - consider using " +
    76. 								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
    77. 					}
    78. 				}
    79. 			}
    80. 		}
    81.  
    82. 		// Register bean as disposable.
    83. 		try {
    84. 			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    85. 		}
    86. 		catch (BeanDefinitionValidationException ex) {
    87. 			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    88. 		}
    89.  
    90. 		return exposedObject;
    91. 	}
      92.  

      1. protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
      2. 		if (System.getSecurityManager() != null) {
      3. 			AccessController.doPrivileged(new PrivilegedAction() {
      4. 				@Override
      5. 				public Object run() {
      6. 					invokeAwareMethods(beanName, bean);
      7. 					return null;
      8. 				}
      9. 			}, getAccessControlContext());
      10. 		}
      11. 		else {
      12. 			invokeAwareMethods(beanName, bean);
      13. 		}
      14.  
      15. 		Object wrappedBean = bean;
      16. 		if (mbd == null || !mbd.isSynthetic()) {
      17. 			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
      18. 		}
      19.  
      20. 		try {
      21. 			invokeInitMethods(beanName, wrappedBean, mbd);
      22. 		}
      23. 		catch (Throwable ex) {
      24. 			throw new BeanCreationException(
      25. 					(mbd != null ? mbd.getResourceDescription() : null),
      26. 					beanName, "Invocation of init method failed", ex);
      27. 		}
      28.  
      29. 		if (mbd == null || !mbd.isSynthetic()) {
      30. 			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
      31. 		}
      32. 		return wrappedBean;
      33. 	}
        34.  

        1. @Override
        2. 	public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
        3. 		// Don't override the class with CGLIB if no overrides.
        4. 		if (bd.getMethodOverrides().isEmpty()) {
        5. 			Constructor constructorToUse;
        6. 			synchronized (bd.constructorArgumentLock) {
        7. 				constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;
        8. 				if (constructorToUse == null) {
        9. 					final Class clazz = bd.getBeanClass();
        10. 					if (clazz.isInterface()) {
        11. 						throw new BeanInstantiationException(clazz, "Specified class is an interface");
        12. 					}
        13. 					try {
        14. 						if (System.getSecurityManager() != null) {
        15. 							constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction>() {
        16. 								@Override
        17. 								public Constructor run() throws Exception {
        18. 									return clazz.getDeclaredConstructor((Class[]) null);
        19. 								}
        20. 							});
        21. 						}
        22. 						else {
        23. 							constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
        24. 						}
        25. 						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
        26. 					}
        27. 					catch (Exception ex) {
        28. 						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
        29. 					}
        30. 				}
        31. 			}
        32. 			return BeanUtils.instantiateClass(constructorToUse);
        33. 		}
        34. 		else {
        35. 			// Must generate CGLIB subclass.
        36. 			return instantiateWithMethodInjection(bd, beanName, owner);
        37. 		}
        38. 	}
         

        1. public static  T instantiateClass(Constructor ctor, Object... args) throws BeanInstantiationException {
        2. 		Assert.notNull(ctor, "Constructor must not be null");
        3. 		try {
        4. 			ReflectionUtils.makeAccessible(ctor);
        5. 			return ctor.newInstance(args);
        6. 		}
        7. 		catch (InstantiationException ex) {
        8. 			throw new BeanInstantiationException(ctor.getDeclaringClass(),
        9. 					"Is it an abstract class?", ex);
        10. 		}
        11. 		catch (IllegalAccessException ex) {
        12. 			throw new BeanInstantiationException(ctor.getDeclaringClass(),
        13. 					"Is the constructor accessible?", ex);
        14. 		}
        15. 		catch (IllegalArgumentException ex) {
        16. 			throw new BeanInstantiationException(ctor.getDeclaringClass(),
        17. 					"Illegal arguments for constructor", ex);
        18. 		}
        19. 		catch (InvocationTargetException ex) {
        20. 			throw new BeanInstantiationException(ctor.getDeclaringClass(),
        21. 					"Constructor threw exception", ex.getTargetException());
        22. 		}
         

        1. protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        2. 		if (System.getSecurityManager() != null) {
        3. 			AccessController.doPrivileged(new PrivilegedAction() {
        4. 				@Override
        5. 				public Object run() {
        6. 					invokeAwareMethods(beanName, bean);
        7. 					return null;
        8. 				}
        9. 			}, getAccessControlContext());
        10. 		}
        11. 		else {
        12. 			invokeAwareMethods(beanName, bean);
        13. 		}
        14.  
        15. 		Object wrappedBean = bean;
        16. 		if (mbd == null || !mbd.isSynthetic()) {
        17. 			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        18. 		}
        19.  
        20. 		try {
        21. 			invokeInitMethods(beanName, wrappedBean, mbd);
        22. 		}
        23. 		catch (Throwable ex) {
        24. 			throw new BeanCreationException(
        25. 					(mbd != null ? mbd.getResourceDescription() : null),
        26. 					beanName, "Invocation of init method failed", ex);
        27. 		}
        28.  
        29. 		if (mbd == null || !mbd.isSynthetic()) {
        30. 			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        31. 		}
        32. 		return wrappedBean;
        33. 	}
          34.  

           

          5. 初始化广播器
           

              注册监听器
           

           

          Springboot初始化
           

          1. SpringApplication实例化
           

          1. public static ConfigurableApplicationContext run(Class[] primarySources, String[] args) {
          2. 		return new SpringApplication(primarySources).run(args);
          3. 	}
          4.  
          5. public SpringApplication(Class... primarySources) {
          6. 		this(null, primarySources);
          7. 	}
          8.  
          9. 	/**
          10. 	 * Create a new {@link SpringApplication} instance. The application context will load
          11. 	 * beans from the specified primary sources (see {@link SpringApplication class-level}
          12. 	 * documentation for details. The instance can be customized before calling
          13. 	 * {@link #run(String...)}.
          14. 	 * @param resourceLoader the resource loader to use
          15. 	 * @param primarySources the primary bean sources
          16. 	 * @see #run(Class, String[])
          17. 	 * @see #setSources(Set)
          18. 	 */
          19. 	@SuppressWarnings({ "unchecked", "rawtypes" })
          20. 	public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
          21. 		this.resourceLoader = resourceLoader;
          22. 		Assert.notNull(primarySources, "PrimarySources must not be null");
          23. 		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
          24. 		this.webApplicationType = WebApplicationType.deduceFromClasspath();
          25. 		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
          26. 		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
          27. 		this.mainApplicationClass = deduceMainApplicationClass();
          28. 	}
           

          注：此时初始化了一些监听器和初始化器, primarySources为启动的主类
           

          2. 启动整体流程代码
           

          1. public ConfigurableApplicationContext run(String... args) {
          2. 		StopWatch stopWatch = new StopWatch();
          3.         // 计时器开始
          4. 		stopWatch.start();
          5. 		ConfigurableApplicationContext context = null;
          6. 		Collection exceptionReporters = new ArrayList<>();
          7. 		configureHeadlessProperty();
          8.         // 通过SPI方式获取到实现了SpringApplicationRunListener监听器的staging()方法
          9. 		SpringApplicationRunListeners listeners = getRunListeners(args);
          10. 		listeners.starting();
          11. 		try {
          12. 			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
          13. 			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
          14. 			configureIgnoreBeanInfo(environment);
          15. 			Banner printedBanner = printBanner(environment);
          16. 			context = createApplicationContext();
          17. 			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
          18. 					new Class[] { ConfigurableApplicationContext.class }, context);
          19. 			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
          20. 			refreshContext(context);
          21. 			afterRefresh(context, applicationArguments);
          22.             // 计时器结束
          23. 			stopWatch.stop();
          24. 			if (this.logStartupInfo) {
          25. 				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
          26. 			}
          27. 			listeners.started(context);
          28. 			callRunners(context, applicationArguments);
          29. 		}
          30. 		catch (Throwable ex) {
          31. 			handleRunFailure(context, ex, exceptionReporters, listeners);
          32. 			throw new IllegalStateException(ex);
          33. 		}
          34.  
          35. 		try {
          36. 			listeners.running(context);
          37. 		}
          38. 		catch (Throwable ex) {
          39. 			handleRunFailure(context, ex, exceptionReporters, null);
          40. 			throw new IllegalStateException(ex);
          41. 		}
          42. 		return context;
          43. 	}
           

          3. createApplicationContext()
           

          1. protected ConfigurableApplicationContext createApplicationContext() {
          2. 		Class contextClass = this.applicationContextClass;
          3. 		if (contextClass == null) {
          4. 			try {
          5. 				switch (this.webApplicationType) {
          6. 				case SERVLET:
          7. 					contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
          8. 					break;
          9. 				case REACTIVE:
          10. 					contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
          11. 					break;
          12. 				default:
          13. 					contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
          14. 				}
          15. 			}
          16. 			catch (ClassNotFoundException ex) {
          17. 				throw new IllegalStateException(
          18. 						"Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
          19. 			}
          20. 		}
          21. 		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
          22. 	}
           

          注：其中创建的是org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext
           

           

          注：其中AbstracApplicationContext中refresh定义了Spring实例化类的标准流程
           

          1. public void refresh() throws BeansException, IllegalStateException {
          2. 		synchronized (this.startupShutdownMonitor) {
          3. 			// Prepare this context for refreshing.
          4. 			prepareRefresh();
          5.  
          6. 			// Tell the subclass to refresh the internal bean factory.
          7. 			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
          8.  
          9. 			// Prepare the bean factory for use in this context.
          10. 			prepareBeanFactory(beanFactory);
          11.  
          12. 			try {
          13. 				// Allows post-processing of the bean factory in context subclasses.
          14. 				postProcessBeanFactory(beanFactory);
          15.  
          16. 				// Invoke factory processors registered as beans in the context.
          17. 				invokeBeanFactoryPostProcessors(beanFactory);
          18.  
          19. 				// Register bean processors that intercept bean creation.
          20. 				registerBeanPostProcessors(beanFactory);
          21.  
          22. 				// Initialize message source for this context.
          23. 				initMessageSource();
          24.  
          25. 				// Initialize event multicaster for this context.
          26. 				initApplicationEventMulticaster();
          27.  
          28. 				// Initialize other special beans in specific context subclasses.
          29. 				onRefresh();
          30.  
          31. 				// Check for listener beans and register them.
          32. 				registerListeners();
          33.  
          34. 				// Instantiate all remaining (non-lazy-init) singletons.
          35. 				finishBeanFactoryInitialization(beanFactory);
          36.  
          37. 				// Last step: publish corresponding event.
          38. 				finishRefresh();
          39. 			}
          40.  
          41. 			catch (BeansException ex) {
          42. 				if (logger.isWarnEnabled()) {
          43. 					logger.warn("Exception encountered during context initialization - " +
          44. 							"cancelling refresh attempt: " + ex);
          45. 				}
          46.  
          47. 				// Destroy already created singletons to avoid dangling resources.
          48. 				destroyBeans();
          49.  
          50. 				// Reset 'active' flag.
          51. 				cancelRefresh(ex);
          52.  
          53. 				// Propagate exception to caller.
          54. 				throw ex;
          55. 			}
          56.  
          57. 			finally {
          58. 				// Reset common introspection caches in Spring's core, since we
          59. 				// might not ever need metadata for singleton beans anymore...
          60. 				resetCommonCaches();
          61. 			}
          62. 		}
          63. 	}
           

          注:经过子类实现后，beanFactory为DefaultListableBeanFactory
           

          1. public AnnotationConfigServletWebServerApplicationContext() {
          2. 		this.reader = new AnnotatedBeanDefinitionReader(this);
          3. 		this.scanner = new ClassPathBeanDefinitionScanner(this);
          4. 	}
           

          注：其中反射形式创建AnnotationConfigServletWebServerApplicationContext时，创建了两个对象，其中reader主要的作用理解是，向DefaultListableBeanFactory注册了内部使用的postProcessor，其中ConfigurationClassPostProcessor尤为重要。
           

           

           5. prepareContext方法
           

          1. private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
          2. 			SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
          3. 		context.setEnvironment(environment);
          4. 		postProcessApplicationContext(context);
          5. 		applyInitializers(context);
          6. 		listeners.contextPrepared(context);
          7. 		if (this.logStartupInfo) {
          8. 			logStartupInfo(context.getParent() == null);
          9. 			logStartupProfileInfo(context);
          10. 		}
          11. 		// Add boot specific singleton beans
          12. 		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
          13. 		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
          14. 		if (printedBanner != null) {
          15. 			beanFactory.registerSingleton("springBootBanner", printedBanner);
          16. 		}
          17. 		if (beanFactory instanceof DefaultListableBeanFactory) {
          18. 			((DefaultListableBeanFactory) beanFactory)
          19. 					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
          20. 		}
          21. 		if (this.lazyInitialization) {
          22. 			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
          23. 		}
          24. 		// Load the sources
          25. 		Set sources = getAllSources();
          26. 		Assert.notEmpty(sources, "Sources must not be empty");
          27. 		load(context, sources.toArray(new Object[0]));
          28. 		listeners.contextLoaded(context);
          29. 	}
            30.  

            注：将启动类定义注入的DefaultListableBeanFactory
             

            6. refreshContext方法开始执行AnnotationConfigServletWebServerApplicationContext
             

            1. 	protected void refresh(ApplicationContext applicationContext) {
            2. 		Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
            3. 		((AbstractApplicationContext) applicationContext).refresh();
            4. 	}
             

            注：也就是执行refresh标准化的13个函数
             

            7. refresh()
             

            注：prepareRefresh()负责一些属性初始化工作，【TODO】， prepareBeanFactory()负责DefaultListableBeanFactory的一些属性赋值。
             

            1. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
            2. 		// Tell the internal bean factory to use the context's class loader etc.
            3. 		beanFactory.setBeanClassLoader(getClassLoader());
            4. 		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
            5. 		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
            6.  
            7. 		// Configure the bean factory with context callbacks.
            8.         // 注意：这个主要是为了处理类实现的Aware接口是，bean初始化的一部分。
            9. 		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
            10. 		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
            11. 		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
            12. 		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
            13. 		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
            14. 		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
            15. 		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
            16.  
            17. 		// BeanFactory interface not registered as resolvable type in a plain factory.
            18. 		// MessageSource registered (and found for autowiring) as a bean.
            19. 		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
            20. 		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
            21. 		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
            22. 		beanFactory.registerResolvableDependency(ApplicationContext.class, this);
            23.  
            24. 		// Register early post-processor for detecting inner beans as ApplicationListeners.
            25. 		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
            26.  
            27. 		// Detect a LoadTimeWeaver and prepare for weaving, if found.
            28. 		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            29. 			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            30. 			// Set a temporary ClassLoader for type matching.
            31. 			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
            32. 		}
            33.  
            34. 		// Register default environment beans.
            35. 		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
            36. 			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
            37. 		}
            38. 		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
            39. 			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
            40. 		}
            41. 		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
            42. 			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
            43. 		}
            44. 	}
             

            invokeBeanFactoryPostProcessors()方法，在这个方法中完成了bean定义的加载，并完成了Springboot的自动配置。在代码中线先调用postProcessBeanDefinitionRegistry方法，在调用postProcessBeanFactory方法。
             

             

            1. public static void invokeBeanFactoryPostProcessors(
            2. 			ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {
            3.  
            4. 		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
            5. 		Set processedBeans = new HashSet<>();
            6.  
            7. 		if (beanFactory instanceof BeanDefinitionRegistry) {
            8. 			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            9. 			List regularPostProcessors = new ArrayList<>();
            10. 			List registryProcessors = new ArrayList<>();
            11.  
            12. 			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            13. 				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            14. 					BeanDefinitionRegistryPostProcessor registryProcessor =
            15. 							(BeanDefinitionRegistryPostProcessor) postProcessor;
            16. 					registryProcessor.postProcessBeanDefinitionRegistry(registry);
            17. 					registryProcessors.add(registryProcessor);
            18. 				}
            19. 				else {
            20. 					regularPostProcessors.add(postProcessor);
            21. 				}
            22. 			}
            23.  
            24. 			// Do not initialize FactoryBeans here: We need to leave all regular beans
            25. 			// uninitialized to let the bean factory post-processors apply to them!
            26. 			// Separate between BeanDefinitionRegistryPostProcessors that implement
            27. 			// PriorityOrdered, Ordered, and the rest.
            28. 			List currentRegistryProcessors = new ArrayList<>();
            29.  
            30. 			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
            31. 			String[] postProcessorNames =
            32. 					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);     
            33.             // 获取到ConfigurationClassPostProcessor的实例
            34. 			for (String ppName : postProcessorNames) {
            35. 				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            36. 					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            37. 					processedBeans.add(ppName);
            38. 				}
            39. 			}
            40. 			sortPostProcessors(currentRegistryProcessors, beanFactory);
            41. 			registryProcessors.addAll(currentRegistryProcessors);
            42.             // 调用ConfigurationClassPostProcessor的方法
            43. 			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            44. 			currentRegistryProcessors.clear();
            45.  
            46. 			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
            47. 			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            48. 			for (String ppName : postProcessorNames) {
            49. 				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
            50. 					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            51. 					processedBeans.add(ppName);
            52. 				}
            53. 			}
            54. 			sortPostProcessors(currentRegistryProcessors, beanFactory);
            55. 			registryProcessors.addAll(currentRegistryProcessors);
            56. 			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            57. 			currentRegistryProcessors.clear();
            58.  
            59. 			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
            60. 			boolean reiterate = true;
            61. 			while (reiterate) {
            62. 				reiterate = false;
            63. 				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            64. 				for (String ppName : postProcessorNames) {
            65. 					if (!processedBeans.contains(ppName)) {
            66. 						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            67. 						processedBeans.add(ppName);
            68. 						reiterate = true;
            69. 					}
            70. 				}
            71. 				sortPostProcessors(currentRegistryProcessors, beanFactory);
            72. 				registryProcessors.addAll(currentRegistryProcessors);
            73. 				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            74. 				currentRegistryProcessors.clear();
            75. 			}
            76.  
            77. 			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
            78. 			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            79. 			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
            80. 		}
            81.  
            82. 		else {
            83. 			// Invoke factory processors registered with the context instance.
            84. 			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
            85. 		}
            86.  
            87. 		// Do not initialize FactoryBeans here: We need to leave all regular beans
            88. 		// uninitialized to let the bean factory post-processors apply to them!
            89. 		String[] postProcessorNames =
            90. 				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
            91.  
            92. 		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
            93. 		// Ordered, and the rest.
            94. 		List priorityOrderedPostProcessors = new ArrayList<>();
            95. 		List orderedPostProcessorNames = new ArrayList<>();
            96. 		List nonOrderedPostProcessorNames = new ArrayList<>();
            97. 		for (String ppName : postProcessorNames) {
            98. 			if (processedBeans.contains(ppName)) {
            99. 				// skip - already processed in first phase above
            100. 			}
            101. 			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            102. 				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            103. 			}
            104. 			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            105. 				orderedPostProcessorNames.add(ppName);
            106. 			}
            107. 			else {
            108. 				nonOrderedPostProcessorNames.add(ppName);
            109. 			}
            110. 		}
            111.  
            112. 		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
            113. 		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
            114. 		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
            115.  
            116. 		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
            117. 		List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
            118. 		for (String postProcessorName : orderedPostProcessorNames) {
            119. 			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
            120. 		}
            121. 		sortPostProcessors(orderedPostProcessors, beanFactory);
            122. 		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
            123.  
            124. 		// Finally, invoke all other BeanFactoryPostProcessors.
            125. 		List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
            126. 		for (String postProcessorName : nonOrderedPostProcessorNames) {
            127. 			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
            128. 		}
            129. 		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
            130.  
            131. 		// Clear cached merged bean definitions since the post-processors might have
            132. 		// modified the original metadata, e.g. replacing placeholders in values...
            133. 		beanFactory.clearMetadataCache();
            134. 	}
             

            1. private static void invokeBeanDefinitionRegistryPostProcessors(
            2. 			Collection postProcessors, BeanDefinitionRegistry registry) {
            3.  
            4. 		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
            5. 			postProcessor.postProcessBeanDefinitionRegistry(registry);
            6. 		}
            7. 	}
            8.  
            9. 	/**
            10. 	 * Invoke the given BeanFactoryPostProcessor beans.
            11. 	 */
            12. 	private static void invokeBeanFactoryPostProcessors(
            13. 			Collection postProcessors, ConfigurableListableBeanFactory beanFactory) {
            14.  
            15. 		for (BeanFactoryPostProcessor postProcessor : postProcessors) {
            16. 			postProcessor.postProcessBeanFactory(beanFactory);
            17. 		}
            18. 	}
             

            其中ConfigurationClassPostProcessor，帮助完成了bean定义的加载和自动配置需要的bean定义的加载。
             

            1. public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
            2. 		List configCandidates = new ArrayList<>();
            3. 		String[] candidateNames = registry.getBeanDefinitionNames();
            4.  
            5. 		for (String beanName : candidateNames) {
            6. 			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            7. 			if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
            8. 				if (logger.isDebugEnabled()) {
            9. 					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
            10. 				}
            11. 			}
            12. 			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            13. 				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
            14. 			}
            15. 		}
            16.  
            17. 		// Return immediately if no @Configuration classes were found
            18. 		if (configCandidates.isEmpty()) {
            19. 			return;
            20. 		}
            21.  
            22. 		// Sort by previously determined @Order value, if applicable
            23. 		configCandidates.sort((bd1, bd2) -> {
            24. 			int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
            25. 			int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
            26. 			return Integer.compare(i1, i2);
            27. 		});
            28.  
            29. 		// Detect any custom bean name generation strategy supplied through the enclosing application context
            30. 		SingletonBeanRegistry sbr = null;
            31. 		if (registry instanceof SingletonBeanRegistry) {
            32. 			sbr = (SingletonBeanRegistry) registry;
            33. 			if (!this.localBeanNameGeneratorSet) {
            34. 				BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
            35. 						AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
            36. 				if (generator != null) {
            37. 					this.componentScanBeanNameGenerator = generator;
            38. 					this.importBeanNameGenerator = generator;
            39. 				}
            40. 			}
            41. 		}
            42.  
            43. 		if (this.environment == null) {
            44. 			this.environment = new StandardEnvironment();
            45. 		}
            46.  
            47. 		// Parse each @Configuration class
            48. 		ConfigurationClassParser parser = new ConfigurationClassParser(
            49. 				this.metadataReaderFactory, this.problemReporter, this.environment,
            50. 				this.resourceLoader, this.componentScanBeanNameGenerator, registry);
            51.  
            52. 		Set candidates = new LinkedHashSet<>(configCandidates);
            53. 		Set alreadyParsed = new HashSet<>(configCandidates.size());
            54. 		do {
            55.             // candidates初始化，一般是启动类
            56. 			parser.parse(candidates);
            57. 			parser.validate();
            58.  
            59. 			Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
            60. 			configClasses.removeAll(alreadyParsed);
            61.  
            62. 			// Read the model and create bean definitions based on its content
            63. 			if (this.reader == null) {
            64. 				this.reader = new ConfigurationClassBeanDefinitionReader(
            65. 						registry, this.sourceExtractor, this.resourceLoader, this.environment,
            66. 						this.importBeanNameGenerator, parser.getImportRegistry());
            67. 			}
            68. 			this.reader.loadBeanDefinitions(configClasses);
            69. 			alreadyParsed.addAll(configClasses);
            70.  
            71. 			candidates.clear();
            72. 			if (registry.getBeanDefinitionCount() > candidateNames.length) {
            73. 				String[] newCandidateNames = registry.getBeanDefinitionNames();
            74. 				Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
            75. 				Set alreadyParsedClasses = new HashSet<>();
            76. 				for (ConfigurationClass configurationClass : alreadyParsed) {
            77. 					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
            78. 				}
            79. 				for (String candidateName : newCandidateNames) {
            80. 					if (!oldCandidateNames.contains(candidateName)) {
            81. 						BeanDefinition bd = registry.getBeanDefinition(candidateName);
            82. 						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
            83. 								!alreadyParsedClasses.contains(bd.getBeanClassName())) {
            84. 							candidates.add(new BeanDefinitionHolder(bd, candidateName));
            85. 						}
            86. 					}
            87. 				}
            88. 				candidateNames = newCandidateNames;
            89. 			}
            90. 		}
            91. 		while (!candidates.isEmpty());
            92.  
            93. 		// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
            94. 		if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
            95. 			sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
            96. 		}
            97.  
            98. 		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
            99. 			// Clear cache in externally provided MetadataReaderFactory; this is a no-op
            100. 			// for a shared cache since it'll be cleared by the ApplicationContext.
            101. 			((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
            102. 		}
            103. 	}
             

            parser.parse(andidates)
             

            1. public void parse(Set configCandidates) {
            2.    for (BeanDefinitionHolder holder : configCandidates) {
            3.       BeanDefinition bd = holder.getBeanDefinition();
            4.       try {
            5.          if (bd instanceof AnnotatedBeanDefinition) {
            6.             parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
            7.          }
            8.          else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
            9.             parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
            10.          }
            11.          else {
            12.             parse(bd.getBeanClassName(), holder.getBeanName());
            13.          }
            14.       }
            15.       catch (BeanDefinitionStoreException ex) {
            16.          throw ex;
            17.       }
            18.       catch (Throwable ex) {
            19.          throw new BeanDefinitionStoreException(
            20.                "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
            21.       }
            22.    }
            23.  
            24.    this.deferredImportSelectorHandler.process();
            25. }
             

            1. 	protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
            2. 		processConfigurationClass(new ConfigurationClass(metadata, beanName));
            3. 	}
             

            1. protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
            2. 		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
            3. 			return;
            4. 		}
            5.  
            6. 		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
            7. 		if (existingClass != null) {
            8. 			if (configClass.isImported()) {
            9. 				if (existingClass.isImported()) {
            10. 					existingClass.mergeImportedBy(configClass);
            11. 				}
            12. 				// Otherwise ignore new imported config class; existing non-imported class overrides it.
            13. 				return;
            14. 			}
            15. 			else {
            16. 				// Explicit bean definition found, probably replacing an import.
            17. 				// Let's remove the old one and go with the new one.
            18. 				this.configurationClasses.remove(configClass);
            19. 				this.knownSuperclasses.values().removeIf(configClass::equals);
            20. 			}
            21. 		}
            22.  
            23. 		// Recursively process the configuration class and its superclass hierarchy.
            24. 		SourceClass sourceClass = asSourceClass(configClass);
            25. 		do {
            26. 			sourceClass = doProcessConfigurationClass(configClass, sourceClass);
            27. 		}
            28. 		while (sourceClass != null);
            29.  
            30. 		this.configurationClasses.put(configClass, configClass);
            31. 	}
             

            1. @Nullable
            2. 	protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
            3. 			throws IOException {
            4.  
            5. 		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            6. 			// Recursively process any member (nested) classes first
            7.             // 处理内部类
            8. 			processMemberClasses(configClass, sourceClass);
            9. 		}
            10.  
            11. 		// Process any @PropertySource annotations
            12. 		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
            13. 				sourceClass.getMetadata(), PropertySources.class,
            14. 				org.springframework.context.annotation.PropertySource.class)) {
            15. 			if (this.environment instanceof ConfigurableEnvironment) {
            16. 				processPropertySource(propertySource);
            17. 			}
            18. 			else {
            19. 				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
            20. 						"]. Reason: Environment must implement ConfigurableEnvironment");
            21. 			}
            22. 		}
            23.  
            24. 		// Process any @ComponentScan annotations
            25.         // 由于启动类带着ComponentScan注解，所以能扫描到启动类所在包下开始扫描
            26. 		Set componentScans = AnnotationConfigUtils.attributesForRepeatable(
            27. 				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
            28. 		if (!componentScans.isEmpty() &&
            29. 				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
            30. 			for (AnnotationAttributes componentScan : componentScans) {
            31. 				// The config class is annotated with @ComponentScan -> perform the scan immediately
            32. 				Set scannedBeanDefinitions =
            33. 						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
            34. 				// Check the set of scanned definitions for any further config classes and parse recursively if needed
            35. 				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            36. 					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
            37. 					if (bdCand == null) {
            38. 						bdCand = holder.getBeanDefinition();
            39. 					}
            40. 					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
            41. 						parse(bdCand.getBeanClassName(), holder.getBeanName());
            42. 					}
            43. 				}
            44. 			}
            45. 		}
            46.  
            47. 		// Process any @Import annotations
            48. 		processImports(configClass, sourceClass, getImports(sourceClass), true);
            49.  
            50. 		// Process any @ImportResource annotations
            51. 		AnnotationAttributes importResource =
            52. 				AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
            53. 		if (importResource != null) {
            54. 			String[] resources = importResource.getStringArray("locations");
            55. 			Classextends BeanDefinitionReader> readerClass = importResource.getClass("reader");
            56. 			for (String resource : resources) {
            57. 				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            58. 				configClass.addImportedResource(resolvedResource, readerClass);
            59. 			}
            60. 		}
            61.  
            62. 		// Process individual @Bean methods
            63. 		Set beanMethods = retrieveBeanMethodMetadata(sourceClass);
            64. 		for (MethodMetadata methodMetadata : beanMethods) {
            65. 			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
            66. 		}
            67.  
            68. 		// Process default methods on interfaces
            69. 		processInterfaces(configClass, sourceClass);
            70.  
            71. 		// Process superclass, if any
            72. 		if (sourceClass.getMetadata().hasSuperClass()) {
            73. 			String superclass = sourceClass.getMetadata().getSuperClassName();
            74. 			if (superclass != null && !superclass.startsWith("java") &&
            75. 					!this.knownSuperclasses.containsKey(superclass)) {
            76. 				this.knownSuperclasses.put(superclass, configClass);
            77. 				// Superclass found, return its annotation metadata and recurse
            78. 				return sourceClass.getSuperClass();
            79. 			}
            80. 		}
            81.  
            82. 		// No superclass -> processing is complete
            83. 		return null;
            84. 	}
             

            1. public Set parse(AnnotationAttributes componentScan, final String declaringClass) {
            2. 		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
            3. 				componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
            4.  
            5. 		Classextends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
            6. 		boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
            7. 		scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
            8. 				BeanUtils.instantiateClass(generatorClass));
            9.  
            10. 		ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
            11. 		if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
            12. 			scanner.setScopedProxyMode(scopedProxyMode);
            13. 		}
            14. 		else {
            15. 			Classextends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
            16. 			scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
            17. 		}
            18.  
            19. 		scanner.setResourcePattern(componentScan.getString("resourcePattern"));
            20.  
            21. 		for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
            22. 			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
            23. 				scanner.addIncludeFilter(typeFilter);
            24. 			}
            25. 		}
            26. 		for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
            27. 			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
            28. 				scanner.addExcludeFilter(typeFilter);
            29. 			}
            30. 		}
            31.  
            32. 		boolean lazyInit = componentScan.getBoolean("lazyInit");
            33. 		if (lazyInit) {
            34. 			scanner.getBeanDefinitionDefaults().setLazyInit(true);
            35. 		}
            36.  
            37. 		Set basePackages = new LinkedHashSet<>();
            38. 		String[] basePackagesArray = componentScan.getStringArray("basePackages");
            39. 		for (String pkg : basePackagesArray) {
            40. 			String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
            41. 					ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
            42. 			Collections.addAll(basePackages, tokenized);
            43. 		}
            44. 		for (Class clazz : componentScan.getClassArray("basePackageClasses")) {
            45. 			basePackages.add(ClassUtils.getPackageName(clazz));
            46. 		}
            47. 		if (basePackages.isEmpty()) {
            48. 			basePackages.add(ClassUtils.getPackageName(declaringClass));
            49. 		}
            50.  
            51. 		scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
            52. 			@Override
            53. 			protected boolean matchClassName(String className) {
            54. 				return declaringClass.equals(className);
            55. 			}
            56. 		});
            57. 		return scanner.doScan(StringUtils.toStringArray(basePackages));
            58. 	}
             

            1. protected Set doScan(String... basePackages) {
            2. 		Assert.notEmpty(basePackages, "At least one base package must be specified");
            3. 		Set beanDefinitions = new LinkedHashSet<>();
            4. 		for (String basePackage : basePackages) {
            5. 			Set candidates = findCandidateComponents(basePackage);
            6. 			for (BeanDefinition candidate : candidates) {
            7. 				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            8. 				candidate.setScope(scopeMetadata.getScopeName());
            9. 				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
            10. 				if (candidate instanceof AbstractBeanDefinition) {
            11. 					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
            12. 				}
            13. 				if (candidate instanceof AnnotatedBeanDefinition) {
            14. 					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            15. 				}
            16. 				if (checkCandidate(beanName, candidate)) {
            17. 					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            18. 					definitionHolder =
            19. 							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            20. 					beanDefinitions.add(definitionHolder);
            21. 					registerBeanDefinition(definitionHolder, this.registry);
            22. 				}
            23. 			}
            24. 		}
            25. 		return beanDefinitions;
            26. 	}
             

            1. public Set findCandidateComponents(String basePackage) {
            2. 		if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
            3. 			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
            4. 		}
            5. 		else {
            6. 			return scanCandidateComponents(basePackage);
            7. 		}
            8. 	}
             

            1. private Set scanCandidateComponents(String basePackage) {
            2. 		Set candidates = new LinkedHashSet<>();
            3. 		try {
            4. 			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            5. 					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
            6. 			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
            7. 			boolean traceEnabled = logger.isTraceEnabled();
            8. 			boolean debugEnabled = logger.isDebugEnabled();
            9. 			for (Resource resource : resources) {
            10. 				if (traceEnabled) {
            11. 					logger.trace("Scanning " + resource);
            12. 				}
            13. 				if (resource.isReadable()) {
            14. 					try {
            15. 						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
            16. 						if (isCandidateComponent(metadataReader)) {
            17. 							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
            18. 							sbd.setResource(resource);
            19. 							sbd.setSource(resource);
            20. 							if (isCandidateComponent(sbd)) {
            21. 								if (debugEnabled) {
            22. 									logger.debug("Identified candidate component class: " + resource);
            23. 								}
            24. 								candidates.add(sbd);
            25. 							}
            26. 							else {
            27. 								if (debugEnabled) {
            28. 									logger.debug("Ignored because not a concrete top-level class: " + resource);
            29. 								}
            30. 							}
            31. 						}
            32. 						else {
            33. 							if (traceEnabled) {
            34. 								logger.trace("Ignored because not matching any filter: " + resource);
            35. 							}
            36. 						}
            37. 					}
            38. 					catch (Throwable ex) {
            39. 						throw new BeanDefinitionStoreException(
            40. 								"Failed to read candidate component class: " + resource, ex);
            41. 					}
            42. 				}
            43. 				else {
            44. 					if (traceEnabled) {
            45. 						logger.trace("Ignored because not readable: " + resource);
            46. 					}
            47. 				}
            48. 			}
            49. 		}
            50. 		catch (IOException ex) {
            51. 			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
            52. 		}
            53. 		return candidates;
            54. 	}
             

            注：可以理解parse->processConfigurationClass（最后一句this.configurationClasses.put(configClass, configClass); 将处理的类入口参数类，进行存储）->doProcessConfigurationClass(识别扫描注解)， 处理ComponentScan, 扫描出来的类【configuration，继续parse()】扫描过程中类注册到DefaultListableBeanFactory，和【processImports(此时只是存储import，自动配置的扫描类)， import的类中没有实现部分接口，继续处理processConfigurationClass()】, 打头的parse启动后进行。
             

            注：此时开始自动装载
             

            		this.deferredImportSelectorHandler.process();

             

            1. public void process() {
            2. 			List deferredImports = this.deferredImportSelectors;
            3. 			this.deferredImportSelectors = null;
            4. 			try {
            5. 				if (deferredImports != null) {
            6. 					DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
            7. 					deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
            8. 					deferredImports.forEach(handler::register);
            9. 					handler.processGroupImports();
            10. 				}
            11. 			}
            12. 			finally {
            13. 				this.deferredImportSelectors = new ArrayList<>();
            14. 			}
            15. 		}
             

            1. public void processGroupImports() {
            2. 			for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
            3. 				grouping.getImports().forEach(entry -> {
            4. 					ConfigurationClass configurationClass = this.configurationClasses.get(
            5. 							entry.getMetadata());
            6. 					try {
            7.                         // 注意，这里再次开始import，
            8. 						processImports(configurationClass, asSourceClass(configurationClass),
            9. 								asSourceClasses(entry.getImportClassName()), false);
            10. 					}
            11. 					catch (BeanDefinitionStoreException ex) {
            12. 						throw ex;
            13. 					}
            14. 					catch (Throwable ex) {
            15. 						throw new BeanDefinitionStoreException(
            16. 								"Failed to process import candidates for configuration class [" +
            17. 										configurationClass.getMetadata().getClassName() + "]", ex);
            18. 					}
            19. 				});
            20. 			}
            21. 		}
             

            此时基本的类定义都扫描到了。其中重要的是AutoConfigurationImportSelector，负责的是自动化的配置加载springboot会把所有jar包下META-INF/spring.factories 中的key是org.springframework.boot.autoconfigure.EnableAutoConfiguration 所对应的值的bean放入容器中
             

            1. protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
            2.    // 判断是否开启自动配置
            3.    if (!isEnabled(annotationMetadata)) {
            4.       return EMPTY_ENTRY;
            5.    }
            6.    // 获取@EnableAutoConfiguration注解的属性
            7.    AnnotationAttributes attributes = getAttributes(annotationMetadata);
            8.    // 从spring.factories文件中获取配置类的全限定名数组
            9.    List configurations = getCandidateConfigurations(annotationMetadata, attributes);
            10.    // 去重
            11.    configurations = removeDuplicates(configurations);
            12.    // 获取注解中exclude或excludeName排除的类集合
            13.    Set exclusions = getExclusions(annotationMetadata, attributes);
            14.    // 检查被排除类是否可以实例化，是否被自动配置所使用，否则抛出异常
            15.    checkExcludedClasses(configurations, exclusions);
            16.    // 去除被排除的类
            17.    configurations.removeAll(exclusions);
            18.    // 使用spring.factories配置文件中配置的过滤器对自动配置类进行过滤
            19.    configurations = getConfigurationClassFilter().filter(configurations);
            20.    // 抛出事件
            21.    fireAutoConfigurationImportEvents(configurations, exclusions);
            22.    return new AutoConfigurationEntry(configurations, exclusions);
            23. }
             

            过滤：
             

            1. private ConfigurationClassFilter getConfigurationClassFilter() {
            2.    if (this.configurationClassFilter == null) {
            3.       // 获取AutoConfigurationImportFilter过滤器列表
            4.       List filters = getAutoConfigurationImportFilters();
            5.       for (AutoConfigurationImportFilter filter : filters) {
            6.          invokeAwareMethods(filter);
            7.       }
            8.       this.configurationClassFilter = new ConfigurationClassFilter(this.beanClassLoader, filters);
            9.    }
            10.    return this.configurationClassFilter;
            11. }
             

            开始创建对象
             

            1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
            2. 		// Initialize conversion service for this context.
            3. 		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            4. 				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            5. 			beanFactory.setConversionService(
            6. 					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
            7. 		}
            8.  
            9. 		// Register a default embedded value resolver if no bean post-processor
            10. 		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
            11. 		// at this point, primarily for resolution in annotation attribute values.
            12. 		if (!beanFactory.hasEmbeddedValueResolver()) {
            13. 			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
            14. 		}
            15.  
            16. 		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
            17. 		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
            18. 		for (String weaverAwareName : weaverAwareNames) {
            19. 			getBean(weaverAwareName);
            20. 		}
            21.  
            22. 		// Stop using the temporary ClassLoader for type matching.
            23. 		beanFactory.setTempClassLoader(null);
            24.  
            25. 		// Allow for caching all bean definition metadata, not expecting further changes.
            26. 		beanFactory.freezeConfiguration();
            27.  
            28. 		// Instantiate all remaining (non-lazy-init) singletons.
            29. 		beanFactory.preInstantiateSingletons();
            30. 	}
             

            创建对象主要知识点是3级缓存和对象的生命周期问题
             

            getBean->doGetBean->getSingleton(lamdba表达式)->createBean->doCreateBean
             

            1. 	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
            2. 		Object singletonObject = this.singletonObjects.get(beanName);
            3. 		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            4. 			synchronized (this.singletonObjects) {
            5. 				singletonObject = this.earlySingletonObjects.get(beanName);
            6. 				if (singletonObject == null && allowEarlyReference) {
            7. 					ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
            8. 					if (singletonFactory != null) {
            9. 						singletonObject = singletonFactory.getObject();
            10. 						this.earlySingletonObjects.put(beanName, singletonObject);
            11. 						this.singletonFactories.remove(beanName);
            12. 					}
            13. 				}
            14. 			}
            15. 		}
            16. 		return singletonObject;
            17. 	}
             

            1. public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
            2. 		Assert.notNull(beanName, "Bean name must not be null");
            3. 		synchronized (this.singletonObjects) {
            4. 			Object singletonObject = this.singletonObjects.get(beanName);
            5. 			if (singletonObject == null) {
            6. 				if (this.singletonsCurrentlyInDestruction) {
            7. 					throw new BeanCreationNotAllowedException(beanName,
            8. 							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
            9. 							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            10. 				}
            11. 				if (logger.isDebugEnabled()) {
            12. 					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            13. 				}
            14. 				beforeSingletonCreation(beanName);
            15. 				boolean newSingleton = false;
            16. 				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            17. 				if (recordSuppressedExceptions) {
            18. 					this.suppressedExceptions = new LinkedHashSet<>();
            19. 				}
            20. 				try {
            21. 					singletonObject = singletonFactory.getObject();
            22. 					newSingleton = true;
            23. 				}
            24. 				catch (IllegalStateException ex) {
            25. 					// Has the singleton object implicitly appeared in the meantime ->
            26. 					// if yes, proceed with it since the exception indicates that state.
            27. 					singletonObject = this.singletonObjects.get(beanName);
            28. 					if (singletonObject == null) {
            29. 						throw ex;
            30. 					}
            31. 				}
            32. 				catch (BeanCreationException ex) {
            33. 					if (recordSuppressedExceptions) {
            34. 						for (Exception suppressedException : this.suppressedExceptions) {
            35. 							ex.addRelatedCause(suppressedException);
            36. 						}
            37. 					}
            38. 					throw ex;
            39. 				}
            40. 				finally {
            41. 					if (recordSuppressedExceptions) {
            42. 						this.suppressedExceptions = null;
            43. 					}
            44. 					afterSingletonCreation(beanName);
            45. 				}
            46. 				if (newSingleton) {
            47. 					addSingleton(beanName, singletonObject);
            48. 				}
            49. 			}
            50. 			return singletonObject;
            51. 		}
            52. 	}
             

            1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            2. 			throws BeanCreationException {
            3.  
            4. 		// 实例化类，并形成包装wrapp类，方便属性的注入.
            5. 		BeanWrapper instanceWrapper = null;
            6. 		if (mbd.isSingleton()) {
            7. 			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
            8. 		}
            9. 		if (instanceWrapper == null) {
            10. 			instanceWrapper = createBeanInstance(beanName, mbd, args);
            11. 		}
            12. 		final Object bean = instanceWrapper.getWrappedInstance();
            13. 		Class beanType = instanceWrapper.getWrappedClass();
            14. 		if (beanType != NullBean.class) {
            15. 			mbd.resolvedTargetType = beanType;
            16. 		}
            17.  
            18. 		// Allow post-processors to modify the merged bean definition.
            19. 		synchronized (mbd.postProcessingLock) {
            20. 			if (!mbd.postProcessed) {
            21. 				try {
            22. 					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            23. 				}
            24. 				catch (Throwable ex) {
            25. 					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            26. 							"Post-processing of merged bean definition failed", ex);
            27. 				}
            28. 				mbd.postProcessed = true;
            29. 			}
            30. 		}
            31.  
            32. 		// Eagerly cache singletons to be able to resolve circular references
            33. 		// even when triggered by lifecycle interfaces like BeanFactoryAware.
            34. 		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            35. 				isSingletonCurrentlyInCreation(beanName));
            36. 		if (earlySingletonExposure) {
            37. 			if (logger.isTraceEnabled()) {
            38. 				logger.trace("Eagerly caching bean '" + beanName +
            39. 						"' to allow for resolving potential circular references");
            40. 			}
            41. 			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
            42. 		}
            43.  
            44. 		// Initialize the bean instance.
            45. 		Object exposedObject = bean;
            46. 		try {
            47. 			populateBean(beanName, mbd, instanceWrapper);
            48. 			exposedObject = initializeBean(beanName, exposedObject, mbd);
            49. 		}
            50. 		catch (Throwable ex) {
            51. 			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            52. 				throw (BeanCreationException) ex;
            53. 			}
            54. 			else {
            55. 				throw new BeanCreationException(
            56. 						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            57. 			}
            58. 		}
            59.  
            60. 		if (earlySingletonExposure) {
            61. 			Object earlySingletonReference = getSingleton(beanName, false);
            62. 			if (earlySingletonReference != null) {
            63. 				if (exposedObject == bean) {
            64. 					exposedObject = earlySingletonReference;
            65. 				}
            66. 				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            67. 					String[] dependentBeans = getDependentBeans(beanName);
            68. 					Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
            69. 					for (String dependentBean : dependentBeans) {
            70. 						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
            71. 							actualDependentBeans.add(dependentBean);
            72. 						}
            73. 					}
            74. 					if (!actualDependentBeans.isEmpty()) {
            75. 						throw new BeanCurrentlyInCreationException(beanName,
            76. 								"Bean with name '" + beanName + "' has been injected into other beans [" +
            77. 								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
            78. 								"] in its raw version as part of a circular reference, but has eventually been " +
            79. 								"wrapped. This means that said other beans do not use the final version of the " +
            80. 								"bean. This is often the result of over-eager type matching - consider using " +
            81. 								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
            82. 					}
            83. 				}
            84. 			}
            85. 		}
            86.  
            87. 		// Register bean as disposable.
            88. 		try {
            89. 			registerDisposableBeanIfNecessary(beanName, bean, mbd);
            90. 		}
            91. 		catch (BeanDefinitionValidationException ex) {
            92. 			throw new BeanCreationException(
            93. 					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
            94. 		}
            95.  
            96. 		return exposedObject;
            97. 	}
             

            属性注入：
             

            通过bean的定义属性值，解决属性的注入。
             

            1. protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
            2. 		if (bw == null) {
            3. 			if (mbd.hasPropertyValues()) {
            4. 				throw new BeanCreationException(
            5. 						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            6. 			}
            7. 			else {
            8. 				// Skip property population phase for null instance.
            9. 				return;
            10. 			}
            11. 		}
            12.  
            13. 		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
            14. 		// state of the bean before properties are set. This can be used, for example,
            15. 		// to support styles of field injection.
            16. 		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            17. 			for (BeanPostProcessor bp : getBeanPostProcessors()) {
            18. 				if (bp instanceof InstantiationAwareBeanPostProcessor) {
            19. 					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            20. 					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
            21. 						return;
            22. 					}
            23. 				}
            24. 			}
            25. 		}
            26.  
            27. 		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
            28.  
            29. 		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
            30. 		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            31. 			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            32. 			// Add property values based on autowire by name if applicable.
            33. 			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
            34. 				autowireByName(beanName, mbd, bw, newPvs);
            35. 			}
            36. 			// Add property values based on autowire by type if applicable.
            37. 			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            38. 				autowireByType(beanName, mbd, bw, newPvs);
            39. 			}
            40. 			pvs = newPvs;
            41. 		}
            42.  
            43. 		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
            44. 		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
            45.  
            46. 		PropertyDescriptor[] filteredPds = null;
            47. 		if (hasInstAwareBpps) {
            48. 			if (pvs == null) {
            49. 				pvs = mbd.getPropertyValues();
            50. 			}
            51. 			for (BeanPostProcessor bp : getBeanPostProcessors()) {
            52. 				if (bp instanceof InstantiationAwareBeanPostProcessor) {
            53. 					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            54. 					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
            55. 					if (pvsToUse == null) {
            56. 						if (filteredPds == null) {
            57. 							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            58. 						}
            59. 						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            60. 						if (pvsToUse == null) {
            61. 							return;
            62. 						}
            63. 					}
            64. 					pvs = pvsToUse;
            65. 				}
            66. 			}
            67. 		}
            68. 		if (needsDepCheck) {
            69. 			if (filteredPds == null) {
            70. 				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            71. 			}
            72. 			checkDependencies(beanName, mbd, filteredPds, pvs);
            73. 		}
            74.  
            75. 		if (pvs != null) {
            76. 			applyPropertyValues(beanName, mbd, bw, pvs);
            77. 		}
            78. 	}
             

            三级缓存
             

             

            doCreateBean
             

            			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

             

            AOP代理
             

            1. 	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
            2. 		Object exposedObject = bean;
            3. 		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            4. 			for (BeanPostProcessor bp : getBeanPostProcessors()) {
            5. 				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            6. 					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            7. 					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            8. 				}
            9. 			}
            10. 		}
            11. 		return exposedObject;
            12. 	}
             

            1.   public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
            2.         if (bean != null) {
            3.             Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
            4.             if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            5.                 return this.wrapIfNecessary(bean, beanName, cacheKey);
            6.             }
            7.         }
            8.  
            9.         return bean;
            10.     }
             

            为什么用三级缓存解决循环依赖，二级缓存不行，因为如果testService1被代理过，假设用二级缓存，此时testService2中注入的testService1是半成品的对象。此时testService1的创建流程继续往下走时，走到AbstractAutoProxyCreator会再次创建代理对象，此时testService2中对应的testService1为对象，而spring容器中testService1的BeanName对应的为代理对象。导致一个beanName对应了两个对象。由于testService1位单例。所以用三级缓存解决，testService1中解决这个问题。利用了earlyProxyReferences来解决这个问题。
             

            三级缓存
             

            bean的生命周期
             

            1. BeanNameAware's setBeanName
            2. BeanClassLoaderAware's setBeanClassLoader
            3. BeanFactoryAware's setBeanFactory
            4. EnvironmentAware's setEnvironment
            5. EmbeddedValueResolverAware's setEmbeddedValueResolver
            6. ResourceLoaderAware's setResourceLoader (only applicable when running in an application context)
            7. ApplicationEventPublisherAware's setApplicationEventPublisher (only applicable when running in an application context)
            8. MessageSourceAware's setMessageSource (only applicable when running in an application context)
            9. ApplicationContextAware's setApplicationContext (only applicable when running in an application context)
            10. ServletContextAware's setServletContext (only applicable when running in a web application context)
            11. postProcessBeforeInitialization methods of BeanPostProcessors
            12. InitializingBean's afterPropertiesSet
            13. a custom init-method definition
            14. postProcessAfterInitialization methods of BeanPostProcessors
             

            1. 
             

            1. 	private void invokeAwareMethods(final String beanName, final Object bean) {
            2. 		if (bean instanceof Aware) {
            3. 			if (bean instanceof BeanNameAware) {
            4. 				((BeanNameAware) bean).setBeanName(beanName);
            5. 			}
            6. 			if (bean instanceof BeanClassLoaderAware) {
            7. 				ClassLoader bcl = getBeanClassLoader();
            8. 				if (bcl != null) {
            9. 					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
            10. 				}
            11. 			}
            12. 			if (bean instanceof BeanFactoryAware) {
            13. 				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            14. 			}
            15. 		}
            16. 	}
             

             

            2. refresh->prepareBeanFactory->ApplicationContextAwareProcessor()
             

            在准备prepareBeanFactory时，添加ApplicationContextAwareProcessor
             

            1. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            2. 		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
            3. 				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
            4. 				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
            5. 			return bean;
            6. 		}
            7.  
            8. 		AccessControlContext acc = null;
            9.  
            10. 		if (System.getSecurityManager() != null) {
            11. 			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
            12. 		}
            13.  
            14. 		if (acc != null) {
            15. 			AccessController.doPrivileged((PrivilegedAction) () -> {
            16. 				invokeAwareInterfaces(bean);
            17. 				return null;
            18. 			}, acc);
            19. 		}
            20. 		else {
            21. 			invokeAwareInterfaces(bean);
            22. 		}
            23.  
            24. 		return bean;
            25. 	}
              26.  

               

              1. private void invokeAwareInterfaces(Object bean) {
              2. 		if (bean instanceof EnvironmentAware) {
              3. 			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
              4. 		}
              5. 		if (bean instanceof EmbeddedValueResolverAware) {
              6. 			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
              7. 		}
              8. 		if (bean instanceof ResourceLoaderAware) {
              9. 			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
              10. 		}
              11. 		if (bean instanceof ApplicationEventPublisherAware) {
              12. 			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
              13. 		}
              14. 		if (bean instanceof MessageSourceAware) {
              15. 			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
              16. 		}
              17. 		if (bean instanceof ApplicationContextAware) {
              18. 			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
              19. 		}
              20. 	}
               

              3. refresh->postProcessBeanFactory
               

              1. protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
              2. 		beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
              3. 		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
              4. 		registerWebApplicationScopes();
              5. 	}
               

              1. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
              2. 		if (getServletContext() != null && bean instanceof ServletContextAware) {
              3. 			((ServletContextAware) bean).setServletContext(getServletContext());
              4. 		}
              5. 		if (getServletConfig() != null && bean instanceof ServletConfigAware) {
              6. 			((ServletConfigAware) bean).setServletConfig(getServletConfig());
              7. 		}
              8. 		return bean;
              9. 	}
               

               


               InitDestroyAnnotationBeanPostProcessor
               

              1. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
              2. 		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
              3. 		try {
              4. 			metadata.invokeInitMethods(bean, beanName);
              5. 		}
              6. 		catch (InvocationTargetException ex) {
              7. 			throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
              8. 		}
              9. 		catch (Throwable ex) {
              10. 			throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
              11. 		}
              12. 		return bean;
              13. 	}
               

              4. @PostConstruct方法
               

              5. InitializingBean->afterPropertiesSet方法
               

              6.@init-method
               

              1. protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
              2. 			throws Throwable {
              3.  
              4. 		boolean isInitializingBean = (bean instanceof InitializingBean);
              5. 		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
              6. 			if (logger.isTraceEnabled()) {
              7. 				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
              8. 			}
              9. 			if (System.getSecurityManager() != null) {
              10. 				try {
              11. 					AccessController.doPrivileged((PrivilegedExceptionAction) () -> {
              12. 						((InitializingBean) bean).afterPropertiesSet();
              13. 						return null;
              14. 					}, getAccessControlContext());
              15. 				}
              16. 				catch (PrivilegedActionException pae) {
              17. 					throw pae.getException();
              18. 				}
              19. 			}
              20. 			else {
              21. 				((InitializingBean) bean).afterPropertiesSet();
              22. 			}
              23. 		}
              24.  
              25. 		if (mbd != null && bean.getClass() != NullBean.class) {
              26. 			String initMethodName = mbd.getInitMethodName();
              27. 			if (StringUtils.hasLength(initMethodName) &&
              28. 					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
              29. 					!mbd.isExternallyManagedInitMethod(initMethodName)) {
              30. 				invokeCustomInitMethod(beanName, bean, mbd);
              31. 			}
              32. 		}
              33. 	}
                34.  

                postProcessAfterInitialization
                 

                1. public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
                2. 			throws BeansException {
                3.  
                4. 		Object result = existingBean;
                5. 		for (BeanPostProcessor processor : getBeanPostProcessors()) {
                6. 			Object current = processor.postProcessAfterInitialization(result, beanName);
                7. 			if (current == null) {
                8. 				return result;
                9. 			}
                10. 			result = current;
                11. 		}
                12. 		return result;
                13. 	}
                 

                
                
                    
                

                
              34. 

                    相关阅读:
                
                    
P5682 [CSP-J2019 江西] 次大值                            
                
动手学深度学习（Pytorch版）代码实践 -深度学习基础-09过拟合与欠拟合                            
                
python四舍五入（round精度不够，有时不能实现四舍五入）                            
                
MongoDB应用：forEach方法实际应用                            
                
算法学习的积累                            
                
国考省考行测：言语理解与表达，主旨理解，结构分析法，总分结构                            
                
[H5动画制作系列]代码画图                            
                
Transformers基本组件（二）快速入门Datasets、Evaluate、Trainer                            
                
spring中事务隔离指什么呢？                            
                
通过QGIS下载高程数据并进行矢量数据高程的计算                            
                
                                    
                
                35. 
                
              35. 
                    原文地址：https://blog.csdn.net/xiaomagezuishuai/article/details/127586411
                
                36.