Spring 框架的 BeanFactory

悠悠 2022-05-30 04:38 158阅读 0赞

参考：  
[http://m.knowsky.com/621190.html][http_m.knowsky.com_621190.html]  
[http://www.cnblogs.com/leskang/p/6411011.html][http_www.cnblogs.com_leskang_p_6411011.html]  
[https://www.cnblogs.com/sishang/p/6576665.html][https_www.cnblogs.com_sishang_p_6576665.html]  
[https://www.yiibai.com/spring/spring-postconstruct-and-predestroy-example.html][https_www.yiibai.com_spring_spring-postconstruct-and-predestroy-example.html]

说到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属性，比如：

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

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\}等等这些替换成实际值。

**bean的实例化阶段**

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

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

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

*BeanFactoryAware 和 ApplicationContextAware 的相当于是封装了 BeanFactory，参考 [https://www.cnblogs.com/handsomeye/p/6277510.html][https_www.cnblogs.com_handsomeye_p_6277510.html]*

*Spring框架做消息的多国化时，我们可以借助于MessageSourceAware接口*

*参考 [https://www.yiibai.com/spring/spring-how-to-access-messagesource-in-bean-messagesourceaware.html][https_www.yiibai.com_spring_spring-how-to-access-messagesource-in-bean-messagesourceaware.html]*

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方法之后执行。

多个 PostProcessor 可以通过实现Ordered 接口，设定执行的次序， 0最高。

**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;}

例如：

package cn.springextend;
    
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    
    /** * @author susq * @since 2018-05-09-13:17 */
    public class TestInitializingBean implements InitializingBean, DisposableBean { 
    
        public TestInitializingBean() {
            System.out.println("constructor");
        }
    
        public void init() {
            System.out.println("init");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("afterPropertiesSet");
        }
    
        @Override
        public void destroy() throws Exception {
            System.out.println("destory");
        }
    }

测试：

package cn.springextend;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /** * @author susq * @since 2018-05-09-13:19 */
    public class App { 
        public static void main(String[] args) {
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("cn/springextend/spring-bean.xml");
            TestInitializingBean initializingBean = (TestInitializingBean) context.getBean("testInitializingBean");
            context.close();
            System.out.println("main end ");
    
        }
    }

输出

constructor afterPropertiesSet init destory main end

可见afterPropertiesSet（）是在构造方法之后调用的，这也是为什么该方法叫这个名字，在属性设置（即构造函数）之后调用。

**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的接口，因为它将你的代码紧耦合到 Spring 代码中。 一个更好的做法应该是在bean的配置文件属性指定[ init-method和destroy-method][init-method_destroy-method]。

例如数据库连接：

所以在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接口的效果。 @PostConstruct和@PreDestroy 标注不属于 Spring，它是在J2EE库- common-annotations.jar。

默认情况下，Spring不会意识到@PostConstruct和@PreDestroy注解。要启用它，要么注册“CommonAnnotationBeanPostProcessor”，要么在bean配置文件的‘ 指定， 参考[https://www.yiibai.com/spring/spring-postconstruct-and-predestroy-example.html][https_www.yiibai.com_spring_spring-postconstruct-and-predestroy-example.html]

**2. 总结**

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

**0）** BeanFactoryPostProcessor接口(在容器启动阶段)

**1）** 各种的Aware接口

**2）** BeanPostProcessor接口

**3）** InitializingBean接口(类似的有@PostConstruct， init-method)

**4）** DisposableBean接口(类似的有@PreDestroy, destory-method)

[http_m.knowsky.com_621190.html]: http://m.knowsky.com/621190.html
[http_www.cnblogs.com_leskang_p_6411011.html]: http://www.cnblogs.com/leskang/p/6411011.html
[https_www.cnblogs.com_sishang_p_6576665.html]: https://www.cnblogs.com/sishang/p/6576665.html
[https_www.yiibai.com_spring_spring-postconstruct-and-predestroy-example.html]: https://www.yiibai.com/spring/spring-postconstruct-and-predestroy-example.html
[https_www.cnblogs.com_handsomeye_p_6277510.html]: https://www.cnblogs.com/handsomeye/p/6277510.html
[https_www.yiibai.com_spring_spring-how-to-access-messagesource-in-bean-messagesourceaware.html]: https://www.yiibai.com/spring/spring-how-to-access-messagesource-in-bean-messagesourceaware.html
[init-method_destroy-method]: http://www.yiibai.com/spring/spring-init-method-and-destroy-method-example.html