Spring源码解析：BeanFactory深入理解

分手后的思念是犯贱 2022-04-05 11:07 295阅读 0赞

（现在一般都用ApplicantContext代替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文件中的每一个<bean />元素分别转换成一个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属性，比如：

读完配置文件之后，得到了很多的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时使用到的占位符的值，就是它注入进去的：

![202226050255435.png][]

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);在子类中实现的，功能就是将 $\{jdbc\_username\}等等这些替换成实际值。

### **2、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.
 * 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.
 * 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.
 * 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 before 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 after 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).
 * 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接口对应于 <bean /> 的 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接口的效果。

### **3、 总结** ###

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，因为实现了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的结合：

<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方法注入：

构造函数注入使用：<constructor-arg index="0" value="7500000"/>， <constructor-arg type="int" value="7500000"/>，对于非简单参数，需要使用ref <constructor-arg index="1" ref="bar"/>

setter方法注入使用 <property name="username" value="xxx"/>, 非简单类型属性使用ref <property name="xxbean" ref="xxx"/>

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

<bean id="moreComplexObject" class="example.ComplexObject">
 
 <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>
 
 <property name="someList">
 <list>
 <value>a list element followed by a reference</value>
 <ref bean="myDataSource" />
 </list>
 </property>
 
 <property name="someMap">
 <map>
 <entry key="an entry" value="just some string"/>
 <entry key ="a ref" value-ref="myDataSource"/>
 </map>
 </property>
 
 <property name="someSet">
 <set>
 <value>just some string</value>
 <ref bean="myDataSource" />
 </set>
 </property>
 </bean>

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

**5.** <bean> 元素可以配置的属性：

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

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

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

**3）**depends-on 依赖于某个bean，其必须先初始化：<bean id="xxx" class="xxx" depends-on="refbean" />

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

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

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

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

**8) **lookup-method 方法注入：

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

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

原文链接：[http://www.cnblogs.com/digdeep/p/4518571.html][http_www.cnblogs.com_digdeep_p_4518571.html]

[202226050255435.png]: /images/20220405/c99836893db3470ba1093de66221fc28.png
[http_www.cnblogs.com_digdeep_p_4518571.html]: http://www.cnblogs.com/digdeep/p/4518571.html