spring扩展点-FactoryBean

FactoryBean也是我们向spring容器注入Bean常用手段，这种方式有如下特点：

    a. 延迟加载，只有注入的Bean(T)被依赖时，才会调用getObject方法，首次使用才会调用，此后会从缓存中读取(FactoryBeanRegistrySupport.factoryBeanObjectCache缓存)

    b. 这种方式会创建两个对象，一个是FactoryBean类型，另一个是自定义类型(泛型类型)

    c. 这种方式通常用来注入一些实例化比较复杂的对象

下面让我们来看一下如何使用吧，我们使用这种方式向spring容器注入UserFactoryBean对象：

1. 定义一个要注入的类

/**
 * 测试FactoryBean接口向spring容器注入Bean
 *
 */
public class UserFactoryBean {
	
	private String name;
	
	public UserFactoryBean() {}
	
	public UserFactoryBean(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

2. 定义一个FactoryBean接口实现类

@Configuration
public class MyFactoryBean implements FactoryBean {

	@Override
	public UserFactoryBean getObject() throws Exception {
		UserFactoryBean u = new UserFactoryBean();
		u.setName("张三");
		return u;
	}

	@Override
	public Class getObjectType() {
		return UserFactoryBean.class;
	}

}

3. 测试类

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class BaseTest {

	@Autowired
	private UserFactoryBean userFactoryBean;
	
	@Test
	public void testFactoryBean() {
		if (null != userFactoryBean) {
			System.out.println(userFactoryBean.getName());
		}
	}
}

4. 测试结果

张三

5. 源码分析

5.1 实例化MyFactoryBean

/**
 * GenericWebApplicationContext(AbstractApplicationContext)
 */
public 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 {
			......
			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);
			......
		}

		catch (BeansException ex) {
			......
		}

		finally {
			......
		}
	}
}

/**
 * GenericWebApplicationContext(AbstractApplicationContext)
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	......
	// Instantiate all remaining (non-lazy-init) singletons.
	beanFactory.preInstantiateSingletons();
}

/**
 * DefaultListableBeanFactory
 */
public 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 beanNames = new ArrayList<>(this.beanDefinitionNames);

	// 实例化所有非懒初始化类(默认lazyInit=false，可以通过添加@Lazy注解或在Bean标签设置lazy-init="true")
	for (String beanName : beanNames) {
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			if (isFactoryBean(beanName)) {
				// 如果是FactoryBean,就初始化，注意此处方法参数为&+beanName,这时实例化的是FactoryBean本身
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					final FactoryBean factory = (FactoryBean) bean;
					boolean isEagerInit;
					// 如果bean是FactoryBean类型，且实现了SmartFactoryBean接口，就判断是否需要进一步实例化自定义对象(调用getObject())
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction)
										((SmartFactoryBean) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean) factory).isEagerInit());
					}
					// 如果是懒加载，就不初始化
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			// 如果不是FactoryBean类型，就直接初始化
			else {
				getBean(beanName);
			}
		}
	}

	// Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
		// 如果bean是SmartInitializingSingleton类型，就调用afterSingletonsInstantiated方法
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction