【小家Spring】为脱离Spring IOC容器管理的Bean赋能【依赖注入】的能力，并分析原理（借助AutowireCapableBeanFactory赋能）（下）

  @Override
  public Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
    // Use non-singleton bean definition, to avoid registering bean as dependent bean.
    final RootBeanDefinition bd = new RootBeanDefinition(beanClass, autowireMode, dependencyCheck);
    bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    if (bd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR) {
      return autowireConstructor(beanClass.getName(), bd, null, null).getWrappedInstance();
    }
    else {
      Object bean;
      final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
        bean = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
            getInstantiationStrategy().instantiate(bd, null, parent),
            getAccessControlContext());
      }
      else {
        bean = getInstantiationStrategy().instantiate(bd, null, parent);
      }
      populateBean(beanClass.getName(), bd, new BeanWrapperImpl(bean));
      return bean;
    }
  }

  @Override
  public void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
      throws BeansException {
    // 构造器注入的模式，这里就不能支持了
    if (autowireMode == AUTOWIRE_CONSTRUCTOR) {
      throw new IllegalArgumentException("AUTOWIRE_CONSTRUCTOR not supported for existing bean instance");
    }
    // Use non-singleton bean definition, to avoid registering bean as dependent bean.
    RootBeanDefinition bd =
        new RootBeanDefinition(ClassUtils.getUserClass(existingBean), autowireMode, dependencyCheck);
    bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    BeanWrapper bw = new BeanWrapperImpl(existingBean);
    initBeanWrapper(bw);
    populateBean(bd.getBeanClass().getName(), bd, bw);
  }

    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RootConfig.class);
        // ApplicationContext里面是持久AutowireCapableBeanFactory这个工具的，它真实的实现类一般都是：DefaultListableBeanFactory
        AutowireCapableBeanFactory autowireCapableBeanFactory = applicationContext.getAutowireCapableBeanFactory();
        //我们也可以自己手动创建一个实例  然后让Spring帮我们自动装配就行  也能正常注入
        Child child = new Child();
        autowireCapableBeanFactory.autowireBeanProperties(child, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);
        System.out.println(child.getHelloService()); //com.fsx.service.HelloServiceImpl@175c2241
    }

  @Override
  public Object initializeBean(Object existingBean, String beanName) {
    return initializeBean(beanName, existingBean, null);
  }

// Interface responsible for creating instances corresponding to a root bean definition.
// 简而言之，就是根据RootBeanDefinition，去实例化一个实例（相当于new了一个对象而已，bean的具体的属性在此时并未赋值）
public interface InstantiationStrategy {
  // 下面是他的三个重载方法
  // owner：这个Bean定义所属的BeanFactory工厂
  // args：构造函数的参数（大多数情况下都用无参构造）
  // factoryBean:factoryMethod  也支持工厂方法方式创建实例（注意此factoryBean非我们所常指的接口：FactoryBean哦~）
  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;
}

  if (!bd.hasMethodOverrides()) {
    ...
    // 最后：借助BeanUtils.instantiateClass(ctor, args) 利用构造函数创建实例
  } else {
    return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
  }

@Component
public class A {
    @Autowired
    private B b;
    public B getB() {
        return b;
    }
}
@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) // 这里scope指定不是单例
public class B {
}
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RootConfig.class);
        A a = applicationContext.getBean(A.class);
        // 我们发现，虽然我们给B设置成`prototype`，但是从a里面get出来的每次都还是同一个对象
        System.out.println(a.getB() == a.getB()); //true
        //证明B不是单例了：
        B b1 = applicationContext.getBean(B.class);
        B b2 = applicationContext.getBean(B.class);
        //证明B并不是单例的
        System.out.println(b1 == b2); //false
    }

@Component
public class A {
    @Autowired
    private B b;
    @Lookup // 采用方法注入
    public B getB() {
        return b;
    }
}
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RootConfig.class);
        A a = applicationContext.getBean(A.class);
        // 不仅仅每次getB都不一样了，我们还发现a已经变成了一个CGLIB的代理对象
        System.out.println(a); //com.fsx.bean.A$$EnhancerBySpringCGLIB$$558725dc@6a6cb05c
        System.out.println(a.getB() == a.getB()); //false
    }

private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();