深入剖析 Spring 框架的 BeanFactory

本文内容纲要:深入剖析 Spring 框架的 BeanFactory

说到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 BeanMetadataAttributeAccessor

implements BeanDefinition, Cloneable {

private volatile Object beanClass;

private String scope = SCOPE_DEFAULT;

private boolean abstractFlag = false;

private boolean lazyInit = false;

private int autowireMode = AUTOWIRE_NO;

private int dependencyCheck = DEPENDENCY_CHECK_NONE;

private String[] dependsOn;private ConstructorArgumentValues constructorArgumentValues;

private MutablePropertyValues propertyValues;private String factoryBeanName;

private String factoryMethodName;

private String initMethodName;

private String destroyMethodName;

beanClass保存bean的class属性,scop保存bean是否单例,abstractFlag保存该bean是否抽象,lazyInit保存是否延迟初始化,autowireMode保存是否自动装配,dependencyCheck保存是否坚持依赖,dependsOn保存该bean依赖于哪些bean(这些bean必须提取初始化),constructorArgumentValues保存通过构造函数注入的依赖,propertyValues保存通过setter方法注入的依赖,factoryBeanName和factoryMethodName用于factorybean,也就是工厂类型的bean,initMethodName和destroyMethodName分别对应bean的init-method和destory-method属性,比如:

<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 AbstractAutowireCapableBeanFactory

implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

/** Map of bean definition objects, keyed by bean name */

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);

@Override

public 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时使用到的占位符的值,就是它注入进去的:

Image

public abstract class PropertyResourceConfigurer extends PropertiesLoaderSupport

implements BeanFactoryPostProcessor, PriorityOrdered {

@Override

public 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>

表示 mockPersister 有一个依赖属性 newsBean,该属性的每次注入都是通过调用newsBean.getNewsBean() 方法获得的。

9) autowire 是否启用自动装配依赖,默认为 no, 其它取值还有:byName, byType, constructor

本文内容总结:深入剖析 Spring 框架的 BeanFactory

原文链接:https://www.cnblogs.com/digdeep/p/4518571.html

以上是 深入剖析 Spring 框架的 BeanFactory 的全部内容, 来源链接: utcz.com/z/296163.html

回到顶部