Spring官网阅读（七）容器的扩展点（二）FactoryBean

public class MyFactoryBean implements FactoryBean {
 @Override
 public Object getObject() throws Exception {
  System.out.println("执行了一段复杂的创建Bean的逻辑");
  return new TestBean();
 }

 @Override
 public Class<?> getObjectType() {
  return TestBean.class;
 }

 @Override
 public boolean isSingleton() {
  return true;
 }
}

public class TestBean {
 public TestBean(){
  System.out.println("TestBean被创建出来了");
 }
}
// 测试类
public class Main {
 public static void main(String[] args) {
  AnnotationConfigApplicationContext ac=
    new AnnotationConfigApplicationContext(Config.class);
  System.out.println("直接调用getBean(\"myFactoryBean\")返回："+ac.getBean("myFactoryBean"));
  System.out.println("调用getBean(\"&myFactoryBean\")返回："+ac.getBean("&myFactoryBean"));
 }
}

// .....省略无关代码.......

// 1.判断是不是一个FactoryBean
if (isFactoryBean(beanName)) {
    // 2.如果是一个FactoryBean那么在getBean时，添加前缀“&”，获取这个FactoryBean
    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    if (bean instanceof FactoryBean) {
        final FactoryBean<?> factory = (FactoryBean<?>) bean;
        boolean isEagerInit;
        // 3.做权限校验，判断是否是一个SmartFactoryBean，并且不是懒加载的
        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
            isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                                        ((SmartFactoryBean<?>) factory)::isEagerInit,
                                                        getAccessControlContext());
        }
        else {
            // 3.判断是否是一个SmartFactoryBean，并且不是懒加载的
            isEagerInit = (factory instanceof SmartFactoryBean &&
                           ((SmartFactoryBean<?>) factory).isEagerInit());
        }
        if (isEagerInit) {
            // 4.如果是一个SmartFactoryBean并且不是懒加载的，那么创建这个FactoryBean创建的Bean
            getBean(beanName);
        }
    }
}
else {
    // 不是一个FactoryBean，直接创建这个Bean
    getBean(beanName);
}
// ...省略无关代码.....

public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
    String beanName = transformedBeanName(name);
    // 直接从单例池中获取这个Bean，然后进行判断，看是否是一个FactoryBean
    Object beanInstance = getSingleton(beanName, false);
    if (beanInstance != null) {
        return (beanInstance instanceof FactoryBean);
    }
    // 查找不到这个BeanDefinition，那么从父容器中再次确认是否是一个FactoryBean
    if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
        // No bean definition found in this factory -> delegate to parent.
        return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
    }
    // 从当前容器中，根据BeanDefinition判断是否是一个FactoryBean
    return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
}

// 是否为原型，默认不是原型
default boolean isPrototype() {
    return false;
}

// 是否为懒加载，默认为懒加载
default boolean isEagerInit() {
    return false;
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                          @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
 
    // 1.获取bean名称
    final String beanName = transformedBeanName(name);
    Object bean;
 
    //...省略无关代码...，这里主要根据beanName创建对应的Bean
 
    // 2.调用getObject对象创建Bean
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

protected String transformedBeanName(String name) {
    // 這個方法主要用來解析別名，如果是別名的話，获取真实的BeanName
    return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

 // 处理FactoryBean
public static String transformedBeanName(String name) {
    Assert.notNull(name, "'name' must not be null");
    // 没有带“&”，直接返回
    if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
        return name;
    }
    // 去除所有的“&”，防止这种写法getBean("&&&&beanName")
    return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
        do {
            beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
        }
        while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
        return beanName;
    });
}

@Nullable
private String factoryBeanName;
@Nullable
private String factoryMethodName;

@Configuration
public class Config {
 @Bean
 public B b(){
  return new B();
 }
}

<bean id="factoryBean" class="com.dmz.official.extension.factorybean.C"/>

<bean id="b" class="com.dmz.official.extension.factorybean.B" factory-bean="factoryBean" factory-method="b"/>

boolean containsBean(String beanName)

Object getBean(String)

Object getBean(String, Class)

Class getType(String name)

boolean isSingleton(String)

String[] getAliases(String name)