Spring bean 如何实例化

bean实例化结论：

getBean -> 实例化对象 -> 进行依赖注入 -> 调用 BeanPostProcessor.postProcessBeforeInitialization -> InitializingBean.afterPropertiesSet() -> 自定义init方法 -> BeanPostProcessor.postProcessAfterInitialization

1、核心入口


AbstractApplicationContext#refresh


tips：此时已完成xml、注解中自定义的bean的解析，放在beanDefinitionMap中，还未进行实例化

@Overridepublic void refresh() throws BeansException, IllegalStateException {   synchronized (this.startupShutdownMonitor) {      // Prepare this context for refreshing.      prepareRefresh();      // Tell the subclass to refresh the internal bean factory.      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();      // Prepare the bean factory for use in this context.      prepareBeanFactory(beanFactory);      try {         // Allows post-processing of the bean factory in context subclasses.         postProcessBeanFactory(beanFactory);         // Invoke factory processors registered as beans in the context.         invokeBeanFactoryPostProcessors(beanFactory);         // Register bean processors that intercept bean creation.         registerBeanPostProcessors(beanFactory);         // Initialize message source for this context.         initMessageSource();         // Initialize event multicaster for this context.         initApplicationEventMulticaster();         // Initialize other special beans in specific context subclasses.         onRefresh();         // Check for listener beans and register them.         registerListeners();         // Instantiate all remaining (non-lazy-init) singletons.         finishBeanFactoryInitialization(beanFactory);         // Last step: publish corresponding event.         finishRefresh();      }      catch (BeansException ex) {         if (logger.isWarnEnabled()) {            logger.warn("Exception encountered during context initialization - " +                  "cancelling refresh attempt: " + ex);         }         // Destroy already created singletons to avoid dangling resources.         destroyBeans();         // Reset 'active' flag.         cancelRefresh(ex);         // Propagate exception to caller.         throw ex;      }      finally {         // Reset common introspection caches in Spring's core, since we         // might not ever need metadata for singleton beans anymore...         resetCommonCaches();      }   }}

2、refresh分析


2.1 prepareRefresh();


设置启动标志位


2.2 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

获取beanFactory，beanFactory是在创建ApplicationContext时生成的，GenericApplicationContext构造函数中

/** * Create a new GenericApplicationContext. * @see #registerBeanDefinition * @see #refresh */public GenericApplicationContext() {   this.beanFactory = new DefaultListableBeanFactory();}

2.3 prepareBeanFactory(beanFactory);


设置beanFactory参数，比如beanClassLoader，系统默认的beanPostProcessors等


2.4 postProcessBeanFactory(beanFactory);


如果需要增加、处理BeanPostProcessor，子类可重写此方法


2.5 invokeBeanFactoryPostProcessors(beanFactory);


初始化并调用BeanFactoryPostProcessors,不是Bean的后处理器，是BeanFactory的后处理器


2.6 registerBeanPostProcessors(beanFactory);


捞取所有实现了BeanPostProcessor接口的bean，依次注册到beanFactory，如果实现PriorityOrdered接口的，会放前面并会进行排序，其他的放后面


2.7 initMessageSource();


初始化MessageSource，国际化处理


2.8 initApplicationEventMulticaster();


初始化ApplicationEventMulticaster，用来进行事件广播


2.9 onRefresh();


初始化其他特殊bean，可在子类覆盖此方法


2.10 registerListeners();


注册事件监听器，将实现ApplicationListener的bean，注册到2.8中的ApplicationEventMulticaster


2.11 finishBeanFactoryInitialization(beanFactory);


初始化所有剩下的非lazy-init的singleton bean，真正开始实例化自定义的bean（下面详解）


2.12 finishRefresh();


初始化并调用LifecycleProcessor，获取并调用Lifecycle的beans的start，发送ContextRefreshedEvent事件等


如果使用springBoot的话，此处会启动容器（如tomcat）

@Overrideprotected void finishRefresh() {   super.finishRefresh();   EmbeddedServletContainer localContainer = startEmbeddedServletContainer();   if (localContainer != null) {      publishEvent(            new EmbeddedServletContainerInitializedEvent(this, localContainer));   }}

private EmbeddedServletContainer startEmbeddedServletContainer() {   EmbeddedServletContainer localContainer = this.embeddedServletContainer;   if (localContainer != null) {      localContainer.start();   }   return localContainer;}

3、finishBeanFactoryInitialization(beanFactory) 详解

核心方法是在DefaultListableBeanFactory.preInstantiateSingletons(); 先遍历beanDefinitionNames，只有对非抽象、单例、非懒加载的bean才进行实例化

@Overridepublic void preInstantiateSingletons() throws BeansException {   if (this.logger.isDebugEnabled()) {      this.logger.debug("Pre-instantiating singletons in " + this);   }   // Iterate over a copy to allow for init methods which in turn register new bean definitions.   // While this may not be part of the regular factory bootstrap, it does otherwise work fine.   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);   // Trigger initialization of all non-lazy singleton beans...   for (String beanName : beanNames) {      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {         if (isFactoryBean(beanName)) {            final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);            boolean isEagerInit;            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {               isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {                  @Override                  public Boolean run() {                     return ((SmartFactoryBean<?>) factory).isEagerInit();                  }               }, getAccessControlContext());            }            else {               isEagerInit = (factory instanceof SmartFactoryBean &&                     ((SmartFactoryBean<?>) factory).isEagerInit());            }            if (isEagerInit) {               getBean(beanName);            }         }         else {            getBean(beanName);         }      }   }   // Trigger post-initialization callback for all applicable beans...   for (String beanName : beanNames) {      Object singletonInstance = getSingleton(beanName);      if (singletonInstance instanceof SmartInitializingSingleton) {         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;         if (System.getSecurityManager() != null) {            AccessController.doPrivileged(new PrivilegedAction<Object>() {               @Override               public Object run() {                  smartSingleton.afterSingletonsInstantiated();                  return null;               }            }, getAccessControlContext());         }         else {            smartSingleton.afterSingletonsInstantiated();         }      }   }}

区分factoryBean、普通bean，但真正实例化都是在getBean(beanName)


-> doGetBean(name, null, null, false);

protected <T> T doGetBean(      final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)      throws BeansException {   final String beanName = transformedBeanName(name);   Object bean;   // Eagerly check singleton cache for manually registered singletons.   Object sharedInstance = getSingleton(beanName);   if (sharedInstance != null && args == null) {      if (logger.isDebugEnabled()) {         if (isSingletonCurrentlyInCreation(beanName)) {            logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +                  "' that is not fully initialized yet - a consequence of a circular reference");         }         else {            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");         }      }      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);   }   else {      // Fail if we're already creating this bean instance:      // We're assumably within a circular reference.      if (isPrototypeCurrentlyInCreation(beanName)) {         throw new BeanCurrentlyInCreationException(beanName);      }      // Check if bean definition exists in this factory.      BeanFactory parentBeanFactory = getParentBeanFactory();      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {         // Not found -> check parent.         String nameToLookup = originalBeanName(name);         if (args != null) {            // Delegation to parent with explicit args.            return (T) parentBeanFactory.getBean(nameToLookup, args);         }         else {            // No args -> delegate to standard getBean method.            return parentBeanFactory.getBean(nameToLookup, requiredType);         }      }      if (!typeCheckOnly) {         markBeanAsCreated(beanName);      }      try {         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);         checkMergedBeanDefinition(mbd, beanName, args);         // Guarantee initialization of beans that the current bean depends on.         String[] dependsOn = mbd.getDependsOn();         if (dependsOn != null) {            for (String dep : dependsOn) {               if (isDependent(beanName, dep)) {                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");               }               registerDependentBean(dep, beanName);               getBean(dep);            }         }         // Create bean instance.         if (mbd.isSingleton()) {            sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {               @Override               public Object getObject() throws BeansException {                  try {                     return createBean(beanName, mbd, args);                  }                  catch (BeansException ex) {                     // Explicitly remove instance from singleton cache: It might have been put there                     // eagerly by the creation process, to allow for circular reference resolution.                     // Also remove any beans that received a temporary reference to the bean.                     destroySingleton(beanName);                     throw ex;                  }               }            });            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);         }         else if (mbd.isPrototype()) {            // It's a prototype -> create a new instance.            Object prototypeInstance = null;            try {               beforePrototypeCreation(beanName);               prototypeInstance = createBean(beanName, mbd, args);            }            finally {               afterPrototypeCreation(beanName);            }            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);         }         else {            String scopeName = mbd.getScope();            final Scope scope = this.scopes.get(scopeName);            if (scope == null) {               throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");            }            try {               Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {                  @Override                  public Object getObject() throws BeansException {                     beforePrototypeCreation(beanName);                     try {                        return createBean(beanName, mbd, args);                     }                     finally {                        afterPrototypeCreation(beanName);                     }                  }               });               bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);            }            catch (IllegalStateException ex) {               throw new BeanCreationException(beanName,                     "Scope '" + scopeName + "' is not active for the current thread; consider " +                     "defining a scoped proxy for this bean if you intend to refer to it from a singleton",                     ex);            }         }      }      catch (BeansException ex) {         cleanupAfterBeanCreationFailure(beanName);         throw ex;      }   }   // Check if required type matches the type of the actual bean instance.   if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {      try {         return getTypeConverter().convertIfNecessary(bean, requiredType);      }      catch (TypeMismatchException ex) {         if (logger.isDebugEnabled()) {            logger.debug("Failed to convert bean '" + name + "' to required type '" +                  ClassUtils.getQualifiedName(requiredType) + "'", ex);         }         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());      }   }   return (T) bean;}

a).如果内存中有，则从内存中取

b).如果内存中没有并且当前beanFactory中没有beanName，则判断parentBeanFactory中是否有，如果有，则从parentBeanFactory中取

c).如果当前beanFactory中有beanName，合并parent的BeanDefinition


d).处理dependsOn属性，如果有依赖，调用依赖的beanName的getBean

e).按照Singleton、Prototype等scope属性，创建bean实例

createBean(beanName, mbd, args); 如果是Singleton，需要在线程安全下创建，如果是Prototype则需要创建新的实例

e.1) 创建新的RootBeanDefinition供创建bean使用，处理lookup-method或replace-method，调用实现InstantiationAwareBeanPostProcessor的bean的BeanPostProcessors后处理器


e.2) AbstractAutowireCapableBeanFactory.doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) 创建bean实例

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)      throws BeanCreationException {   // Instantiate the bean.   BeanWrapper instanceWrapper = null;   if (mbd.isSingleton()) {      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);   }   if (instanceWrapper == null) {      instanceWrapper = createBeanInstance(beanName, mbd, args);   }   final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);   Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);   mbd.resolvedTargetType = beanType;   // Allow post-processors to modify the merged bean definition.   synchronized (mbd.postProcessingLock) {      if (!mbd.postProcessed) {         try {            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);         }         catch (Throwable ex) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName,                  "Post-processing of merged bean definition failed", ex);         }         mbd.postProcessed = true;      }   }   // Eagerly cache singletons to be able to resolve circular references   // even when triggered by lifecycle interfaces like BeanFactoryAware.   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&         isSingletonCurrentlyInCreation(beanName));   if (earlySingletonExposure) {      if (logger.isDebugEnabled()) {         logger.debug("Eagerly caching bean '" + beanName +               "' to allow for resolving potential circular references");      }      addSingletonFactory(beanName, new ObjectFactory<Object>() {         @Override         public Object getObject() throws BeansException {            return getEarlyBeanReference(beanName, mbd, bean);         }      });   }   // Initialize the bean instance.   Object exposedObject = bean;   try {      populateBean(beanName, mbd, instanceWrapper);      if (exposedObject != null) {         exposedObject = initializeBean(beanName, exposedObject, mbd);      }   }   catch (Throwable ex) {      if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {         throw (BeanCreationException) ex;      }      else {         throw new BeanCreationException(               mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);      }   }   if (earlySingletonExposure) {      Object earlySingletonReference = getSingleton(beanName, false);      if (earlySingletonReference != null) {         if (exposedObject == bean) {            exposedObject = earlySingletonReference;         }         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {            String[] dependentBeans = getDependentBeans(beanName);            Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);            for (String dependentBean : dependentBeans) {               if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {                  actualDependentBeans.add(dependentBean);               }            }            if (!actualDependentBeans.isEmpty()) {               throw new BeanCurrentlyInCreationException(beanName,                     "Bean with name '" + beanName + "' has been injected into other beans [" +                     StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +                     "] in its raw version as part of a circular reference, but has eventually been " +                     "wrapped. This means that said other beans do not use the final version of the " +                     "bean. This is often the result of over-eager type matching - consider using " +                     "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");            }         }      }   }   // Register bean as disposable.   try {      registerDisposableBeanIfNecessary(beanName, bean, mbd);   }   catch (BeanDefinitionValidationException ex) {      throw new BeanCreationException(            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);   }   return exposedObject;}

e.2.1) instanceWrapper = createBeanInstance(beanName, mbd, args); 反射创建bean实例


e.2.2) 调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition


e.2.3) populateBean(beanName, mbd, instanceWrapper); 完成依赖参数注入，如果依赖的bean还未初始化，则调用getBean初始化，然后注入


e.2.4) initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd);

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {   if (System.getSecurityManager() != null) {      AccessController.doPrivileged(new PrivilegedAction<Object>() {         @Override         public Object run() {            invokeAwareMethods(beanName, bean);            return null;         }      }, getAccessControlContext());   }   else {      invokeAwareMethods(beanName, bean);   }   Object wrappedBean = bean;   if (mbd == null || !mbd.isSynthetic()) {      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);   }   try {      invokeInitMethods(beanName, wrappedBean, mbd);   }   catch (Throwable ex) {      throw new BeanCreationException(            (mbd != null ? mbd.getResourceDescription() : null),            beanName, "Invocation of init method failed", ex);   }   if (mbd == null || !mbd.isSynthetic()) {      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);   }   return wrappedBean;}

e.2.4.1) 调用BeanPostProcessor的postProcessBeforeInitialization


e.2.4.2) invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd) 

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)      throws Throwable {   boolean isInitializingBean = (bean instanceof InitializingBean);   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {      if (logger.isDebugEnabled()) {         logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");      }      if (System.getSecurityManager() != null) {         try {            AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {               @Override               public Object run() throws Exception {                  ((InitializingBean) bean).afterPropertiesSet();                  return null;               }            }, getAccessControlContext());         }         catch (PrivilegedActionException pae) {            throw pae.getException();         }      }      else {         ((InitializingBean) bean).afterPropertiesSet();      }   }   if (mbd != null) {      String initMethodName = mbd.getInitMethodName();      if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&            !mbd.isExternallyManagedInitMethod(initMethodName)) {         invokeCustomInitMethod(beanName, bean, mbd);      }   }}

e.2.4.2.1) 如果该bean实现了InitializingBean接口，调用afterPropertiesSet


e.2.4.2.2) 调用bean的自定义init方法


e.2.4.3) 调用BeanPostProcessor的postProcessAfterInitialization，至此，完成了一个bean的初始化




总结下bean实例化的大致流程：


实例化对象 -> 进行依赖注入 -> 调用 BeanPostProcessor.postProcessBeforeInitialization -> InitializingBean.afterPropertiesSet() -> 自定义init方法 -> BeanPostProcessor.postProcessAfterInitialization