Spring源码学习--BeanFactory接口

本文主要是介绍Spring源码学习--BeanFactory接口，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章来源:

1 https://www.cnblogs.com/digdeep/p/4518571.html
2 http://www.cnblogs.com/leftthen/p/5259288.html

BeanFactory 是Spring bean容器的根接口.提供获取bean,是否包含bean,是否单例与原型,获取bean类型,bean别名的api.

AutowireCapableBeanFactory 添加集成其他框架功能.如果集成WebWork则可以使用Spring对Actions等进行管理.

HierarchicalBeanFactory 提供父容器的访问功能

ConfigurableBeanFactory 如名,提供factory的配置功能,眼花缭乱好多api

ConfigurableListableBeanFactory 集大成者,提供解析,修改bean定义,并与初始化单例.

ListableBeanFactory 提供容器内bean实例的枚举功能.这边不会考虑父容器内的实例.

看到这边,我们是不是想起了设计模式原则里的接口隔离原则(Interface Segregation Principle(ISP))：客户端不应该依赖它不需要的接口；类间的依赖关系应该建立在最小的接口上对这个有兴趣的话,找度娘或者看看这个设计模式六大原则（4）：接口隔离原则

https://blog.csdn.net/zhengzhb/article/details/7296921

这边清晰地定义了如下的体系:

根接口BeanFactory(基础容器)
第二层: 第三方集成,继承体系,遍历bean
第三层: 配置功能
第四层: 配置+迭代

BeanFactory 源码具体：

　　1、4个获取实例的方法。getBean的重载方法。

　　2、4个判断的方法。判断是否存在，是否为单例、原型，名称类型是否匹配。

　　3、1个获取类型的方法、1个获取别名的方法。根据名称获取类型、根据名称获取别名。一目了然！

总结：

　　这10个方法，很明显，这是一个典型的工厂模式的工厂接口。:

package org.springframework.beans.factory;
public interface BeanFactory {/*** 用于区分是否直接获取FactoryBean实例.* bean以&开头表示获取FactoryBean实例.否则获取created的实例.For example, if the bean named* {@code myJndiObject} is a FactoryBean, getting {@code &myJndiObject}* will return the factory, not the instance returned by the factory.*/String FACTORY_BEAN_PREFIX = "&";/*** 返回一个原型或者单例实例.* 抢单例,原型设计模式的饭碗* 可以根据别名查找,也可以去父容器实例查找*/Object getBean(String name) throws BeansException;/*** 加个类型*/<T> T getBean(String name, Class<T> requiredType) throws BeansException;/*** 根据类型获取bean实例.可以是接口或子类,但不能是{@code null}.* {@link ListableBeanFactory}也可以使用类型转化为name进行查找.更多bean集合的操作可以看* ListableBeanFactory和BeanFactoryUtils*/<T> T getBean(Class<T> requiredType) throws BeansException;/*** 多了构造方法,工厂方法的参数*/Object getBean(String name, Object... args) throws BeansException;/*** 判断是否包含bean(包括别名,父容器)* 陷阱出现:这边不管类是否抽象类,懒加载,是否在容器范围内,只要符合都返回true,所以这边true,不一定能从getBean获取实例*/boolean containsBean(String name);/*** 是否单例*/boolean isSingleton(String name) throws NoSuchBeanDefinitionException;/*** 是否为原型（多实例）*/boolean isPrototype(String name) throws NoSuchBeanDefinitionException;/*** 名称、类型是否匹配*/boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;/*** 根据bean name获取类型*/Class<?> getType(String name) throws NoSuchBeanDefinitionException;/*** 根据实例的名字获取实例的别名*/String[] getAliases(String name);}

说到Spring框架，人们往往大谈特谈一些似乎高逼格的东西，比如依赖注入，控制反转，面向切面等等。但是却忘记了最基本的一点，Spring的本质是一个bean工厂(beanFactory)或者说bean容器，它按照我们的要求，生产我们需要的各种各样的bean，提供给我们使用。只是在生产bean的过程中，需要解决bean之间的依赖问题，才引入了依赖注入(DI)这种技术。也就是说依赖注入是beanFactory生产bean时为了解决bean之间的依赖的一种技术而已。

那么我们为什么需要Spring框架来给我们提供这个beanFactory的功能呢？原因是一般我们认为是，可以将原来硬编码的依赖，通过Spring这个beanFactory这个工长来注入依赖，也就是说原来只有依赖方和被依赖方，现在我们引入了第三方——spring这个beanFactory，由它来解决bean之间的依赖问题，达到了松耦合的效果；这个只是原因之一，还有一个更加重要的原因：在没有spring这个beanFactory之前，我们都是直接通过new来实例化各种对象，现在各种对象bean的生产都是通过beanFactory来实例化的，这样的话，spring这个beanFactory就可以在实例化bean的过程中，做一些小动作——在实例化bean的各个阶段进行一些额外的处理，也就是说beanFactory会在bean的生命周期的各个阶段中对bean进行各种管理，并且spring将这些阶段通过各种接口暴露给我们，让我们可以对bean进行各种处理，我们只要让bean实现对应的接口，那么spring就会在bean的生命周期调用我们实现的接口来处理该bean。下面我们看是如何实现这一点的。

1. bean容器的启动

bean在实例化之前，必须是在bean容器启动之后。所以就有了两个阶段：

1）bean容器的启动阶段；2）容器中bean的实例化阶段；

启动阶段

1> 首先是读取bean的xml配置文件，然后解析xml文件中的各种bean的定义，将xml文件中的每一个元素分别转换成一个BeanDefinition对象，其中保存了从配置文件中读取到的该bean的各种信息：

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessorimplements BeanDefinition, Cloneable {// beanClass保存bean的class属性private volatile Object beanClass;// scop保存bean是否单例private String scope = SCOPE_DEFAULT;// abstractFlag保存该bean是否抽象private boolean abstractFlag = false;// lazyInit保存是否延迟初始化private boolean lazyInit = false;// autowireMode保存是否自动装配private int autowireMode = AUTOWIRE_NO;// dependencyCheck保存是否坚持依赖private int dependencyCheck = DEPENDENCY_CHECK_NONE;// dependsOn保存该bean依赖于哪些bean(这些bean必须提取初始化)private String[] dependsOn;// constructorArgumentValues保存通过构造函数注入的依赖private ConstructorArgumentValues constructorArgumentValues;// propertyValues保存通过setter方法注入的依赖private MutablePropertyValues propertyValues;// factoryBeanName和factoryMethodName用于factorybean，也就是工厂类型的beanprivate String factoryBeanName;private String factoryMethodName;// initMethodName和destroyMethodName分别对应bean的init-method和destory-method属性private String initMethodName;private String destroyMethodName;

比如：

<bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">

读完配置文件之后，得到了很多的BeanDefinition对象.

2> 然后通过BeanDefinitionRegistry将这些bean注册到beanFactory中：

public interface BeanDefinitionRegistry extends AliasRegistry {void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException;void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;boolean containsBeanDefinition(String beanName);String[] getBeanDefinitionNames();int getBeanDefinitionCount();boolean isBeanNameInUse(String beanName);
}

BeanFactory的实现类，需要实现BeanDefinitionRegistry 接口：

@SuppressWarnings("serial")
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactoryimplements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {/** Map of bean definition objects, keyed by bean name */private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);@Overridepublic void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {// ... ...this.beanDefinitionMap.put(beanName, beanDefinition);// ... ...}

我们看到BeanDefinition被注册到了 DefaultListableBeanFactory，保存在它的一个ConcurrentHashMap中。

将BeanDefinition注册到了beanFactory之后，在这里Spring为我们提供了一个扩展的切口，允许我们通过实现接口BeanFactoryPostProcessor 在此处来插入我们定义的代码：

public interface BeanFactoryPostProcessor {/*** Modify the application context's internal bean factory after its standard* initialization. All bean definitions will have been loaded, but no beans* will have been instantiated yet. This allows for overriding or adding* properties even to eager-initializing beans.* @param beanFactory the bean factory used by the application context* @throws org.springframework.beans.BeansException in case of errors*/void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

典型的例子就是：PropertyPlaceholderConfigurer，我们一般在配置数据库的dataSource时使用到的占位符的值，就是它注入进去的：

public abstract class PropertyResourceConfigurer extends PropertiesLoaderSupportimplements BeanFactoryPostProcessor, PriorityOrdered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {try {Properties mergedProps = mergeProperties();// Convert the merged properties, if necessary.convertProperties(mergedProps);// Let the subclass process the properties.processProperties(beanFactory, mergedProps);}catch (IOException ex) {throw new BeanInitializationException("Could not load properties", ex);}}

processProperties(beanFactory, mergedProps);在子类中实现的，功能就是将

 <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"><property name="url" value="${jdbc_url}" /><property name="username" value="${jdbc_username}" /><property name="password" value="${jdbc_password}" />

${jdbc_username}等等这些替换成实际值。

bean的实例化阶段

实例化阶段主要是通过反射或者CGLIB对bean进行实例化，在这个阶段Spring又给我们暴露了很多的扩展点：

1> 各种的Aware接口，比如 BeanFactoryAware，MessageSourceAware，ApplicationContextAware

对于实现了这些Aware接口的bean，在实例化bean时Spring会帮我们注入对应的：BeanFactory， MessageSource，ApplicationContext的实例：

public interface BeanFactoryAware extends Aware {/*** Callback that supplies the owning factory to a bean instance.* <p>Invoked after the population of normal bean properties* but before an initialization callback such as* {@link InitializingBean#afterPropertiesSet()} or a custom init-method.* @param beanFactory owning BeanFactory (never {@code null}).* The bean can immediately call methods on the factory.* @throws BeansException in case of initialization errors* @see BeanInitializationException*/void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}

public interface ApplicationContextAware extends Aware {/*** Set the ApplicationContext that this object runs in.* Normally this call will be used to initialize the object.* <p>Invoked after population of normal bean properties but before an init callback such* as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}* or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader},* {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and* {@link MessageSourceAware}, if applicable.* @param applicationContext the ApplicationContext object to be used by this object* @throws ApplicationContextException in case of context initialization errors* @throws BeansException if thrown by application context methods* @see org.springframework.beans.factory.BeanInitializationException*/void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
}

public interface MessageSourceAware extends Aware {/*** Set the MessageSource that this object runs in.* <p>Invoked after population of normal bean properties but before an init* callback like InitializingBean's afterPropertiesSet or a custom init-method.* Invoked before ApplicationContextAware's setApplicationContext.* @param messageSource message sourceto be used by this object*/void setMessageSource(MessageSource messageSource);
}

2> BeanPostProcessor接口

实现了BeanPostProcessor接口的bean，在实例化bean时Spring会帮我们调用接口中的方法：

public interface BeanPostProcessor {/*** Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean* initialization callbacks (like InitializingBean's {@code afterPropertiesSet}* or a custom init-method). The bean will already be populated with property values.* The returned bean instance may be a wrapper around the original.*/Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;/*** Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean* initialization callbacks (like InitializingBean's {@code afterPropertiesSet}* or a custom init-method). The bean will already be populated with property values.* The returned bean instance may be a wrapper around the original.*/Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

从注释中可以知道 postProcessBeforeInitialization方法在 InitializingBean接口的 afterPropertiesSet方法之前执行，而postProcessAfterInitialization方法在 InitializingBean接口的afterPropertiesSet方法之后执行。

3> InitializingBean接口

实现了InitializingBean接口的bean，在实例化bean时Spring会帮我们调用接口中的方法：

public interface InitializingBean {/*** Invoked by a BeanFactory after it has set all bean properties supplied* (and satisfied BeanFactoryAware and ApplicationContextAware).* <p>This method allows the bean instance to perform initialization only* possible when all bean properties have been set and to throw an* exception in the event of misconfiguration.* @throws Exception in the event of misconfiguration (such* as failure to set an essential property) or if initialization fails.*/void afterPropertiesSet() throws Exception;
}

4> DisposableBean接口

实现了BeanPostProcessor接口的bean，在该bean死亡时Spring会帮我们调用接口中的方法：.

public interface DisposableBean {/*** Invoked by a BeanFactory on destruction of a singleton.* @throws Exception in case of shutdown errors.* Exceptions will get logged but not rethrown to allow* other beans to release their resources too.*/void destroy() throws Exception;
}

InitializingBean接口和 DisposableBean接口对应于的 init-method 和 destory-method 属性，其经典的例子就是dataSource:

所以在Spring初始化 dataSource 这个bean之后会调用 DruidDataSource.init 方法:

public void init() throws SQLException {// ... ...try {lock.lockInterruptibly();} catch (InterruptedException e) {throw new SQLException("interrupt", e);}boolean init = false;try {  connections = new DruidConnectionHolder[maxActive];SQLException connectError = null;try {                for (int i = 0, size = getInitialSize(); i < size; ++i) {Connection conn = createPhysicalConnection();DruidConnectionHolder holder = new DruidConnectionHolder(this, conn);connections[poolingCount++] = holder;}if (poolingCount > 0) {poolingPeak = poolingCount;poolingPeakTime = System.currentTimeMillis();}} catch (SQLException ex) {LOG.error("init datasource error", ex);connectError = ex;}          } catch (SQLException e) {LOG.error("dataSource init error", e);throw e;} catch (InterruptedException e) {throw new SQLException(e.getMessage(), e);} finally {inited = true;lock.unlock();}}

基本就是初始化数据库连接池。

在dataSource 这个bean死亡时会调用 DruidDataSource.close()方法:

public void close() {lock.lock();try {for (int i = 0; i < poolingCount; ++i) {try {DruidConnectionHolder connHolder = connections[i];for (PreparedStatementHolder stmtHolder : connHolder.getStatementPool().getMap().values()) {connHolder.getStatementPool().closeRemovedStatement(stmtHolder);}connHolder.getStatementPool().getMap().clear();Connection physicalConnection = connHolder.getConnection();physicalConnection.close();connections[i] = null;destroyCount.incrementAndGet();} catch (Exception ex) {LOG.warn("close connection error", ex);}}          } finally {lock.unlock();}}

基本就是关闭连接池中的连接。

另外注解 @PostConstruct 和 @PreDestroy 也能达到 InitializingBean接口和 DisposableBean接口的效果。

2. 总结

spring容器接管了bean的实例化，不仅仅是通过依赖注入达到了松耦合的效果，同时给我们提供了各种的扩展接口，来在bean的生命周期的各个时期插入我们自己的代码：

0）BeanFactoryPostProcessor接口(在容器启动阶段)1）各种的Aware接口2）BeanPostProcessor接口3）InitializingBean接口(@PostConstruct， init-method)4）DisposableBean接口(@PreDestroy, destory-method)

3. FactoryBean接口

实现了FactoryBean接口的bean是一类叫做factory的bean。其特点是，spring会在使用getBean()调用获得该bean时，会自动调用该bean的getObject()方法，所以返回的不是factory这个bean，而是这个bean.getOjbect()方法的返回值：

public interface FactoryBean<T> {T getObject() throws Exception;Class<?> getObjectType();boolean isSingleton();
}

典型的例子有spring与mybatis的结合：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource" /><property name="configLocation" value="classpath:config/mybatis-config-master.xml" /><property name="mapperLocations" value="classpath*:config/mappers/master/**/*.xml" />
</bean>

我们看上面该bean，因为实现了FactoryBean接口，所以返回的不是 SqlSessionFactoryBean 的实例，而是她的 SqlSessionFactoryBean.getObject() 的返回值：

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {private static final Log logger = LogFactory.getLog(SqlSessionFactoryBean.class);private Resource configLocation;private Resource[] mapperLocations;private DataSource dataSource;public SqlSessionFactory getObject() throws Exception {if (this.sqlSessionFactory == null) {afterPropertiesSet();}return this.sqlSessionFactory;}

其实他是一个专门生产 sqlSessionFactory 的工厂，所以才叫 SqlSessionFactoryBean。而SqlSessionFactory又是生产SqlSession的工厂。

还有spring与ibatis的结合：

 <!-- Spring提供的iBatis的SqlMap配置 --><bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean"><property name="configLocation" value="classpath:sqlmap/sqlmap-config.xml" /><property name="dataSource" ref="dataSource" /></bean>

public class SqlMapClientFactoryBean implements FactoryBean<SqlMapClient>, InitializingBean {private Resource[] configLocations;private Resource[] mappingLocations;private Properties sqlMapClientProperties;private DataSource dataSource;private boolean useTransactionAwareDataSource = true;private Class transactionConfigClass = ExternalTransactionConfig.class;private Properties transactionConfigProperties;private LobHandler lobHandler;private SqlMapClient sqlMapClient;public SqlMapClient getObject() {return this.sqlMapClient;}

SqlMapClientFactoryBean 返回的是 getObject() 中返回的 sqlMapClient, 而不是 SqlMapClientFactoryBean 自己的实例。

4. 依赖注入(DI)

1）依赖注入的方式分为构造函数注入和setter方法注入：

<bean id="exampleBean" class="examples.ExampleBean"><constructor-arg index="0" value="7500000"/><constructor-arg index="1" ref="bar"/>
</bean>
<bean id="bar" class="x.y.Bar"/>

构造函数注入使用：，，对于非简单参数，需要使用ref

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource" /><property name="configLocation" value="classpath:config/mybatis-config.xml" /><property name="mapperLocations" value="classpath*:config/mappers/**/*.xml" />
</bean>

setter方法注入使用 , 非简单类型属性使用ref

2）集合等复杂类型的注入：

<bean id="moreComplexObject" class="example.ComplexObject"><!-- results in a setAdminEmails(java.util.Properties) call --><property name="adminEmails"><props><prop key="administrator">administrator@example.org</prop><prop key="support">support@example.org</prop><prop key="development">development@example.org</prop></props></property><!-- results in a setSomeList(java.util.List) call --><property name="someList"><list><value>a list element followed by a reference</value><ref bean="myDataSource" /></list></property><!-- results in a setSomeMap(java.util.Map) call --><property name="someMap"><map><entry key="an entry" value="just some string"/><entry key ="a ref" value-ref="myDataSource"/></map></property><!-- results in a setSomeSet(java.util.Set) call --><property name="someSet"><set><value>just some string</value><ref bean="myDataSource" /></set></property>
</bean>

也很简单，list属性就是里面包含或者或者, set也类似。map是里面包含这个也好理解，因为map的实现就是使用内部类Entry来存储key和value. Properties是里面包含.

5 元素可以配置的属性：

除了 id 和 class 属性之外，还有一些可选的属性:

1) scope属性，默认的 scope就是 singleton=”true”, springmvc和struts2的重要区别之一就是spring的controll是单例的，而struts2的action是：scope=”prototype” ，还有 scope=”request” ， scope=”session”，scope=”globalSession”(仅用于portlet)

2）abstract属性，是否是抽象的bean：

 <bean id="baseDAO" abstract="true"><property name="dataSource" ref="dataSource" /><property name="sqlMapClient" ref="sqlMapClient" />
</bean>    
<bean id="collectionDAO" class="net.minisns.dal.dao.CollectionDAOImpl" parent="baseDAO" />
<bean id="commentDAO" class="net.minisns.dal.dao.CommentDAOImpl" parent="baseDAO" />

3）depends-on 依赖于某个bean，其必须先初始化：

4）lazy-init=”true” 是否延迟初始化，默认为 false

5) dependency-check 是否对bean依赖的其它bean进行检查，默认值为 none，可取值有：none, simple, object, all等

6）factory-method 和 factory-bean用于静态工厂和非静态工厂：

<bean id="bar" class="...StaticBarInterfaceFactory" factory-method="getInstance"/>
<bean id="barFactory" class="...NonStaticBarInterfaceFactory"/> 
<bean id="bar" factory-bean="barFactory" factory-method="getInstance"/>

7）init-method, destory-method 指定bean初始化和死亡时调用的方法，常用于 dataSource的连接池的配置

8) lookup-method 方法注入：

<bean id="newsBean" class="..xxx" singleton="false"> 
<bean id="mockPersister" class="..impl.MockNewsPersister"><lookup-method name="getNewsBean" bean="newsBean"/> 
</bean>