继上次注册 bean 之后好久没更新，这两天有空查了查资料也自己看了看 spring BeanFactory 的 getBean(beanName); 这个方法。因时间有限不能像之前那样复制代码并一行一行写上注释，这次只是将代码流程中的一些方法复制出来进行注释。

Spring 的版本是 5.1.3.RELEASE

首先是 getBean(String beanName);

  1. Person person = (Person) context.getBean("person");
  1. protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
  2. 			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  3.     // 获取 beanName 参数 name 有可能是别名也有可能是 FactoryBean 带 "&" 前缀
  4. 	final String beanName = transformedBeanName(name);
  5. 	Object bean;
  6. 	// 获取缓存中的 bean
  7. 	// Eagerly check singleton cache for manually registered singletons.
  8. 	Object sharedInstance = getSingleton(beanName);
  9. 	if (sharedInstance != null && args == null) {
  10. 		if (logger.isTraceEnabled()) {
  11. 			if (isSingletonCurrentlyInCreation(beanName)) {
  12. 				logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  13. 						"' that is not fully initialized yet - a consequence of a circular reference");
  14. 			}
  15. 			else {
  16. 				logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  17. 			}
  18. 		}
  19. 		// 获取 bean 实例
  20. 		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  21. 	}
  23. 	else {
  24. 	    // 如果 bean 的范围是非单例的则会报错，只有单例才会去尝试解决循环依赖
  25. 		// Fail if we're already creating this bean instance:
  26. 		// We're assumably within a circular reference.
  27. 		if (isPrototypeCurrentlyInCreation(beanName)) {
  28. 			throw new BeanCurrentlyInCreationException(beanName);
  29. 		}
  31. 		// 获取 parentBeanFactory 在当前例子中 parentBeanFactory 为 null
  32. 		// Check if bean definition exists in this factory.
  33. 		BeanFactory parentBeanFactory = getParentBeanFactory();
  34. 		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  35. 			// Not found -> check parent.
  36. 			String nameToLookup = originalBeanName(name);
  37. 			if (parentBeanFactory instanceof AbstractBeanFactory) {
  38. 				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  39. 						nameToLookup, requiredType, args, typeCheckOnly);
  40. 			}
  41. 			else if (args != null) {
  42. 				// Delegation to parent with explicit args.
  43. 				return (T) parentBeanFactory.getBean(nameToLookup, args);
  44. 			}
  45. 			else if (requiredType != null) {
  46. 				// No args -> delegate to standard getBean method.
  47. 				return parentBeanFactory.getBean(nameToLookup, requiredType);
  48. 			}
  49. 			else {
  50. 				return (T) parentBeanFactory.getBean(nameToLookup);
  51. 			}
  52. 		}
  54. 		// typeCheckOnly: 是否获取实例用于类型检查而不是实际使用
  55.            // !typeCheckOnly 如果不只是做类型检查而需要实际创建使用
  56. 		if (!typeCheckOnly) {
  57. 		    // 调用 alreadyCreated.add 将 beanName 加入到缓存标记
  58. 			markBeanAsCreated(beanName);
  59. 		}
  61. 		try {
  62. 		    // 将之前注册好的 BeanDefinition 转成 RootBeanDefinition 如果存在 Parent 就将属性合并
  63. 			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  64. 			checkMergedBeanDefinition(mbd, beanName, args);
  66. 			// 如果存在依赖则需要递归实例化依赖的 bean
  67. 			// Guarantee initialization of beans that the current bean depends on.
  68. 			String[] dependsOn = mbd.getDependsOn();
  69. 			if (dependsOn != null) {
  70. 				for (String dep : dependsOn) {
  71. 					if (isDependent(beanName, dep)) {
  72. 						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  73. 								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  74. 					}
  75. 					registerDependentBean(dep, beanName);
  76. 					try {
  77. 					    // 则遍历调用 getBean
  78. 						getBean(dep);
  79. 					}
  80. 					catch (NoSuchBeanDefinitionException ex) {
  82. 					}
  83. 				}
  84. 			}
  86. 			// 如果 RootBeanDefinition 实例时单例的范围
  87. 			// Create bean instance.
  88. 			if (mbd.isSingleton()) {
  89. 			    // 则调用 getSingleton() 方法来获取到 bean 实例
  90. 				sharedInstance = getSingleton(beanName, () -> {
  91. 					try {
  92. 						// 核心创建 bean 回调方法
  93. 						return createBean(beanName, mbd, args);
  94. 					}
  95. 					catch (BeansException ex) {
  96. 						// Explicitly remove instance from singleton cache: It might have been put there
  97. 						// eagerly by the creation process, to allow for circular reference resolution.
  98. 						// Also remove any beans that received a temporary reference to the bean.
  99. 						destroySingleton(beanName);
  100. 						throw ex;
  101. 					}
  102. 				});
  103. 				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  104. 			}
  105. 			// 省略其他代码
  106. 		}
  107. 		catch (BeansException ex) {
  108. 			// 省略其他代码
  109. 		}
  110. 	}
  111. 	return (T) bean;
  112. }

1.public Object getBean(String name);

1.1.doGetBean(name, null, null, false);

1.1.1.final String beanName = transformedBeanName(name); 先获取到对应的 beanName

1.1.2.Object sharedInstance = getSingleton(beanName); 在缓存中检查是否已经存在创建好的 bean 里面涉及到几个 map

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); Key: beanName value: bean 实例

private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); Key: beanName value: bean 实例 与 singletonObjects 区别是用于存放 ObjectFactory.getObject(); 返回的 bean 实例

private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); Key: beanName value: ObjectFactory 缓存的是单例工厂

1.1.3.if (isPrototypeCurrentlyInCreation(beanName)); 如果当前的 bean 正在创建则直接抛出异常 throw new BeanCurrentlyInCreationException(beanName);

1.1.4.BeanFactory parentBeanFactory = getParentBeanFactory(); 获取当前 bean 定义是否存在父容器 parentBeanFactory 比如 spring springmvc 父子容器

1.1.5.markBeanAsCreated(beanName); 标记当前 bean 正在创建打上标识

private final Set alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256)); 存储的是已经创建过的 beanName

private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256); Key: beanName value: beanDefinition 存储是是已经创建过的 beanName 和 bean 定义

1.1.6.final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 获取到 beanName 对应的 beanDefinition 从 mergedBeanDefinitions 获取，第一次是返回一个新的 RootBeanDefinition

1.1.7.checkMergedBeanDefinition(mbd, beanName, args); 检查如果该 bean 是一个抽象类抛出异常 throw new BeanIsAbstractException(beanName);

1.1.8.String[] dependsOn = mbd.getDependsOn(); 获取是否需要处理依赖 bean 如果需要则遍历 dependsOn 的元素调用 getBean(dep);

1.1.9.if (mbd.isSingleton()) 如果该 bean 是单例的话直接创建

1.2.0.getSingleton(String beanName, ObjectFactory<?> singletonFactory); 调用 getSingleton 方法创建 bean，主要核心在第二个参数的 createBean(beanName, mbd, args); 方法

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory);

  1. public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  2. 	Assert.notNull(beanName, "Bean name must not be null");
  3. 	synchronized (this.singletonObjects) {
  4. 	    // 首先还是先从一级缓存获取最终的 bean 实例
  5. 		Object singletonObject = this.singletonObjects.get(beanName);
  6. 		// 如果获取不到
  7. 		if (singletonObject == null) {
  8. 			if (this.singletonsCurrentlyInDestruction) {
  9. 				throw new BeanCreationNotAllowedException();
  10. 			}
  11. 			if (logger.isDebugEnabled()) {
  12. 				logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
  13. 			}
  14. 			// 将 beanName 放入 singletonsCurrentlyInCreation 缓存标记正在创建中
  15. 			beforeSingletonCreation(beanName);
  16. 			boolean newSingleton = false;
  17. 			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  18. 			if (recordSuppressedExceptions) {
  19. 				this.suppressedExceptions = new LinkedHashSet<>();
  20. 			}
  21. 			try {
  22. 			    // 调用参数 lambda 表达式传递的行为也就是 ObjectFactory 类型的匿名内部类
  23. 				singletonObject = singletonFactory.getObject();
  24. 				newSingleton = true;
  25. 			}
  26. 			catch (IllegalStateException ex) {
  27. 				// Has the singleton object implicitly appeared in the meantime ->
  28. 				// if yes, proceed with it since the exception indicates that state.
  29. 				singletonObject = this.singletonObjects.get(beanName);
  30. 				if (singletonObject == null) {
  31. 					throw ex;
  32. 				}
  33. 			}
  34. 			catch (BeanCreationException ex) {
  35. 				if (recordSuppressedExceptions) {
  36. 					for (Exception suppressedException : this.suppressedExceptions) {
  37. 						ex.addRelatedCause(suppressedException);
  38. 					}
  39. 				}
  40. 				throw ex;
  41. 			}
  42. 			finally {
  43. 				if (recordSuppressedExceptions) {
  44. 					this.suppressedExceptions = null;
  45. 				}
  46.                    // 将 beanName 从 singletonsCurrentlyInCreation 缓存标记从删除
  47. 				afterSingletonCreation(beanName);
  48. 			}
  49. 			if (newSingleton) {
  50. 			    // 加入一级缓存删除二三级缓存
  51. 				addSingleton(beanName, singletonObject);
  52. 			}
  53. 		}
  54. 		return singletonObject;
  55. 	}
  56. }

2.public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory);

2.1.Object singletonObject = this.singletonObjects.get(beanName); 尝试从缓存中获取如果获取不到并且该 bean 在销毁中则抛出异常 throw new BeanCreationNotAllowedException(beanName, message);

private boolean singletonsCurrentlyInDestruction = false; 销毁标识

2.2.beforeSingletonCreation(beanName); 将该 bean 加入创建单例 bean 的缓存中

2.3.singletonObject = singletonFactory.getObject(); 重点来了直接调用 ObjectFactory.createBean(beanName, mbd, args); 方法创建 bean

2.4.addSingleton(beanName, singletonObject); 最后将创建好的 bean 依次放入缓存

private final Set registeredSingletons = new LinkedHashSet<>(256); 存储的是创建好的 beanName

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args);

  1. protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  2. 			throws BeanCreationException {
  4. 	if (logger.isTraceEnabled()) {
  5. 		logger.trace("Creating instance of bean '" + beanName + "'");
  6. 	}
  7. 	RootBeanDefinition mbdToUse = mbd;
  9. 	// 首先获取到 beanName 的 Class 对象
  10. 	// Make sure bean class is actually resolved at this point, and
  11. 	// clone the bean definition in case of a dynamically resolved Class
  12. 	// which cannot be stored in the shared merged bean definition.
  13. 	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  14. 	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  15. 		mbdToUse = new RootBeanDefinition(mbd);
  16. 		mbdToUse.setBeanClass(resolvedClass);
  17. 	}
  19. 	// Prepare method overrides.
  20. 	try {
  21. 	    // 处理重写的方法
  22. 		mbdToUse.prepareMethodOverrides();
  23. 	}
  24. 	catch (BeanDefinitionValidationException ex) {
  25. 		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  26. 				beanName, "Validation of method overrides failed", ex);
  27. 	}
  29. 	try {
  30. 	    // 给 BeanPostProcessors 一个返回代理而不是目标 bean 实例的机会
  31. 		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  32. 		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  33. 		if (bean != null) {
  34. 			return bean;
  35. 		}
  36. 	}
  37. 	catch (Throwable ex) {
  38. 		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  39. 				"BeanPostProcessor before instantiation of bean failed", ex);
  40. 	}
  42. 	try {
  43. 	    // 创建 bean
  44. 		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  45. 		if (logger.isTraceEnabled()) {
  46. 			logger.trace("Finished creating instance of bean '" + beanName + "'");
  47. 		}
  48. 		return beanInstance;
  49. 	}
  50. 	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
  51. 		// A previously detected exception with proper bean creation context already,
  52. 		// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
  53. 		throw ex;
  54. 	}
  55. 	catch (Throwable ex) {
  56. 		throw new BeanCreationException(
  57. 				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  58. 	}
  59. }

3.1.Class<?> resolvedClass = resolveBeanClass(mbd, beanName); 获取该 bean 对应的 class

3.2.mbdToUse.prepareMethodOverrides(); 设置该 bean 是否有重写方法

3.3.Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 在该 bean 实例化之前，检查是否需要返回 proxy 代理对象。

3.4.Object beanInstance = doCreateBean(beanName, mbdToUse, args); 进行实例化 bean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args);

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
  2.        // BeanWrapper 是 Spring 提供的对 bean 操作的封装
  3. 	// Instantiate the bean.
  4. 	BeanWrapper instanceWrapper = null;
  5. 	if (mbd.isSingleton()) {
  6. 	    // 如果是单例模式就从 factoryBeanInstanceCache 缓存中删除
  7. 		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  8. 	}
  9. 	// 如果不存在缓存中
  10. 	if (instanceWrapper == null) {
  11. 	    // 创建 bean
  12. 		instanceWrapper = createBeanInstance(beanName, mbd, args);
  13. 	}
  14. 	final Object bean = instanceWrapper.getWrappedInstance();
  15. 	Class<?> beanType = instanceWrapper.getWrappedClass();
  16. 	if (beanType != NullBean.class) {
  17. 		mbd.resolvedTargetType = beanType;
  18. 	}
  20. 	// Allow post-processors to modify the merged bean definition.
  21. 	synchronized (mbd.postProcessingLock) {
  22. 		if (!mbd.postProcessed) {
  23. 			try {
  24. 			    // 遍历所有 MergedBeanDefinitionPostProcessor 执行 postProcessMergedBeanDefinition 方法
  25. 				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  26. 			}
  27. 			catch (Throwable ex) {
  28. 				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  29. 						"Post-processing of merged bean definition failed", ex);
  30. 			}
  31. 			mbd.postProcessed = true;
  32. 		}
  33. 	}
  34.        // 如果当前 bean 是一个单例的并且自动尝试解析 bean 之间的循环引用，并且正在创建中则加入三级缓存
  35. 	// Eagerly cache singletons to be able to resolve circular references
  36. 	// even when triggered by lifecycle interfaces like BeanFactoryAware.
  37. 	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  38. 			isSingletonCurrentlyInCreation(beanName));
  39. 	if (earlySingletonExposure) {
  40. 		if (logger.isTraceEnabled()) {
  41. 			logger.trace("Eagerly caching bean '" + beanName +
  42. 					"' to allow for resolving potential circular references");
  43. 		}
  44. 		// 加入三级缓存
  45. 		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  46. 	}
  48. 	// Initialize the bean instance.
  49. 	Object exposedObject = bean;
  50. 	try {
  51. 	    // 填充属性
  52. 		populateBean(beanName, mbd, instanceWrapper);
  53. 		// 执行 init 方法和 init-method 配置方法
  54. 		exposedObject = initializeBean(beanName, exposedObject, mbd);
  55. 	}
  56. 	catch (Throwable ex) {
  57. 		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  58. 			throw (BeanCreationException) ex;
  59. 		}
  60. 		else {
  61. 			throw new BeanCreationException(
  62. 					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  63. 		}
  64. 	}
  65. 	// 省略代码
  66. 	// Register bean as disposable.
  67. 	try {
  68. 		registerDisposableBeanIfNecessary(beanName, bean, mbd);
  69. 	}
  70. 	catch (BeanDefinitionValidationException ex) {
  71. 		throw new BeanCreationException(
  72. 				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  73. 	}
  75. 	return exposedObject;
  76. }

4.1.instanceWrapper = createBeanInstance(beanName, mbd, args); 创建 bean 里面就是调用反射使用构造器创建实例 bean

4.2.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 获取所有的 BeanPostProcessor 判断里面元素是不是 MergedBeanDefinitionPostProcessor，再调用 MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(mbd, beanType, beanName);

4.3.populateBean(beanName, mbd, instanceWrapper); 到了初始化 bean 数据的函数

4.4.initializeBean(beanName, exposedObject, mbd); 执行一些 bean 后置处理(BeanNameAware、BeanClassLoaderAware、BeanFactoryAware、BeanPostProcessor);

4.5.registerDisposableBeanIfNecessary(beanName, bean, mbd); 注册销毁 bean 的回调

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw);

  1. protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
  2. 	// 如果 bw bean 实例为 null 并且 beanDefinition 中描述 bean 的属性不为空则抛出异常
  3.     if (bw == null) {
  4. 		if (mbd.hasPropertyValues()) {
  5. 			throw new BeanCreationException(
  6. 					mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
  7. 		}
  8. 		else {
  9. 			// Skip property population phase for null instance.
  10. 			return;
  11. 		}
  12. 	}
  14. 	// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
  15. 	// state of the bean before properties are set. This can be used, for example,
  16. 	// to support styles of field injection.
  17. 	boolean continueWithPropertyPopulation = true;
  19.     // 如果注册了 InstantiationAwareBeanPostProcessor 则遍历调用 postProcessAfterInstantiation 方法
  20. 	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  21. 		for (BeanPostProcessor bp : getBeanPostProcessors()) {
  22. 			if (bp instanceof InstantiationAwareBeanPostProcessor) {
  23. 				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  24. 				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
  25. 					continueWithPropertyPopulation = false;
  26. 					break;
  27. 				}
  28. 			}
  29. 		}
  30. 	}
  32. 	if (!continueWithPropertyPopulation) {
  33. 		return;
  34. 	}
  36. 	// spring 会根据注入类型来判断调用哪个方法一般默认是 AUTOWIRE_NO
  37. 	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
  39. 	if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
  40. 		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  41. 		// Add property values based on autowire by name if applicable.
  42. 		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
  43. 		    // 根据 name 注入
  44. 			autowireByName(beanName, mbd, bw, newPvs);
  45. 		}
  46. 		// Add property values based on autowire by type if applicable.
  47. 		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
  48. 		    // 根据 type 注入
  49. 			autowireByType(beanName, mbd, bw, newPvs);
  50. 		}
  51. 		pvs = newPvs;
  52. 	}
  54. 	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
  55. 	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
  57. 	PropertyDescriptor[] filteredPds = null;
  58. 	if (hasInstAwareBpps) {
  59. 		if (pvs == null) {
  60. 			pvs = mbd.getPropertyValues();
  61. 		}
  62. 		for (BeanPostProcessor bp : getBeanPostProcessors()) {
  63. 			if (bp instanceof InstantiationAwareBeanPostProcessor) {
  64. 				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  65. 				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
  66. 				if (pvsToUse == null) {
  67. 					if (filteredPds == null) {
  68. 						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  69. 					}
  70. 					pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
  71. 					if (pvsToUse == null) {
  72. 						return;
  73. 					}
  74. 				}
  75. 				pvs = pvsToUse;
  76. 			}
  77. 		}
  78. 	}
  79. 	if (needsDepCheck) {
  80. 		if (filteredPds == null) {
  81. 			filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  82. 		}
  83. 		checkDependencies(beanName, mbd, filteredPds, pvs);
  84. 	}
  86. 	if (pvs != null) {
  87. 		applyPropertyValues(beanName, mbd, bw, pvs);
  88. 	}
  89. }

5.1.if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) 到这步的时候 bean 实例化完成但是还没开始属性设值，取所有 InstantiationAwareBeanPostProcessor 的实现类调用 postProcessAfterInstantiation(bw.getWrappedInstance(), beanName); InstantiationAwareBeanPostProcessor 的实现类可以在这里对 bean 进行状态修改

5.2.PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); 取出该 bean 的所有属性

5.3.autowireByName(beanName, mbd, bw, newPvs); 通过 name 找到所有属性值

5.4.autowireByType(beanName, mbd, bw, newPvs); 通过 type 找到所有属性值

5.5.for (BeanPostProcessor bp : getBeanPostProcessors()) 获取所有的 BeanPostProcessor

5.6.if (bp instanceof InstantiationAwareBeanPostProcessor) 找到所有的 InstantiationAwareBeanPostProcessor 类型

5.7.pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); 对采用 @Autowired 注解的依赖进行设值 field.set(bean, value);

5.8.if (pvs != null) applyPropertyValues(beanName, mbd, bw, pvs); 设置该 bean 的属性值

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd);

  1. protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
  2. 	if (System.getSecurityManager() != null) {
  3. 		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  4. 		    // 调用实现了 XxxAware 接口的方法
  5. 			invokeAwareMethods(beanName, bean);
  6. 			return null;
  7. 		}, getAccessControlContext());
  8. 	}
  9. 	else {
  10.            // 调用实现了 XxxAware 接口的方法
  11. 		invokeAwareMethods(beanName, bean);
  12. 	}
  14. 	Object wrappedBean = bean;
  15. 	if (mbd == null || !mbd.isSynthetic()) {
  16. 	    // 调用 BeanPostProcessor.postProcessBeforeInitialization
  17. 		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  18. 	}
  20. 	try {
  21. 	    // 调用 InitializingBean 接口的方法
  22. 		invokeInitMethods(beanName, wrappedBean, mbd);
  23. 	}
  24. 	catch (Throwable ex) {
  25. 		throw new BeanCreationException(
  26. 				(mbd != null ? mbd.getResourceDescription() : null),
  27. 				beanName, "Invocation of init method failed", ex);
  28. 	}
  29. 	if (mbd == null || !mbd.isSynthetic()) {
  30.            // 调用 BeanPostProcessor.postProcessAfterInitialization
  31. 		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  32. 	}
  34. 	return wrappedBean;
  35. }
  37. protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
  38. 			throws Throwable {
  40. 		boolean isInitializingBean = (bean instanceof InitializingBean);
  41. 		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
  42. 			if (logger.isTraceEnabled()) {
  43. 				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
  44. 			}
  45. 			if (System.getSecurityManager() != null) {
  46. 				try {
  47. 					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
  48. 					    // 调用 InitializingBean.afterPropertiesSet
  49. 						((InitializingBean) bean).afterPropertiesSet();
  50. 						return null;
  51. 					}, getAccessControlContext());
  52. 				}
  53. 				catch (PrivilegedActionException pae) {
  54. 					throw pae.getException();
  55. 				}
  56. 			}
  57. 			else {
  58.                 // 调用 InitializingBean.afterPropertiesSet
  59. 				((InitializingBean) bean).afterPropertiesSet();
  60. 			}
  61. 		}
  63. 		if (mbd != null && bean.getClass() != NullBean.class) {
  64.             // 判断是否指定了 init-method,如果指定了则调用
  65. 			String initMethodName = mbd.getInitMethodName();
  66. 			if (StringUtils.hasLength(initMethodName) &&
  67. 					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
  68. 					!mbd.isExternallyManagedInitMethod(initMethodName)) {
  69.                 // 利用反射机制执行
  70. 				invokeCustomInitMethod(beanName, bean, mbd);
  71. 			}
  72. 		}
  73. 	}

6.1.invokeAwareMethods(beanName, bean); 如果该 bean 实现了 Aware(BeanNameAware、BeanClassLoaderAware、BeanFactoryAware) 接口则调用对应的 set 方法进行赋值

6.2.wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 获取出所有的 BeanPostProcessor 调用对应的 Object current = processor.postProcessBeforeInitialization(result, beanName);

6.3.invokeInitMethods(beanName, wrappedBean, mbd); 如果该 bean 实现了 InitializingBean 接口则调用对应的 ((InitializingBean) bean).afterPropertiesSet();

6.4.invokeCustomInitMethod(beanName, bean, mbd); 调用 bean 自定义的 init-method 方法

6.5.wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); 获取出所有的 BeanPostProcessor 调用对应的 Object current = processor.postProcessAfterInitialization(result, beanName);

执行完这 6 步之后一个 spring bean 的加载就已经结束了进行逐层返回。帮助了自己巩固记忆，如果写的不足之处望指出谢谢各位观看！

注释

id 和 name

每个 bean 在配置的时候都有唯一的名字和多个别名，获取 bean 的时候可以通过 beanName 也可以通过别名

  1. beanFactory.getBean("beanName or alias");

以下配置的结果就是：beanName 为 person，别名有 3 个，分别为 p1、p2、p3。

  1. <bean id="person" name="p1, p2, p3" class="com.feil.springtest.ioc.test01.Person">

以下配置的结果就是：beanName 为 p1，别名有 2 个，分别为 p2、p3。

  1. <bean name="p1, p2, p3" class="com.javadoop.example.MessageServiceImpl" />

以下配置的结果就是：beanName 为：com.feil.springtest.ioc.test01.Person#0，

  1. <bean class="com.feil.springtest.ioc.test01.Person" />

以下配置的结果就是：beanName 为 person，没有别名。

  1. <bean id="person" class="com.feil.springtest.ioc.test01.Person" />
profile

我们可以把不同环境的配置分别配置到单独的文件中

  1. <beans profile="dev" ....>
  2. 	<bean ... />
  3. 	<bean ... />
  4. 	<bean ... />
  5. </beans>
  1. <beans profile="test" ....>
  2. 	<bean ... />
  3. 	<bean ... />
  4. 	<bean ... />
  5. </beans>

当然，我们也可以在一个配置文件中使用：

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns:jdbc="http://www.springframework.org/schema/jdbc"
  4.     xmlns:jee="http://www.springframework.org/schema/jee"
  5.     xsi:schemaLocation="...">
  7.     <beans profile="dev">
  8.         ...
  9.     </beans>
  11.     <beans profile="test">
  12.         ...
  13.     </beans>
  14. </beans>

那么 spring 是怎么识别出不同的环境呢？Spring 在启动的过程中，会去寻找 “spring.profiles.active” 的属性值，根据这个属性值来的。那怎么配置这个值呢？

Spring 会在这几个地方寻找 spring.profiles.active 的属性值：操作系统环境变量、JVM 系统变量、web.xml 中定义的参数、JNDI。

最简单的方式肯定是在程序启动的时候指定：

  1. -Dspring.spring.profiles.active="dev"
BeanPostProcessor

BeanPostProcessor接口作用：

如果我们想在 Spring 容器中完成 bean 实例化、配置以及其他初始化方法前后要添加一些自己逻辑处理。我们需要定义一个或多个 BeanPostProcessor 接口实现类，然后注册到 Spring IoC 容器中。

BeanPostProcessor 概念在 Spring 中也是比较重要的。我们看下接口定义：

  1. public interface BeanPostProcessor {
  2.     @Nullable
  3.     default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  4.         return bean;
  5.     }
  7.     @Nullable
  8.     default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  9.         return bean;
  10.     }
  11. }

1：后置处理器的 postProcessorBeforeInitailization 方法是 bean 在初始化之前会执行 postProcessBeforeInitialization 这个方法。

2：后置处理器的 postProcessorAfterInitailization 方法是在 bean 初始化完成之后会执行 postProcessAfterInitialization 这个方法。

请看第一个方法，这个方法接受的第一个参数是 bean 实例重点在返回值将会作为新的 bean 实例，那意味着什么呢？我们很容易想到的就是，我们这里可以对一些我们想要修饰的 bean 实例做一些事情。但是对于 Spring 框架来说，它会决定是不是要在这个方法中返回 bean 实例的代理。

Spring 源码学习——加载 Bean的更多相关文章

  1. Spring 源码学习 - 单例bean的实例化过程

    本文作者:geek,一个聪明好学的同事 1. 简介 开发中我们常用@Commpont,@Service,@Resource等注解或者配置xml去声明一个类,使其成为spring容器中的bean,以下我 ...

  2. Spring源码学习笔记之bean标签属性介绍及作用

    传统的Spring项目, xml 配置bean在代码中是经常遇到, 那么在配置bean的时候,这些属性的作用是什么呢? 虽然说现在boot项目兴起,基于xml配置的少了很多, 但是如果能够了解这些标签 ...

  3. Spring源码学习笔记12——总结篇,IOC，Bean的生命周期，三大扩展点

    Spring源码学习笔记12--总结篇,IOC,Bean的生命周期,三大扩展点 参考了Spring 官网文档 https://docs.spring.io/spring-framework/docs/ ...

  4. Spring源码学习-容器BeanFactory(三) BeanDefinition的创建-解析Spring的默认标签

    写在前面 上文Spring源码学习-容器BeanFactory(二) BeanDefinition的创建-解析前BeanDefinition的前置操作中Spring对XML解析后创建了对应的Docum ...

  5. Spring源码学习-容器BeanFactory(二) BeanDefinition的创建-解析前BeanDefinition的前置操作

    写在前面 上文 Spring源码学习-容器BeanFactory(一) BeanDefinition的创建-解析资源文件主要讲Spring容器创建时通过XmlBeanDefinitionReader读 ...

  6. Spring源码学习-容器BeanFactory(一) BeanDefinition的创建-解析资源文件

    写在前面 从大四实习至今已一年有余,作为一个程序员,一直没有用心去记录自己工作中遇到的问题,甚是惭愧,打算从今日起开始养成写博客的习惯.作为一名java开发人员,Spring是永远绕不过的话题,它的设 ...

  7. 框架源码系列六：Spring源码学习之Spring IOC源码学习

    Spring 源码学习过程: 一.搞明白IOC能做什么,是怎么做的  1. 搞明白IOC能做什么? IOC是用为用户创建.管理实例对象的.用户需要实例对象时只需要向IOC容器获取就行了,不用自己去创建 ...

  8. Spring 源码学习 04：初始化容器与 DefaultListableBeanFactory

    前言 在前一篇文章:创建 IoC 容器的几种方式中,介绍了四种方式,这里以 AnnotationConfigApplicationContext 为例,跟进代码,看看 IoC 的启动流程. 入口 从 ...

  9. Spring源码学习笔记9——构造器注入及其循环依赖

    Spring源码学习笔记9--构造器注入及其循环依赖 一丶前言 前面我们分析了spring基于字段的和基于set方法注入的原理,但是没有分析第二常用的注入方式(构造器注入)(第一常用字段注入),并且在 ...

随机推荐

  1. 排序算法（一） 插入排序及Java实现

    代码实现: public void insertionSort(List<T> list, Comparator<T> comparator) { for (int i=1; ...

  2. python pandas 　使用列表快速创建数据 用于测试

    创建数据和行append数据 >>> df = pd.DataFrame([['AA', 1.00], ['Ks', 2.00]], columns=['name', 'age']) ...

  3. 关于python语言学习心得

    最近又开始学习代码了,中途停顿了2个月左右,学习贵在坚持. 内心非常渴望学会一门编程语言,对代码目前来说还不是排斥. 也没有什么好的学习方法,只是按照同事说的,买了一本书籍来,边看边练习,先熟悉它的语 ...

  4. https://blog.csdn.net/rubbertree/article/details/88877262

    本文链接:https://blog.csdn.net/rubbertree/article/details/88877262 https://blog.csdn.net/mingtianhaiyouw ...

  5. 随时更新web html 项目页面，查看手机等其他移动设备的几种方法？

    想一想自己一边写着代码,一边随时看着手机更新页面,对于前端开发者来说是不是爽歪歪: 实现以上效果只需要几个方法: 1) 安装虚拟机 Oracle VM VirtualBox (安装过程省略) 2) 安 ...

  6. 并发编程 --进、线程池、协程、IO模型

    内容目录: 1.socket服务端实现并发 2.进程池,线程池 3.协程 4.IO模型 1.socket服务端实现并发 # 客户端: import socket client = socket.soc ...

  7. tzfile - 时区信息

    SYNOPSIS #include <tzfile.h> DESCRIPTION 时区信息文件被 tzset(3) 使用, 其开头为特征字符"TZif", 以此标示该文 ...

  8. JS Window对象 计时器setInterval() 在执行时,从载入页面后每隔指定的时间执行代码。

    计时器setInterval() 在执行时,从载入页面后每隔指定的时间执行代码. 语法: setInterval(代码,交互时间); 参数说明: 1. 代码:要调用的函数或要执行的代码串. 2. 交互 ...

  9. [转载]python异常如何全面捕获

    写在前面:最近写python程序,进场遇到异常的问题,因此需要捕获异常.查阅了下资料,整理如下: 常见的异常处理的方法: 假设有下面的一段程序: try:     语句1     语句2     . ...

  10. Windows中区位码转换为机内码

    步骤的简化 区位码的区和位分别加上32得到国标码, 再分别加上128得到机内码 区位码的区和位分别加上160得到机内码 区位码加上A0A0H = 机内码 示例: 我 我的区位码是4650 区位码 46 ...