解析spring中的BeanFactory

转载 2018年04月17日 15:10:38

我们常把spring看作一个bean工厂或者ioc容器,它帮助我们负责对象的创建管理,以及对象间依赖关系的建立,还有其他的功能。

关于工厂的实现,一般来说与我们接触最多的就是BeanFactory和ApplicationContext两种实现方式,当然前者是所有实现的父类,ApplicationContext也是继承于它。

BeanFactory,这种方式我们在代码里基本是不会用到的,因为它是面向spring框架本身的,而且提供的功能比较少,而ApplicationContext是面向开发者的,在beanFactory的基础上扩展了不少额外功能,比如事件的监听,再比如对国际化消息的支持,还是很多。

今天就先谈谈BeanFactory

那么我们为什么需要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属性,比如:

<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 {
    
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

bean的实例化阶段

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

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

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

public interface BeanFactoryAware extends Aware {
   
    void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}
public interface ApplicationContextAware extends Aware {
   
    void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
}
public interface MessageSourceAware extends Aware {
   
    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接口对应于 <bean /> 的 init-method 和 destory-method 属性,其经典的例子就是dataSource:

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

所以在Spring初始化 dataSource 这个bean之后会调用 DruidDataSource.init 方法:    基本就是初始化数据库连接池。

在dataSource 这个bean死亡时会调用 DruidDataSource.close()方法:    基本就是关闭连接池中的连接

另外注解 @PostConstruct 和 @PreDestroy 也能达到 InitializingBean接口 和 DisposableBean接口的效果。一般来说,这两种是比较常用的,也非常方便

复制代码
@Service
public class TestImpl{

    @PostConstruct
    public void init(){
        System.out.println("实例化时会调用此方法");
    }
    @PreDestroy
    public void destory(){
        System.out.println("销毁之前会调用此方法");
    }
}
复制代码

 

 总结

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

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

1)各种的Aware接口

2)BeanPostProcessor接口

3)InitializingBean接口(@PostConstruct, init-method)

4)DisposableBean接口(@PreDestroy, destory-method)

http://www.vab8501.cn/
http://www.vkp1919.cn/
http://www.awt9604.cn/
http://www.igq3204.cn/
http://www.ayp2545.cn/
http://www.pgn4393.cn/
http://www.npd9270.cn/
http://www.sfi6002.cn/
http://www.nne5492.cn/
http://www.yai2320.cn/
http://www.ics4171.cn/
http://www.sfv9051.cn/
http://www.ccg1407.cn/
http://www.hjn1455.cn/
http://www.ygf6271.cn/
http://www.vfm1218.cn/
http://www.aaa4131.cn/
http://www.guc5469.cn/
http://www.dcj3647.cn/
http://www.utm9669.cn/
http://www.ahg7671.cn/
http://www.nxn1651.cn/
http://www.rrq5757.cn/
http://www.pbr1256.cn/
http://www.oai3459.cn/
http://www.vaj6107.cn/
http://www.xfc0942.cn/
http://www.evc2128.cn/
http://www.bwu7749.cn/
http://www.rmf4655.cn/
http://www.pyq8206.cn/
http://www.sdk5229.cn/
http://www.sez8143.cn/
http://www.tfn8353.cn/
http://www.uem3051.cn/
http://www.tza5452.cn/
http://www.epp9269.cn/
http://www.tsr7510.cn/
http://www.xhv3734.cn/
http://www.vrc9998.cn/
http://www.dsf5404.cn/
http://www.xjm6385.cn/
http://www.iaz1229.cn/
http://www.kcv6320.cn/
http://www.usl0022.cn/
http://www.abo8793.cn/
http://www.qeb9677.cn/
http://www.atx6995.cn/
http://www.buv6436.cn/
http://www.lll4952.cn/
http://www.cjx5965.cn/
http://www.otg2660.cn/
http://www.bmn9515.cn/
http://www.ewf1466.cn/
http://www.cbc3788.cn/
http://www.iqp5694.cn/
http://www.drr8954.cn/

【简记】Java Web 内幕——Spring源码(组件分析,BeanFactory源码,Bean创建之前)

本章内容: Bean组件、Context组件解析 BeanFactory的创建 初始化Bean实例之前的操作 Bean组件解析Spring Bean 的创建是典型的工厂模式, 它的顶级接口是BeanF...
  • qqqqq1993qqqqq
  • qqqqq1993qqqqq
  • 2017-07-10 16:18:00
  • 255

spring代码解析

  • 2009年09月21日 16:30
  • 599KB
  • 下载

spring源码解析 pdf

  • 2010年06月03日 14:46
  • 873KB
  • 下载

Spring源码学习之BeanFactory和FactoryBean

今天在学习Spring源码的时候,发现了spring中不仅仅有BeanFactory,还有FactoryBean,突然觉得分不清这两者之间有什么不同,难道仅仅是名字吗?但是从名字上我们也能看出一些端倪...
  • hsj1213522415
  • hsj1213522415
  • 2017-02-24 11:35:10
  • 275

理解spring中的BeanFactory和FactoryBean的区别与联系

首先,这俩都是个接口…实现 BeanFactory 接口的类表明此类事一个工厂,作用就是配置、新建、管理 各种Bean。而 实现 FactoryBean 的类表明此类也是一个Bean,类型为工厂Bea...
  • joenqc
  • joenqc
  • 2017-03-26 20:51:54
  • 3350

简单实现Spring中BeanFactory原理

上一篇文章介绍了Java反射机制在Spring IOC中的应用,知道了BeanFactory底层的实现原理。 原理搞懂了,对Spring IOC理解起来也很容易。 先来看看Java代码获取Spring...
  • mlc1218559742
  • mlc1218559742
  • 2016-10-10 11:22:30
  • 3598

spring中BeanFactory和FactoryBean的区别

spring中BeanFactory和FactoryBean的区别
  • qiesheng
  • qiesheng
  • 2017-06-06 10:13:04
  • 3336

Spring中BeanFactory和FactoryBean的区别

org.springframework.beans及org.springframework.context包是Spring IoC容器的基础。BeanFactory提供的高级配置机制,使得管理任何性质...
  • tanga842428
  • tanga842428
  • 2016-08-13 16:18:13
  • 1409

Spring源码深度解析(四)容器的基础XmlBeanFactory

现在我们已经对Srping的容器有了一个大概的了解,尽管很多地方还很迷糊,但是不要紧,下面我们开始探讨每个步骤的详细实现。接下来我们要深入分析以下代码的实现: BeanFactory bf = new...
  • u012291108
  • u012291108
  • 2016-06-29 20:53:45
  • 5574

Spring中的beanFactory和ApplicationContext的有什么区别和关联

从上面的类结构图中可以看出来,ApplicationContext 是 BeanFactory接口的子接口 其中BeanFactory获得配置文件的实例是: // 使用BeanFactory 读...
  • judyfun
  • judyfun
  • 2015-03-10 10:58:16
  • 1433
收藏助手
不良信息举报
您举报文章:解析spring中的BeanFactory
举报原因:
原因补充:

(最多只允许输入30个字)