实例化方式

BeanPostProcessor

在createBean中，判断BeanFactory中是否包含InstantiationAwareBeanPostProcessor，若包含，直接由该处理器拦截并返回Bean。此处可以用于手动设置AOP的情况。

FactoryMethod

在createBeanInstance中，判断BeanDefinition中是否包含FactoryMethod，若包含，由该FactoryMethod处理并返回Bean。拥有全生命周期，常见的用法为@Bean注解。

以XML配置为例：

• 静态工厂方法

<bean id="apple" class="com.xxx.factorymethod.FruitStaticFactory" factory-method="getFruit">
    <constructor-arg value="apple"/>
</bean>

public class FruitStaticFactory {
    public static Fruit getFruit(String fruitName) {
    if ("apple".equals(fruitName)) {
        return new Apple();
    }
        return null;
    }
}

public interface Fruit{}

public class Apple implement Fruit{}

• 实例工厂方法

<bean id="apple" class="com.xxx.factorymethod.Apple" factory-method="getFruit" factory-bean="fruitFactory">
    <constructor-arg value="apple"/>
</bean>

<bean id="fruitFactory" class="com.xxx.factorymethod.FruitInstanceFactory" />

public class FruitInstanceFactory {
    public Fruit getFruit(String fruitName) {
        if ("apple".equals(fruitName)) {
            return new Apple();
        }
        return null;
    }
}

public interface Fruit{}

public class Apple implement Fruit{}

反射

Spring的通用Bean创建流程，拥有完整的生命周期。

实例化流程

源码分析

BeanPostProcessor

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
   ...

   // Prepare method overrides.
   // 预处理 method overrides
   try {
      mbdToUse.prepareMethodOverrides();
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
   }

   // 判断是否有InstantiationAwareBeanPostProcessor
   // 如果有，尝试走InstantiationAwareBeanPostProcessor代理生成Bean
   try {
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
         return bean;
      }
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
            "BeanPostProcessor before instantiation of bean failed", ex);
   }

   // 正常流程，Bean的创建生命周期都在doCreateBean方法中
   Object beanInstance = doCreateBean(beanName, mbdToUse, args);
   if (logger.isDebugEnabled()) {
      logger.debug("Finished creating instance of bean '" + beanName + "'");
   }
   return beanInstance;
}

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
   Object bean = null;
   if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
      // Make sure bean class is actually resolved at this point.
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         Class<?> targetType = determineTargetType(beanName, mbd);
         if (targetType != null) {
            // 执行BPP的BeforeInstantiation方法，可以返回bean
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
            if (bean != null) {
               // 执行BPP的AfterInitialization方法，可以加工并代理bean
               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
         }
      }
      mbd.beforeInstantiationResolved = (bean != null);
   }
   return bean;
}

FactoryMethod

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
      throws BeanCreationException {

   // Instantiate the bean.
BeanWrapper instanceWrapper = null;
   // 如果该bean为单例的，且在FactoryBean缓存中存在(被FactoryBean创建过)，则直接取到
   if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   // 如果上述步骤取不到，则实例化Bean
   if (instanceWrapper == null) {
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }

   ...
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
   ...

   // 如果bd中定义了FactoryMethod，则使用该方法返回
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // 正常实例化逻辑
   ...
}

public BeanWrapper instantiateUsingFactoryMethod(
      final String beanName, final RootBeanDefinition mbd, final Object[] explicitArgs) {

   ...

   // bean的工厂类
   Object factoryBean;
   // 工厂的class类型
   Class<?> factoryClass;
   // 工厂方法是不是静态的
   boolean isStatic;

   String factoryBeanName = mbd.getFactoryBeanName();
   // 如果factoryBeanName非空，证明是实例工厂
   if (factoryBeanName != null) {
      if (factoryBeanName.equals(beanName)) {
         throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
               "factory-bean reference points back to the same bean definition");
      }
      // 获取工厂实例
      factoryBean = this.beanFactory.getBean(factoryBeanName);
      if (factoryBean == null) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "factory-bean '" + factoryBeanName + "' (or a BeanPostProcessor involved) returned null");
      }
      if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
         throw new IllegalStateException("About-to-be-created singleton instance implicitly appeared " +
               "through the creation of the factory bean that its bean definition points to");
      }
      factoryClass = factoryBean.getClass();
      // 非静态的
      isStatic = false;
   }
   // 否则，就是静态工厂
   else {
      // It's a static factory method on the bean class.
if (!mbd.hasBeanClass()) {
         throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
               "bean definition declares neither a bean class nor a factory-bean reference");
      }
      // 静态工厂，factoryBean为空
      factoryBean = null;
      factoryClass = mbd.getBeanClass();
      isStatic = true;
   }

   // 需要使用的工厂方法
   Method factoryMethodToUse = null;
   ArgumentsHolder argsHolderToUse = null;
   Object[] argsToUse = null;

   ...

   if (factoryMethodToUse == null || argsToUse == null) {
      // Need to determine the factory method...
// Try all methods with this name to see if they match the given arguments.
factoryClass = ClassUtils.getUserClass(factoryClass);

      // 获取工厂类的所有方法
      Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
      List<Method> candidateSet = new ArrayList<Method>();
      // 提取工厂类的FactoryMethod
      for (Method candidate : rawCandidates) {
         if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
            candidateSet.add(candidate);
         }
      }
      Method[] candidates = candidateSet.toArray(new Method[candidateSet.size()]);
      // 根据是否public、方法参数数量从多到少排序
      AutowireUtils.sortFactoryMethods(candidates);

      ConstructorArgumentValues resolvedValues = null;
      boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
      int minTypeDiffWeight = Integer.MAX_VALUE;
      Set<Method> ambiguousFactoryMethods = null;

      // 最小的参数数量
      int minNrOfArgs;
      // 如果方法传入了参数，以传入的为准
      if (explicitArgs != null) {
         minNrOfArgs = explicitArgs.length;
      }
      // 否则，使用mbd中的信息
      else {
         // We don't have arguments passed in programmatically, so we need to resolve the
// arguments specified in the constructor arguments held in the bean definition.
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
         resolvedValues = new ConstructorArgumentValues();
         // 推断参数可能的类型
         minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
      }

      LinkedList<UnsatisfiedDependencyException> causes = null;

      // 遍历方法，获取最优的方法
      // 用于处理方法重载
      for (Method candidate : candidates) {
         Class<?>[] paramTypes = candidate.getParameterTypes();
         // 如果方法参数大于要求的参数数量，说明有可能是目标工厂方法
         // 只考虑paramTypes.length >= minNrOfArgs的情况
         if (paramTypes.length >= minNrOfArgs) {
            ArgumentsHolder argsHolder;

            if (resolvedValues != null) {
               // Resolved constructor arguments: type conversion and/or autowiring necessary.
try {
                  String[] paramNames = null;
                  ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                  if (pnd != null) {
                     paramNames = pnd.getParameterNames(candidate);
                  }
                  // 创建该种方法对应的参数值
                  // 如果参数类型存在冲突，抛出UnsatisfiedDependencyException异常
                  argsHolder = createArgumentArray(
                        beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
               }
               catch (UnsatisfiedDependencyException ex) {
                  if (this.beanFactory.logger.isTraceEnabled()) {
                     this.beanFactory.logger.trace("Ignoring factory method [" + candidate +
                           "] of bean '" + beanName + "': " + ex);
                  }
                  // Swallow and try next overloaded factory method.
if (causes == null) {
                     causes = new LinkedList<UnsatisfiedDependencyException>();
                  }
                  causes.add(ex);
                  continue;
               }
            }

            else {
               // Explicit arguments given -> arguments length must match exactly.
if (paramTypes.length != explicitArgs.length) {
                  continue;
               }
               argsHolder = new ArgumentsHolder(explicitArgs);
            }

            // 为每种方法计算一个差异值
            int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                  argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
            // Choose this factory method if it represents the closest match.
// 记录循环中差异值最小的方法
            if (typeDiffWeight < minTypeDiffWeight) {
               factoryMethodToUse = candidate;
               argsHolderToUse = argsHolder;
               argsToUse = argsHolder.arguments;
               minTypeDiffWeight = typeDiffWeight;
               ambiguousFactoryMethods = null;
            }
            // Find out about ambiguity: In case of the same type difference weight
// for methods with the same number of parameters, collect such candidates
// and eventually raise an ambiguity exception.
// However, only perform that check in non-lenient constructor resolution mode,
// and explicitly ignore overridden methods (with the same parameter signature).
// 如果存在两个方法差异值相等，且与传参数量相等，同时记录
            // 这种case在后面抛出异常
            else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
                  !mbd.isLenientConstructorResolution() &&
                  paramTypes.length == factoryMethodToUse.getParameterTypes().length &&
                  !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
               if (ambiguousFactoryMethods == null) {
                  ambiguousFactoryMethods = new LinkedHashSet<Method>();
                  ambiguousFactoryMethods.add(factoryMethodToUse);
               }
               ambiguousFactoryMethods.add(candidate);
            }
         }
      }

      // 找不到目标方法，抛异常
      if (factoryMethodToUse == null) {
         ...
      }
      // 目标方法返回值为null，抛异常
      else if (void.class == factoryMethodToUse.getReturnType()) {
         ...
      }
      // 有多个目标方法，抛异常
      else if (ambiguousFactoryMethods != null) {
         ...
      }

      // 把解析出的构造器存入缓存，方便下次使用(原型Bean)
      if (explicitArgs == null && argsHolderToUse != null) {
         argsHolderToUse.storeCache(mbd, factoryMethodToUse);
      }
   }

   try {
      Object beanInstance;

      if (System.getSecurityManager() != null) {
         ...
      }
      else {
         // 使用invoke()对方法执行反射
         beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
               mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);
      }

      if (beanInstance == null) {
         return null;
      }
      // 把FactoryMethod生成的对象放入BeanWrapper中
      bw.setBeanInstance(beanInstance);
      return bw;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Bean instantiation via factory method failed", ex);
   }
}

反射

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
   ...

   // FactoryMethod
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // Shortcut when re-creating the same bean...
   // 反射
boolean resolved = false;
   boolean autowireNecessary = false;
   // 缓存
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true;
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }
   if (resolved) {
      if (autowireNecessary) {
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
         return instantiateBean(beanName, mbd);
      }
   }

   // Candidate constructors for autowiring?
   // 根据BeanPostProcessors决定使用什么构造器
   // 主要用来处理Autowired
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   // 这里判断，前一步Autowired结果，
   // xml是否有constructor-arg，
   // 是否显式传入了args
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      // 调用有参构造器
      // 逻辑类似FactoryMethod中的instantiateUsingFactoryMethod
      // 使用差异值来确定最终使用的构造器
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   // No special handling: simply use no-arg constructor.
   // 调用无参构造器
return instantiateBean(beanName, mbd);
}

applyMergedBeanDefinitionPostProcessors

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 {
            // 处理@Resource，@Autowired，@PostConstructor注解
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Post-processing of merged bean definition failed", ex);
         }
         mbd.postProcessed = true;
      }
   }

   ...
}

MergedBeanDefinitionPostProcessor：在实例化之后执行，用来处理@Resource，@Autowired，@PostConstructor，@PreDestory等注解，补充Bean的定义

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
   void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
}

以InitDestroyAnnotationBeanPostProcessor为例：

@Override
// 实现了MergedBeanDefinitionPostProcessor
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
   if (beanType != null) {
      // 循环遍历该类及其父类的所有方法，
      // 寻找@PostConstructor，@PreDestory修饰的方法
      LifecycleMetadata metadata = findLifecycleMetadata(beanType);
      // 将上一步找到的方法写入Map中
      metadata.checkConfigMembers(beanDefinition);
   }
}

@Override
// 实现了BeanPostProcessor
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
   LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
   try {
      // 执行init方法
      metadata.invokeInitMethods(bean, beanName);
   }
   catch (InvocationTargetException ex) {
      throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
   }
   catch (Throwable ex) {
      throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
   }
   return bean;
}

@Override
// 实现了DestructionAwareBeanPostProcessor
public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
   LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
   try {
      // 执行销毁方法
      metadata.invokeDestroyMethods(bean, beanName);
   }
   catch (InvocationTargetException ex) {
      String msg = "Invocation of destroy method failed on bean with name '" + beanName + "'";
      if (logger.isDebugEnabled()) {
         logger.warn(msg, ex.getTargetException());
      }
      else {
         logger.warn(msg + ": " + ex.getTargetException());
      }
   }
   catch (Throwable ex) {
      logger.error("Failed to invoke destroy method on bean with name '" + beanName + "'", ex);
   }
}