我们虽然获得了Bean的描述信息BeanDefinition,但是什么时候才会真正的实例化这些Bean呢。其实一共有两个触发点,但是最后实际上调用的是同一个方法。

第一个:在AbstractApplicationContext的refresh()方法中,容器会初始化lazy-init=false的bean。

  1. // Instantiate all remaining (non-lazy-init) singletons.
  2. finishBeanFactoryInitialization(beanFactory);

第二个:在获得了ApplicationContext后,调用getBean(XX)方法。

实际上它们最终都是调用的AbstractBeanFactory的doGetBean(XX)方法。

  1. /**
  2. * Return an instance, which may be shared or independent, of the specified bean.
  3. * @param name the name of the bean to retrieve
  4. * @param requiredType the required type of the bean to retrieve
  5. * @param args arguments to use if creating a prototype using explicit arguments to a
  6. * static factory method. It is invalid to use a non-null args value in any other case.
  7. * @param typeCheckOnly whether the instance is obtained for a type check,
  8. * not for actual use
  9. * @return an instance of the bean
  10. * @throws BeansException if the bean could not be created
  11. */
  12. @SuppressWarnings("unchecked")
  13. protected <T> T doGetBean(
  14. final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
  15. throws BeansException {
  16. //如果name已&开头,去掉&
  17. final String beanName = transformedBeanName(name);
  18. Object bean;
  19.  
  20. // Eagerly check singleton cache for manually registered singletons.
  21. /**1.先在单例缓存中查找*/
  22. Object sharedInstance = getSingleton(beanName);
  23. if (sharedInstance != null && args == null) {
  24. if (logger.isDebugEnabled()) {
  25. if (isSingletonCurrentlyInCreation(beanName)) {
  26. logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
  27. "' that is not fully initialized yet - a consequence of a circular reference");
  28. }
  29. else {
  30. logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
  31. }
  32. }
  33. /**2.判断返回instance本身还是要返回FacotryBean*/
  34. bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  35. }
  36.  
  37. else {
  38. // Fail if we're already creating this bean instance:
  39. // We're assumably within a circular reference.
  40. //判断是否不是循环引用
  41. if (isPrototypeCurrentlyInCreation(beanName)) {
  42. throw new BeanCurrentlyInCreationException(beanName);
  43. }
  44.  
  45. // Check if bean definition exists in this factory.
  46. BeanFactory parentBeanFactory = getParentBeanFactory();
  47. if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  48. // Not found -> check parent.
  49. String nameToLookup = originalBeanName(name);
  50. if (args != null) {
  51. // Delegation to parent with explicit args.
  52. return (T) parentBeanFactory.getBean(nameToLookup, args);
  53. }
  54. else {
  55. // No args -> delegate to standard getBean method.
  56. return parentBeanFactory.getBean(nameToLookup, requiredType);
  57. }
  58. }
  59. //标记bean已被创建
  60. if (!typeCheckOnly) {
  61. markBeanAsCreated(beanName);
  62. }
  63.  
  64. try {
  65. final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  66. checkMergedBeanDefinition(mbd, beanName, args);
  67.  
  68. // Guarantee initialization of beans that the current bean depends on.
  69. /**3.如果bean依赖于其他bean先初始化,先初始化依赖的bean*/
  70. String[] dependsOn = mbd.getDependsOn();
  71. if (dependsOn != null) {
  72. for (String dependsOnBean : dependsOn) {
  73. getBean(dependsOnBean);
  74. /**4.记录两个bean相互依赖关系,被依赖的bean在销毁前,要先要销毁依赖它的bean*/
  75. registerDependentBean(dependsOnBean, beanName);
  76. }
  77. }
  78.  
  79. // Create bean instance.
  80. /**
  81. * 5.创建单例bean,scope="singleton"
  82. */
  83. if (mbd.isSingleton()) {
  84. sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
  85. public Object getObject() throws BeansException {
  86. try {
  87. return createBean(beanName, mbd, args);
  88. }
  89. catch (BeansException ex) {
  90. // Explicitly remove instance from singleton cache: It might have been put there
  91. // eagerly by the creation process, to allow for circular reference resolution.
  92. // Also remove any beans that received a temporary reference to the bean.
  93. destroySingleton(beanName);
  94. throw ex;
  95. }
  96. }
  97. });
  98. bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  99. }
  100. /**
  101. * 6.创建原型bean,scope="prototype"
  102. */
  103. else if (mbd.isPrototype()) {
  104. // It's a prototype -> create a new instance.
  105. Object prototypeInstance = null;
  106. try {
  107. beforePrototypeCreation(beanName);
  108. prototypeInstance = createBean(beanName, mbd, args);
  109. }
  110. finally {
  111. afterPrototypeCreation(beanName);
  112. }
  113. bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  114. }
  115. /**
  116. * 7. scope=request/session/globalSession
  117. */
  118. else {
  119. String scopeName = mbd.getScope();
  120. final Scope scope = this.scopes.get(scopeName);
  121. if (scope == null) {
  122. throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
  123. }
  124. try {
  125. Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
  126. public Object getObject() throws BeansException {
  127. beforePrototypeCreation(beanName);
  128. try {
  129. return createBean(beanName, mbd, args);
  130. }
  131. finally {
  132. afterPrototypeCreation(beanName);
  133. }
  134. }
  135. });
  136. bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  137. }
  138. catch (IllegalStateException ex) {
  139. throw new BeanCreationException(beanName,
  140. "Scope '" + scopeName + "' is not active for the current thread; " +
  141. "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  142. ex);
  143. }
  144. }
  145. }
  146. catch (BeansException ex) {
  147. cleanupAfterBeanCreationFailure(beanName);
  148. throw ex;
  149. }
  150. }
  151.  
  152. // Check if required type matches the type of the actual bean instance.
  153. if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
  154. try {
  155. return getTypeConverter().convertIfNecessary(bean, requiredType);
  156. }
  157. catch (TypeMismatchException ex) {
  158. if (logger.isDebugEnabled()) {
  159. logger.debug("Failed to convert bean '" + name + "' to required type [" +
  160. ClassUtils.getQualifiedName(requiredType) + "]", ex);
  161. }
  162. throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  163. }
  164. }
  165. return (T) bean;
  166. }

AbstractAutowireCapableBeanFactory的createBean方法:

  1. @Override
  2. protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
  3. throws BeanCreationException {
  4.  
  5. if (logger.isDebugEnabled()) {
  6. logger.debug("Creating instance of bean '" + beanName + "'");
  7. }
  8. // Make sure bean class is actually resolved at this point.
  9. /**1.解析Bean的Class*/
  10. resolveBeanClass(mbd, beanName);
  11.  
  12. // Prepare method overrides.
  13. try {
  14. /**2.方法注入准备*/
  15. mbd.prepareMethodOverrides();
  16. }
  17. catch (BeanDefinitionValidationException ex) {
  18. throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
  19. beanName, "Validation of method overrides failed", ex);
  20. }
  21.  
  22. try {
  23. // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  24. /**3.BeanPostProcesser第一个扩展点,可以返回一个代理类*/
  25. Object bean = resolveBeforeInstantiation(beanName, mbd);
  26. if (bean != null) {
  27. return bean;
  28. }
  29. }
  30. catch (Throwable ex) {
  31. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  32. "BeanPostProcessor before instantiation of bean failed", ex);
  33. }
  34. /**4.执行spring创建bena实例的流程*/
  35. Object beanInstance = doCreateBean(beanName, mbd, args);
  36. if (logger.isDebugEnabled()) {
  37. logger.debug("Finished creating instance of bean '" + beanName + "'");
  38. }
  39. return beanInstance;
  40. }

第4步才是真正创建实例和初始化的主要方法:

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
  2. // Instantiate the bean.
  3.  
  4. BeanWrapper instanceWrapper = null;
  5. if (mbd.isSingleton()) {
  6. instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  7. }
  8. if (instanceWrapper == null) {
  9. /**5.创建bean实例*/
  10. instanceWrapper = createBeanInstance(beanName, mbd, args);
  11. }
  12. final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
  13. Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
  14.  
  15. // Allow post-processors to modify the merged bean definition.
  16. /**
  17. * 6.MergedBeanDefinitionPostProcessor合并父子类属性,例如:List属性
  18. */
  19. synchronized (mbd.postProcessingLock) {
  20. if (!mbd.postProcessed) {
  21. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  22. mbd.postProcessed = true;
  23. }
  24. }
  25.  
  26. // Eagerly cache singletons to be able to resolve circular references
  27. // even when triggered by lifecycle interfaces like BeanFactoryAware.
  28. /**
  29. * 7.及早暴露单例bean引用,解决循环引用
  30. */
  31. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  32. isSingletonCurrentlyInCreation(beanName));
  33. if (earlySingletonExposure) {
  34. if (logger.isDebugEnabled()) {
  35. logger.debug("Eagerly caching bean '" + beanName +
  36. "' to allow for resolving potential circular references");
  37. }
  38. //创建匿名内部类,匿名内部类会讲beanName、mbd,bean(final修饰)拷贝一份到内部类,已保证当前方法执行完成后局部变量退栈后内部类还可以访问。
  39. addSingletonFactory(beanName, new ObjectFactory<Object>() {
  40. public Object getObject() throws BeansException {
  41. return getEarlyBeanReference(beanName, mbd, bean);
  42. }
  43. });
  44. }
  45.  
  46. // Initialize the bean instance.
  47. Object exposedObject = bean;
  48. try {
  49. /**
  50. * 8.依赖注入
  51. */
  52. populateBean(beanName, mbd, instanceWrapper);
  53. if (exposedObject != null) {
  54. /**
  55. * 9.执行自定义BeanProcesser和init-method
  56. */
  57. exposedObject = initializeBean(beanName, exposedObject, mbd);
  58. }
  59. }
  60. catch (Throwable ex) {
  61. if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  62. throw (BeanCreationException) ex;
  63. }
  64. else {
  65. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  66. }
  67. }
  68.  
  69. if (earlySingletonExposure) {
  70. Object earlySingletonReference = getSingleton(beanName, false);
  71. if (earlySingletonReference != null) {
  72. if (exposedObject == bean) {
  73. exposedObject = earlySingletonReference;
  74. }
  75. else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  76. String[] dependentBeans = getDependentBeans(beanName);
  77. Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
  78. for (String dependentBean : dependentBeans) {
  79. if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  80. actualDependentBeans.add(dependentBean);
  81. }
  82. }
  83. if (!actualDependentBeans.isEmpty()) {
  84. throw new BeanCurrentlyInCreationException(beanName,
  85. "Bean with name '" + beanName + "' has been injected into other beans [" +
  86. StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  87. "] in its raw version as part of a circular reference, but has eventually been " +
  88. "wrapped. This means that said other beans do not use the final version of the " +
  89. "bean. This is often the result of over-eager type matching - consider using " +
  90. "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
  91. }
  92. }
  93. }
  94. }
  95.  
  96. // Register bean as disposable.
  97. try {
  98. /**
  99. * 10.注册DestructionAwareBeanPostProcessors和destroy-method
  100. */
  101. registerDisposableBeanIfNecessary(beanName, bean, mbd);
  102. }
  103. catch (BeanDefinitionValidationException ex) {
  104. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  105. }
  106.  
  107. return exposedObject;
  108. }

第5步:实例化Bean对象,封装成BeanWrapper

  1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
  2. // Make sure bean class is actually resolved at this point.
  3. Class<?> beanClass = resolveBeanClass(mbd, beanName);
  4.  
  5. if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  6. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  7. "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
  8. }
  9. /**5.1 通过静态方法来实例化bean*/
  10. if (mbd.getFactoryMethodName() != null) {
  11. return instantiateUsingFactoryMethod(beanName, mbd, args);
  12. }
  13.  
  14. // Shortcut when re-creating the same bean...
  15. boolean resolved = false;
  16. boolean autowireNecessary = false;
  17. if (args == null) {
  18. synchronized (mbd.constructorArgumentLock) {
  19. if (mbd.resolvedConstructorOrFactoryMethod != null) {
  20. resolved = true;
  21. autowireNecessary = mbd.constructorArgumentsResolved;
  22. }
  23. }
  24. }
  25. /**5.2 暂时不知道什么时候会走这???????*/
  26. if (resolved) {
  27. if (autowireNecessary) {
  28. return autowireConstructor(beanName, mbd, null, null);
  29. }
  30. else {
  31. return instantiateBean(beanName, mbd);
  32. }
  33. }
  34.  
  35. // Need to determine the constructor...
  36. /**5.3 BeanPostProcessor的又一个扩展点:SmartInstantiationAwareBeanPostProcessor。
  37. * 检测Bean的构造器,可以检测出多个候选构造器,再有相应的策略决定使用哪一个,
  38. * 如AutowiredAnnotationBeanPostProcessor实现将自动扫描通过@Autowired/@Va
  39. */
  40. Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  41. /**5.4 通过构造器实例化bean,包括autowire=constructor 和<constructor-arg></constructor-arg>*/
  42. if (ctors != null ||
  43. mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
  44. mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  45. return autowireConstructor(beanName, mbd, ctors, args);
  46. }
  47.  
  48. // No special handling: simply use no-arg constructor.
  49. /**5.5 通过无参构造器实例化bean*/
  50. return instantiateBean(beanName, mbd);
  51. }

第8步:Bean实例的初始化也就是属性的注入

  1. /**
  2. * Populate the bean instance in the given BeanWrapper with the property values
  3. * from the bean definition.
  4. * @param beanName the name of the bean
  5. * @param mbd the bean definition for the bean
  6. * @param bw BeanWrapper with bean instance
  7. */
  8. protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
  9. PropertyValues pvs = mbd.getPropertyValues();
  10.  
  11. if (bw == null) {
  12. if (!pvs.isEmpty()) {
  13. throw new BeanCreationException(
  14. mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
  15. }
  16. else {
  17. // Skip property population phase for null instance.
  18. return;
  19. }
  20. }
  21.  
  22. // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
  23. // state of the bean before properties are set. This can be used, for example,
  24. // to support styles of field injection.
  25. boolean continueWithPropertyPopulation = true;
  26. /**
  27. * 扩展点3:通过InstantiationAwareBeanPostProcessor给属性赋值
  28. */
  29. if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  30. for (BeanPostProcessor bp : getBeanPostProcessors()) {
  31. if (bp instanceof InstantiationAwareBeanPostProcessor) {
  32. InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  33. if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
  34. continueWithPropertyPopulation = false;
  35. break;
  36. }
  37. }
  38. }
  39. }
  40.  
  41. if (!continueWithPropertyPopulation) {
  42. return;
  43. }
  44.  
  45. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
  46. mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
  47. MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  48.  
  49. // Add property values based on autowire by name if applicable.
  50. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
  51. //根据Name自动装配
  52. autowireByName(beanName, mbd, bw, newPvs);
  53. }
  54.  
  55. // Add property values based on autowire by type if applicable.
  56. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
  57. //根据Type自动装配
  58. autowireByType(beanName, mbd, bw, newPvs);
  59. }
  60.  
  61. pvs = newPvs;
  62. }
  63.  
  64. boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
  65. boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
  66.  
  67. if (hasInstAwareBpps || needsDepCheck) {
  68. PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  69. if (hasInstAwareBpps) {
  70. /**
  71. * InstantiationAwareBeanPostProcesser在属性注入之前的扩展点
  72. */
  73. for (BeanPostProcessor bp : getBeanPostProcessors()) {
  74. if (bp instanceof InstantiationAwareBeanPostProcessor) {
  75. InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  76. pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
  77. if (pvs == null) {
  78. return;
  79. }
  80. }
  81. }
  82. }
  83. /**是否需要依赖检查*/
  84. if (needsDepCheck) {
  85. checkDependencies(beanName, mbd, filteredPds, pvs);
  86. }
  87. }
  88. /**属性注入*/
  89. applyPropertyValues(beanName, mbd, bw, pvs);
  90. }

最终是通过java反射调用set方法的invoke实现的属性注入。BeanWrapperImpl setPropertyValue方法

  1. //省略..... if (System.getSecurityManager() != null) {
  2. try {
  3. AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
  4. public Object run() throws Exception {
  5. writeMethod.invoke(object, value);
  6. return null;
  7. }
  8. }, acc);
  9. }
  10. catch (PrivilegedActionException ex) {
  11. throw ex.getException();
  12. }
  13. }
  14. else {
  15. writeMethod.invoke(this.object, value);
  16. }
  17. }
  1.          //省略.....

到此,bean的实例化和属性注入已经完成。但是Bean实例的初始化工作还没完成,还有一系列的初始化工作。

第9步:初始化Bean实例

  1. protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
  2. if (System.getSecurityManager() != null) {
  3. AccessController.doPrivileged(new PrivilegedAction<Object>() {
  4. public Object run() {
  5. invokeAwareMethods(beanName, bean);
  6. return null;
  7. }
  8. }, getAccessControlContext());
  9. }
  10. else {
  11. /**1.为实现Aware接口的bean设置一些相应的资源**/
  12. invokeAwareMethods(beanName, bean);
  13. }
  14.  
  15. Object wrappedBean = bean;
  16. if (mbd == null || !mbd.isSynthetic()) {
  17. /**2.调用BeanPostProcesser postProcessBeforeInitialization方法*/
  18. wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  19. }
  20.  
  21. try {
  22. /**3.调用InitializingBean的afterPropertiesSet方法
  23. * 调用自定义init-method
  24. */
  25. invokeInitMethods(beanName, wrappedBean, mbd);
  26. }
  27. catch (Throwable ex) {
  28. throw new BeanCreationException(
  29. (mbd != null ? mbd.getResourceDescription() : null),
  30. beanName, "Invocation of init method failed", ex);
  31. }
  32.  
  33. if (mbd == null || !mbd.isSynthetic()) {
  34. /**
  35. * 4.调用BeanPostProcesser postProcessAfterInitialization方法
  36. */
  37. wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  38. }
  39. return wrappedBean;
  40. }

第10步:注册DisposableBean

  1. protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
  2. AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
  3. if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
  4. //单例
  5. if (mbd.isSingleton()) {
  6. // Register a DisposableBean implementation that performs all destruction
  7. // work for the given bean: DestructionAwareBeanPostProcessors,
  8. // DisposableBean interface, custom destroy method.
  9. registerDisposableBean(beanName,
  10. new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
  11. }
  12. else {
  13. // A bean with a custom scope...
  14. Scope scope = this.scopes.get(mbd.getScope());
  15. if (scope == null) {
  16. throw new IllegalStateException("No Scope registered for scope '" + mbd.getScope() + "'");
  17. }
  18. scope.registerDestructionCallback(beanName,
  19. new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
  20. }
  21. }
  22. }
  1. public void registerDisposableBean(String beanName, DisposableBean bean) {
  2. synchronized (this.disposableBeans) {
  3. this.disposableBeans.put(beanName, bean);
  4. }
  5. }
  6.  
  7. public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
  8. List<BeanPostProcessor> postProcessors, AccessControlContext acc) {
  9.  
  10. Assert.notNull(bean, "Disposable bean must not be null");
  11. this.bean = bean;
  12. this.beanName = beanName;
  13. this.invokeDisposableBean =
  14. (this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy"));
  15. this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
  16. this.acc = acc;
  17. String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
  18. if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
  19. !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
  20. this.destroyMethodName = destroyMethodName;
  21. this.destroyMethod = determineDestroyMethod();
  22. if (this.destroyMethod == null) {
  23. if (beanDefinition.isEnforceDestroyMethod()) {
  24. throw new BeanDefinitionValidationException("Couldn't find a destroy method named '" +
  25. destroyMethodName + "' on bean with name '" + beanName + "'");
  26. }
  27. }
  28. else {
  29. Class<?>[] paramTypes = this.destroyMethod.getParameterTypes();
  30. if (paramTypes.length > 1) {
  31. throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
  32. beanName + "' has more than one parameter - not supported as destroy method");
  33. }
  34. else if (paramTypes.length == 1 && !paramTypes[0].equals(boolean.class)) {
  35. throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
  36. beanName + "' has a non-boolean parameter - not supported as destroy method");
  37. }
  38. }
  39. }
  40. this.beanPostProcessors = filterPostProcessors(postProcessors);
  41. }

到此,Spring Bean的实例化和初始化工作就完成了。

总结一下Bean的实例创建和初始化过程,也就是Bean的生命周期:

Spring源码解析(四)Bean的实例化和依赖注入的更多相关文章

  1. Spring源码解析三:IOC容器的依赖注入

    一般情况下,依赖注入的过程是发生在用户第一次向容器索要Bean是触发的,而触发依赖注入的地方就是BeanFactory的getBean方法. 这里以DefaultListableBeanFactory ...

  2. Spring源码解析——循环依赖的解决方案

    一.前言 承接<Spring源码解析--创建bean>.<Spring源码解析--创建bean的实例>,我们今天接着聊聊,循环依赖的解决方案,即创建bean的ObjectFac ...

  3. Spring源码-IOC部分-Bean实例化过程【5】

    实验环境:spring-framework-5.0.2.jdk8.gradle4.3.1 Spring源码-IOC部分-容器简介[1] Spring源码-IOC部分-容器初始化过程[2] Spring ...

  4. Spring源码解析之八finishBeanFactoryInitialization方法即初始化单例bean

    Spring源码解析之八finishBeanFactoryInitialization方法即初始化单例bean 七千字长文深刻解读,Spirng中是如何初始化单例bean的,和面试中最常问的Sprin ...

  5. Spring 源码分析之 bean 依赖注入原理(注入属性)

         最近在研究Spring bean 生命周期相关知识点以及源码,所以打算写一篇 Spring bean生命周期相关的文章,但是整理过程中发现涉及的点太多而且又很复杂,很难在一篇文章中把Spri ...

  6. Spring源码解析 - AbstractBeanFactory 实现接口与父类分析

    我们先来看类图吧: 除了BeanFactory这一支的接口,AbstractBeanFactory主要实现了AliasRegistry和SingletonBeanRegistry接口. 这边主要提供了 ...

  7. Spring源码分析之Bean的创建过程详解

    前文传送门: Spring源码分析之预启动流程 Spring源码分析之BeanFactory体系结构 Spring源码分析之BeanFactoryPostProcessor调用过程详解 本文内容: 在 ...

  8. spring 源码解析

    1. [文件] spring源码.txt ~ 15B     下载(167) ? 1 springн┤┬вио╬Ш: 2. [文件] spring源码分析之AOP.txt ~ 15KB     下载( ...

  9. Mybatis源码解析(四) —— SqlSession是如何实现数据库操作的?

    Mybatis源码解析(四) -- SqlSession是如何实现数据库操作的?   如果拿一次数据库请求操作做比喻,那么前面3篇文章就是在做请求准备,真正执行操作的是本篇文章要讲述的内容.正如标题一 ...

  10. Spring源码解析之BeanFactoryPostProcessor(三)

    在上一章中笔者介绍了refresh()的<1>处是如何获取beanFactory对象,下面我们要来学习refresh()方法的<2>处是如何调用invokeBeanFactor ...

随机推荐

  1. Unity UI大小动态设置(Resize Unity UI RectTransform)

    我们在开发过程中发现,要调整Unity UI元素的大小,RectTransform提供了sizeDelta属性可以用来动态修改RectTransform的大小,但同时我们也google到另外一个修改R ...

  2. 【java】java 设计模式(4):建造者模式(Builder)

    工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,所谓复合对象就是指某个类具有不同的属性,其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到 ...

  3. java socket通信-传输文件图片--传输图片

    ClientTcpSend.java   client发送类 package com.yjf.test; import java.io.DataOutputStream; import java.io ...

  4. 京东云擎”本周四推出一键免费安装Discuz论坛

    “京东云擎”本周四推出一键免费安装Discuz论坛了,让用户能在1分钟之内建立自己的论坛.这是继上周云擎推出一键安装WordPress之后的又一重大免费贡献! 云擎: http://jae.jd.co ...

  5. Android DOM解析XML示例程序

    DOM方式解析xml是先把xml文档都读到内存中,然后再用DOM API来访问树形结构,并获取数据的.DOM比较符合人的思维模式,但是其对内存的消耗比较大. activity_main.xml < ...

  6. 编写一个读写倾斜测量数据.s3c文件格式的OSG插件osgdb_s3c

    VS新建一个空的DLL工程 ReaderWriterS3C.cpp源文件 #include <osg/Notify> #include <osgDB/FileNameUtils> ...

  7. 你知道嵌入式C语言中各变量存储的位置吗?

    局部变量.局部静态变量.全局变量.全局静态变量区别如下: 局部变量: 栈区: 局部静态变量:静态区: 全局变量: 静态区的常量区: 全局静态变量:静态区. 在进行C/C++编程时,需要程序员对内存的了 ...

  8. 使用fetch-jsonp进行跨域以及参数的传递

    其实fetch-jsonp的官方文档里面已经写得很详细了,连接如下:https://github.com/camsong/fetch-jsonp:但是由于它本身没有多少demo,所以自己在上手的时候遇 ...

  9. django实现瀑布流、组合搜索、阶梯评论、验证码

    django实现图片瀑布流布局 我们在一些图片网站上经常会看到,满屏都是图片,而且图片都大小不一,却可以按空间排列.默认一个div是占用一行,当想把div里的图片并排显示的时候,只能使用float属性 ...

  10. poj_2774 后缀数组

    题目大意 给定两个字符串A,B,求出A和B中最长公共子串的长度. 题目分析 字符串的子串可以认为是是字符串的某个后缀的前缀,而求最长公共子串相当于A和B的某两个后缀的最长相同前缀.可以考虑使用后缀数组 ...