spring 生命周期最详解

来源：互联网发布：mac groovy sdk 编辑：程序博客网时间：2024/06/13 16:11

还未完成抱歉，由于翻译英文api十分耗时，博客只能保存一份草稿，所以只能提前发表，这周会写完。

目的

在大三开始学习spring时，老师就说spring bean周期非常重要，当时也有仔细看，但是说实话搞不大懂，后面工作面试也问过，还是有点模糊，就是没有掌握好，进行深入理解，这次“老大”又问到了。不允许再回避了，所以这次坚决搞明白，理解生命周期作用，为啥要这样设计，我们能在生命周期做哪些更高层次的编程。

生命周期流程图

先总体看下spring的生命周期流程图，实现（继承）这些接口（抽象类）并在容器里注册，就可以看到bean的生命周期会按下面流程进行，后面会给出测试代码。

这里写图片描述

测试代码

要被注册的Person类

package springBeanTest;import org.springframework.beans.BeansException;import org.springframework.beans.factory.*;public class Person implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {    private String name;    private String address;    private int phone;    private BeanFactory beanFactory;    private String beanName;    public Person() {        System.out.println("【构造器】调用Person的构造器实例化");    }    public String getName() {        return name;    }    public void setName(String name) {        System.out.println("【注入属性】name");        this.name = name;    }    public String getAddress() {        return address;    }    public void setAddress(String address) {        System.out.println("【注入属性】address");        this.address = address;    }    public int getPhone() {        return phone;    }    public void setPhone(int phone) {        System.out.println("【注入属性】phone");        this.phone = phone;    }    // 这是BeanFactoryAware接口方法    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {        System.out.println("【BeanFactoryAware接口】调用setBeanFactory方法");        this.beanFactory = beanFactory;    }    // 这是BeanNameAware接口方法    public void setBeanName(String s) {        System.out.println("【BeanNameAware接口】调用setBeanName方法");        this.beanName = s;    }    // 这是DiposibleBean接口方法    public void destroy() throws Exception {        System.out.println("【DiposibleBean接口】调用destroy方法");    }    // 这是InitializingBean接口方法    public void afterPropertiesSet() throws Exception {        System.out.println("【InitializingBean接口】调用afterPropertiesSet方法");    }    // 通过<bean>的init-method属性指定的初始化方法    public void myInit() {        System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");    }    // 通过<bean>的destroy-method属性指定的初始化方法    public void myDestory() {        System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");    }}

实现BeanFactoryPostProcessor的类

package springBeanTest;import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.beans.factory.config.BeanFactoryPostProcessor;import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor{    public MyBeanFactoryPostProcessor() {        super();        System.out.println("这是BeanFactoryPostProcessor实现类构造器！！");    }    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {        System.out                .println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");        BeanDefinition bd = configurableListableBeanFactory.getBeanDefinition("person");        bd.getPropertyValues().addPropertyValue("phone", "110");    }}

继承InstantiationAwareBeanPostProcessorAdapter的类

package springBeanTest;import java.beans.PropertyDescriptor;import org.springframework.beans.BeansException;import org.springframework.beans.PropertyValues;import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;public class MyInstantiationAwareBeanPostProcessor extends        InstantiationAwareBeanPostProcessorAdapter {    public MyInstantiationAwareBeanPostProcessor() {        super();        System.out                .println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！");    }    // 接口方法、实例化Bean之前调用    @Override    public Object postProcessBeforeInstantiation(Class beanClass,                                                 String beanName) throws BeansException {        System.out                .println("InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");        return null;    }    // 接口方法、实例化Bean之后调用    @Override    public Object postProcessAfterInitialization(Object bean, String beanName)            throws BeansException {        System.out                .println("InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");        return bean;    }    // 接口方法、设置某个属性时调用    @Override    public PropertyValues postProcessPropertyValues(PropertyValues pvs,                                                    PropertyDescriptor[] pds, Object bean, String beanName)            throws BeansException {        System.out                .println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");        return pvs;    }}

实现BeanPostProcessor的类

package springBeanTest;import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.BeanPostProcessor;public class MyBeanPostProcessor implements BeanPostProcessor{    public MyBeanPostProcessor(){        System.out.println("这是BeanPostProcessor实现类构造器！！");    }    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {        System.out.println("BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改");        return o;    }    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {        System.out.println("BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改");        return o;    }}

测试类BeanLifeCycle

package springBeanTest;        import org.springframework.context.ApplicationContext;        import org.springframework.context.support.ClassPathXmlApplicationContext;public class BeanLifeCycle {    public static void main(String[] args) {        System.out.println("现在开始初始化容器");        ApplicationContext factory = new ClassPathXmlApplicationContext("beans.xml");        System.out.println("容器初始化成功");        //得到Preson，并使用        Person person = factory.getBean("person",Person.class);        System.out.println(person);        System.out.println("现在开始关闭容器！");        ((ClassPathXmlApplicationContext)factory).registerShutdownHook();    }}

配置文件

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"       xsi:schemaLocation="            http://www.springframework.org/schema/beans            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">    <bean id="beanPostProcessor" class="springBeanTest.MyBeanPostProcessor">    </bean>    <bean id="instantiationAwareBeanPostProcessor" class="springBeanTest.MyInstantiationAwareBeanPostProcessor">    </bean>    <bean id="beanFactoryPostProcessor" class="springBeanTest.MyBeanFactoryPostProcessor">    </bean>    <bean id="person" class="springBeanTest.Person" init-method="myInit"          destroy-method="myDestory" scope="singleton" p:name="张三" p:address="广州"          p:phone="123567889"/></beans>

生命周期的接口和抽象类

大概了解了生命周期的流程和运用到哪些接口和抽象类之后，下面开始进一步深入了解他们的具体作用，按照流程往下一一介绍。

BeanFactoryPostProcessor接口

package org.springframework.beans.factory.config;import org.springframework.beans.BeansException;public interface BeanFactoryPostProcessor {    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;}

该接口只有一个postProcessBeanFactory方法，初次看不知干嘛，关键在于参数，可以利用参数做一些操作。

下面了解一下这个参数。
ConfigurableListableBeanFactory 提供分析、修改bean定义和预先实例化单例。这个BeanFactory的子接口不应该是被使用于普通应用程序中：BeanFactory和ListableBeanFactory铁铮铮作为最经典的用例;这个接口是仅应该允许内部框架使用，即使在访问bean factory配置方法时也如此。

ConfigurableListableBeanFactory 的方法

clearMetadataCache() : 清除合并的bean定义缓存，删除目前仍不符合完全元数据缓存的bean条目。通常在更改原始bean定义之后触发，例如在应用一个BeanFactoryPostProcessor之后。请注意此时已经被创建的beans的元数据将被保存。
freezeConfiguration()：冻结全部bean定义，给被注册的bean定义发信号告诉它们今后不再被修改和后台处理。它允许factory去积极缓存bean定义元数据。
isConfigurationFrozen():返回factory的bean定义是否被冻结。如果是，它们今后不再被修改和后台处理。
getBeanDefinition(String beanName)：返回被指定bean名称被注册的bean定义，允许其访问其属性和构造函数参数值（可以在bean工厂后期处理期间被处理）。这个被返回的bean definition对象不应该是副本而是原始在工厂被注册的。这意味着如果需要它可以被转换为更具体的实现类型。注意这个方法只能获得本地工厂bean definition。
Iterator getBeanNamesIterator()
void ignoreDependencyType(Class<?> type)：自动忽略被给定依赖类型，例如String是默认没有依赖类型。
-void ignoreDependencyInterface(Class<?> ifc) ：这个通常被使用由注册依赖的应用上下文，可以以多种方式实现。例如BeanFactory通过BeanFactoryAware，ApplicationContext 通过ApplicationContextAware。
void registerResolvableDependency(Class<?> dependencyType,Object autowiredValue)：注册一个特定类型依赖伴随着响应的自动值。这是被用于应该可自动装配而不是在工厂被定义为bean的工厂/上下文引用。例如将一个应用上下文类型依赖解析为该bean所在的ApplicationContext实例。注意~没有这样的默认类型在一个简单的BeanFactory中注册，甚至不是BeanFactory接口本身。
boolean isAutowireCandidate(String beanName,DependencyDescriptor descriptor)throws NoSuchBeanDefinitionException ：确认这个被指定的bean是否是一个自动候选，将被注入到其他声明匹配类型的bean中。
void preInstantiateSingletons()throws BeansException

阅读全文

1 0