IOC之bean的实例化策略：InstantiationStrategy

public interface InstantiationStrategy {

 /**
  * 默认构造方法
  */
 Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner)
   throws BeansException;

 /**
  * 指定构造方法
  */
 Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
   Constructor<?> ctor, @Nullable Object... args) throws BeansException;

 /**
  * 工厂方法
  */
 Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
   @Nullable Object factoryBean, Method factoryMethod, @Nullable Object... args)
   throws BeansException;

}

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
                          @Nullable Object factoryBean, final Method factoryMethod, @Nullable Object... args) {

  try {
    if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        ReflectionUtils.makeAccessible(factoryMethod);
        return null;
      });
    }
    else {
      ReflectionUtils.makeAccessible(factoryMethod);
    }

    Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
    try {
      currentlyInvokedFactoryMethod.set(factoryMethod);
      Object result = factoryMethod.invoke(factoryBean, args);
      if (result == null) {
        result = new NullBean();
      }
      return result;
    }
    finally {
      if (priorInvokedFactoryMethod != null) {
        currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
      }
      else {
        currentlyInvokedFactoryMethod.remove();
      }
    }
  }
  // 省略 catch
}

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  // Don't override the class with CGLIB if no overrides.
  if (!bd.hasMethodOverrides()) {
    Constructor<?> constructorToUse;
    synchronized (bd.constructorArgumentLock) {
      constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
      if (constructorToUse == null) {
        final Class<?> clazz = bd.getBeanClass();
        if (clazz.isInterface()) {
          throw new BeanInstantiationException(clazz, "Specified class is an interface");
        }
        try {
          if (System.getSecurityManager() != null) {
            constructorToUse = AccessController.doPrivileged(
              (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
          }
          else {
            constructorToUse =   clazz.getDeclaredConstructor();
          }
          bd.resolvedConstructorOrFactoryMethod = constructorToUse;
        }
        catch (Throwable ex) {
          throw new BeanInstantiationException(clazz, "No default constructor found", ex);
        }
      }
    }
    return BeanUtils.instantiateClass(constructorToUse);
  }
  else {
    // Must generate CGLIB subclass.
    return instantiateWithMethodInjection(bd, beanName, owner);
  }
}

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
                          final Constructor<?> ctor, @Nullable Object... args) {

  if (!bd.hasMethodOverrides()) {
    if (System.getSecurityManager() != null) {
      // use own privileged to change accessibility (when security is on)
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        ReflectionUtils.makeAccessible(ctor);
        return null;
      });
    }
    return (args != null ? BeanUtils.instantiateClass(ctor, args) : BeanUtils.instantiateClass(ctor));
  }
  else {
    return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
  }
}

// SimpleInstantiationStrategy
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
}

// CglibSubclassingInstantiationStrategy
@Override
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  return instantiateWithMethodInjection(bd, beanName, owner, null);
}

protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
                                                @Nullable Constructor<?> ctor, @Nullable Object... args) {
  return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
}

public Object instantiate(@Nullable Constructor<?> ctor, @Nullable Object... args) {
  Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
  Object instance;
  if (ctor == null) {
    instance = BeanUtils.instantiateClass(subclass);
  }
  else {
    try {
      Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
      instance = enhancedSubclassConstructor.newInstance(args);
    }
    catch (Exception ex) {
      throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
                                           "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
    }
  }

  //这个地方解决一个bug，bug提交报告https://jira.spring.io/browse/SPR-10785
  // SPR-10785: set callbacks directly on the instance instead of in the
  // enhanced class (via the Enhancer) in order to avoid memory leaks.
  Factory factory = (Factory) instance;
  factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
                                       new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
                                       new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
  return instance;
}

private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
 // cglib里面的用法，对原始class进行增强，并设置callback
 Enhancer enhancer = new Enhancer();
 enhancer.setSuperclass(beanDefinition.getBeanClass());
 enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
 if (this.owner instanceof ConfigurableBeanFactory) {
  ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
  enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
 }
 // 过滤，自定义逻辑来指定调用的callback下标
 enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
 enhancer.setCallbackTypes(CALLBACK_TYPES);
 return enhancer.createClass();
}

enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
enhancer.setCallbackTypes(CALLBACK_TYPES);

public int accept(Method method) {
  MethodOverride methodOverride = getBeanDefinition().getMethodOverrides().getOverride(method);
  if (logger.isTraceEnabled()) {
    logger.trace("Override for '" + method.getName() + "' is [" + methodOverride + "]");
  }
  if (methodOverride == null) {
    return PASSTHROUGH;
  }
  else if (methodOverride instanceof LookupOverride) {
    return LOOKUP_OVERRIDE;
  }
  else if (methodOverride instanceof ReplaceOverride) {
    return METHOD_REPLACER;
  }
  throw new UnsupportedOperationException("Unexpected MethodOverride subclass: " +
                                          methodOverride.getClass().getName());
}

private static final Class<?>[] CALLBACK_TYPES 
  = new Class<?>[] {NoOp.class, LookupOverrideMethodInterceptor.class, ReplaceOverrideMethodInterceptor.class};

private static class LookupOverrideMethodInterceptor 
  extends CglibIdentitySupport implements MethodInterceptor {

  private final BeanFactory owner;

  public LookupOverrideMethodInterceptor(RootBeanDefinition beanDefinition, BeanFactory owner) {
    super(beanDefinition);
    this.owner = owner;
  }

  @Override
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
    // Cast is safe, as CallbackFilter filters are used selectively.
    LookupOverride lo = (LookupOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
    Assert.state(lo != null, "LookupOverride not found");
    Object[] argsToUse = (args.length > 0 ? args : null); // if no-arg, don't insist on args at all
    if (StringUtils.hasText(lo.getBeanName())) {
      return (argsToUse != null ? this.owner.getBean(lo.getBeanName(), argsToUse) :
              this.owner.getBean(lo.getBeanName()));
    }
    else {
      return (argsToUse != null ? this.owner.getBean(method.getReturnType(), argsToUse) :
              this.owner.getBean(method.getReturnType()));
    }
  }
}

private static class ReplaceOverrideMethodInterceptor 
  extends CglibIdentitySupport implements MethodInterceptor {

  private final BeanFactory owner;

  public ReplaceOverrideMethodInterceptor(RootBeanDefinition beanDefinition, BeanFactory owner) {
    super(beanDefinition);
    this.owner = owner;
  }

  @Override
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
    ReplaceOverride ro = (ReplaceOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
    Assert.state(ro != null, "ReplaceOverride not found");
    // TODO could cache if a singleton for minor performance optimization
    MethodReplacer mr = this.owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class);
    return mr.reimplement(obj, method, args);
  }
}