BeanFactory和FactoryBean

spring中BeanFactory是一个很重要的概念，是IOC容器bean的顶级接口。里面定义了一系列的基本功能

1. package org.springframework.beans.factory;    
2. import org.springframework.beans.BeansException;    
3. public interface BeanFactory {    
4.     String FACTORY_BEAN_PREFIX = "&";    
5.     Object getBean(String name) throws BeansException;    
6.     <T> T getBean(String name, Class<T> requiredType) throws BeansException;    
7.     <T> T getBean(Class<T> requiredType) throws BeansException;    
8.     Object getBean(String name, Object... args) throws BeansException;    
9.     boolean containsBean(String name);    
10.     boolean isSingleton(String name) throws NoSuchBeanDefinitionException;    
11.     boolean isPrototype(String name) throws NoSuchBeanDefinitionException;    
12.     boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;    
13.     Class<?> getType(String name) throws NoSuchBeanDefinitionException;    
14.     String[] getAliases(String name);    

BeanFactory 的子类实现类最终通过getBean方法获得容器bean。

而对于FactoryBean接口，它本身也是一个bean：

1. package org.springframework.beans.factory;    
2. public interface FactoryBean<T> {    
3.     T getObject() throws Exception;    
4.     Class<?> getObjectType();    
5.     boolean isSingleton();    
6. }

它与BeanFactory最大的区别就是：BeanFactory.getBean()方法获取的是容器中的bean，而实现了 FactoryBean的实现类在用BeanFactory.getBean()方法获取的是getObject()方法里面你所定义的返回T，而并不是容器bean本身。如果你想获得bean本身，可以通过BeanFactory.getBean(“&”+beanName)来获取。具体源码可以翻一下：

在bean实例化的入口处：AbstractApplicationContext类的refresh（）方法中：

1. <span style="color:#000000;">@Override  
2.     public void refresh() throws BeansException, IllegalStateException {  
3.         synchronized (this.startupShutdownMonitor) {  
4.             // Prepare this context for refreshing.  
5.             prepareRefresh();  
6.   
7.             // Tell the subclass to refresh the internal bean factory.  
8.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  
9.   
10.             // Prepare the bean factory for use in this context.  
11.             prepareBeanFactory(beanFactory);  
12.   
13.             try {  
14.                 // Allows post-processing of the bean factory in context subclasses.  
15.                 postProcessBeanFactory(beanFactory);  
16.   
17.                 // Invoke factory processors registered as beans in the context.  
18.                 invokeBeanFactoryPostProcessors(beanFactory);  
19.   
20.                 // Register bean processors that intercept bean creation.  
21.                 registerBeanPostProcessors(beanFactory);  
22.   
23.                 // Initialize message source for this context.  
24.                 initMessageSource();  
25.   
26.                 // Initialize event multicaster for this context.  
27.                 initApplicationEventMulticaster();  
28.   
29.                 // Initialize other special beans in specific context subclasses.  
30.                 onRefresh();  
31.   
32.                 // Check for listener beans and register them.  
33.                 registerListeners();  
34.   
35.                 // Instantiate all remaining (non-lazy-init) singletons.  
36.                 finishBeanFactoryInitialization(beanFactory);
37.   
38.                 // Last step: publish corresponding event.  
39.                 finishRefresh();  
40.             }

finishBeanFactoryInitialization方法里主要做的是初始化所有的（剩余的）非懒加载的单例类：跟进去----

1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {  
2.    // Initialize conversion service for this context.  
3.    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&  
4.          beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {  
5.       beanFactory.setConversionService(  
6.             beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));  
7.    }  
8.   
9.    // Register a default embedded value resolver if no bean post-processor  
10.    // (such as a PropertyPlaceholderConfigurer bean) registered any before:  
11.    // at this point, primarily for resolution in annotation attribute values.  
12.    if (!beanFactory.hasEmbeddedValueResolver()) {  
13.       beanFactory.addEmbeddedValueResolver(new StringValueResolver() {  
14.          @Override  
15.          public String resolveStringValue(String strVal) {  
16.             return getEnvironment().resolvePlaceholders(strVal);  
17.          }  
18.       });  
19.    }  
20.   
21.    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.  
22.    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);  
23.    for (String weaverAwareName : weaverAwareNames) {  
24.       getBean(weaverAwareName);  
25.    }  
26.   
27.    // Stop using the temporary ClassLoader for type matching.  
28.    beanFactory.setTempClassLoader(null);  
29.   
30.    // Allow for caching all bean definition metadata, not expecting further changes.  
31.    beanFactory.freezeConfiguration();  
32.   
33.    // Instantiate all remaining (non-lazy-init) singletons.  
34.    beanFactory.preInstantiateSingletons</span>();  

从preInstantiateSingletons方法进去可以看到它是ConfigurableListableBeanFactory接口的方法，由子类DefaultListableBeanFactory实现了该方法，可以看看具体的代码：

1. public void preInstantiateSingletons() throws BeansException {  
2.    if (this.logger.isDebugEnabled()) {  
3.       this.logger.debug("Pre-instantiating singletons in " + this);  
4.    }  
5.   
6.    // Iterate over a copy to allow for init methods which in turn register new bean definitions.  
7.    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.  
8.    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);  
9.   
10.    // Trigger initialization of all non-lazy singleton beans...  
11.    for (String beanName : beanNames) {  
12.       RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);  
13.       if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {  
14.          if (isFactoryBean(beanName)) {  
15.             final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);  
16.             boolean isEagerInit;  
17.             if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean)     {  
18.                isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {  
19.                   @Override  
20.                   public Boolean run() {  
21.                      return ((SmartFactoryBean<?>) factory).isEagerInit();  
22.                   }  
23.                }, getAccessControlContext());  
24.             }  
25.             else {  
26.                isEagerInit = (factory instanceof SmartFactoryBean &&  
27.                      ((SmartFactoryBean<?>) factory).isEagerInit());  
28.             }  
29.             if (isEagerInit) {  
30.                getBean(beanName);  
31.             }  
32.          }  
33.          else {  
34.             getBean(beanName);  
35.          }  
36.       }  

1. 在这段代码的中间可以看到：首先判断!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()非抽象、单例、非懒加载的情况时，如果是FactoryBean，那么final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);是通过一个“&”符号获得IOC中的bean，如果不是FactoryBean则直接通过getBean即可。  
2. https://www.cnblogs.com/jyyzzjl/p/5459335.html 引入另外一篇博文，对后续有更多的解释！

  
  

   
   
很多开源项目在集成Spring 时都使用到FactoryBean，比如 MyBatis3 提供 mybatis-spring项目中的 org.mybatis.spring.SqlSessionFactoryBean：

   
   
<bean id="tradeSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="trade" />
        <property name="mapperLocations" value="classpath*:mapper/trade/*Mapper.xml" />
        <property name="configLocation" value="classpath:mybatis-config.xml" />
        <property name="typeAliasesPackage" value="com.bytebeats.mybatis3.domain.trade" />
    </bean>

   
   
org.mybatis.spring.SqlSessionFactoryBean 如下：
   
   

package org.mybatis.spring;

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
private static final Log LOGGER = LogFactory.getLog(SqlSessionFactoryBean.class);
        ......
}


   
   
另外，阿里开源的分布式服务框架 Dubbo 中的Consumer 也使用到了FactoryBean：
   
   
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
    ">
     
    <!-- 当前应用信息配置 -->
    <dubbo:application name="demo-consumer" />
   
   <!-- 暴露服务协议配置 -->
    <dubbo:protocol name="dubbo" port="20813" />    

    <!-- 暴露服务配置 -->
    <dubbo:reference id="demoService" interface="com.alibaba.dubbo.config.spring.api.DemoService"  />
     
</beans>

   
   
<dubbo:reference  对应的Bean是com.alibaba.dubbo.config.spring.ReferenceBean 类，如下：
   
   
public class ReferenceBean<T> extends ReferenceConfig<T> implements FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean {

}