【Spring学习】Bean生命周期

ゞ浴缸里的玫瑰 2022-09-21 13:16 176阅读 0赞

我理解的Bean生命周期包括两个方面：

*  Bean何时创建，何时销毁
 *  Bean从创建到销毁的执行流程

## 一、Bean创建与销毁 ##

Bean的创建时机主要由几个配置项共同来决定，包括：

*  scope属性，决定是Bean是单例模式(singleton)还是多例模式(prototype)，默认为单例singleton；
 *  lazy-init属性，***只对单例模式有效，决定是否延时加载***，默认为false，表示在容器初始化时，就会生成单例；
 *  RequestMapping属性，这个注解MVC中才有，当有该属性时，lazy-init属性会失效(其实不是简单的冲突，而是RequestMapping会在另外的逻辑处理中生成单例)；

### 1.scope属性 ###

主要有两个枚举，singleton与prototype，默认值为singleton。

#### 1.1配置scope，如果不配置，默认值都为singleton ####

*  xml配置

*  注解配置，直接使用@Scope注解

@Scope(value=ConfigurableBeanFactory.SCOPE_PROTOTYPE)

#### 1.2 枚举含义 ####

*  singleton，表示单例模式，这个很好理解，表示在容器中，只存在该Bean的一个实例，每次请求Bean时，返回的都是同一个。例：

//例1.2.1
    @Component
    public class Person { 
        public Person(){
            System.out.println("Person 初始化...");
        }
        public static void main(String args[]){
            BeanFactory beanFactory = new ClassPathXmlApplicationContext("mvc-dispatcher-servlet.xml");
            System.out.println("容器初始化完成");
            Person person1 = (Person) beanFactory.getBean("person");
            Person person2 = (Person) beanFactory.getBean("person");
            System.out.println(person1.equals(person2));//同一个实例，打印true
        }
    }
    
    输出：
    Person 初始化...
    容器初始化完成
    true

*  prototype，表示每次请求Bean时，都会新建一个Bean实例，例：

//例1.2.1
    //上例中，在类前加一个注解：
    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    
    输出：
    容器初始化完成
    Person 初始化...
    Person 初始化...
    false

### 2.lazy-init属性 ###

一个布尔型的枚举，就两个值true与false，默认值为true。这个配置只在scope=singleton时有效

#### 2.1 配置lazy-init，默认值为true ####

*  xml中配置

*  注解配置，使用@Lazy注解

//在类前使用
    @Lazy

#### 2.2 枚举含义 ####

*  lazy-init=false，表示容器在初始化时，就会创建单例Bean，这个是默认配置，所以例1.2.1中，先打印“Person 初始化…”，再打印“容器初始化完成”
 *  lazy-init=true，在初次getBean时，才会去创建Bean，例

//例2.2.1
    //在Person类前添加注解@Lazy
    
    输出：
    容器初始化完成
    Person 初始化...
    true

### 3.配置嵌套 ###

主要指singleton与prototype两种不同Bean的相互引用，更具体的来说，其实是singleton对prototype的引用。因为相互引用一共就四种方式，有三种结果非常明确，即：

*  prototype或singleton引用singleton，因为singleton在容器中只会有一个实例，所以结果肯定都是引用同一个类；
 *  prototype引用prototype，重新创建的实例再次注入新的依赖，肯定还是会重新创建的。

所以，只剩singleton对prototype的引用，一开始我就理解错误，以为prototype每次都会变，如下实例：

//例3.1
    
    @Component
    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public class Apple { 
        public Apple(){
            System.out.println("Apple 初始化...");
        }
    }
    
    @Component
    public class Person { 
        @Resource
        Apple apple;
    
        public Person(){
            System.out.println("Person 初始化...");
        }
        public void eat(){
            System.out.println("Apple hashcode="+apple.hashCode());
        }
        public static void main(String args[]){
            BeanFactory beanFactory = new ClassPathXmlApplicationContext("mvc-dispatcher-servlet.xml");
            System.out.println("容器初始化完成");
            Person person1 = (Person) beanFactory.getBean("person");
            Person person2 = (Person) beanFactory.getBean("person");
            person1.eat();
            person2.eat();
        }
    }
    
    输出：
    Person 初始化...
    Apple 初始化...
    容器初始化完成
    Apple hashcode=10745331
    Apple hashcode=10745331

本来以为，每次获取Person的Bean时，都会重新注入Apple，结果证明注入只会在Bean创建时进行一次，后续getBean时，发现单例Person存在，直接就会返回该实例，不会重新进行注入操作。  
       但是如果有这种需求，就是需要每次都重新创建新的Apple，如何实现呢？在网上查询了一下资料，需要使用lookup-method属性配置。

### 4 lookup-method属性 ###

这个属性用于singleton的Bean中获取prototype的Bean，实现每次调用都重新创建新的Bean。

#### 4.1 原理 ####

用户自己指定一个Bean注入时的方法，然后使用Bean时调用这个方法获取。Spring容器会自动用cglib替换方法体，动态调用getBean获取Bean并返回。看看源码：

//1.解析lookup-method属性并注册
    //org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseLookupOverrideSubElements
    /** * Parse lookup-override sub-elements of the given bean element. */
    public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
        NodeList nl = beanEle.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
                Element ele = (Element) node;
                String methodName = ele.getAttribute(NAME_ATTRIBUTE);
                String beanRef = ele.getAttribute(BEAN_ELEMENT);
                //新建lookup重载对象
                LookupOverride override = new LookupOverride(methodName, beanRef);
                override.setSource(extractSource(ele));
                //注册到Bean定义中
                overrides.addOverride(override);
            }
        }
    }
    
    //2.调用lookup-method方法时，调用cglib替换后的代码，再去调用getBean，具体方法没去研究，有时间看看
    //org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor#intercept
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
        // Cast is safe, as CallbackFilter filters are used selectively.
        LookupOverride lo = (LookupOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
        Object[] argsToUse = (args.length > 0 ? args : null);  // if no-arg, don't insist on args at all
        if (StringUtils.hasText(lo.getBeanName())) {
            //有beanName，优先使用beanName匹配
            return this.owner.getBean(lo.getBeanName(), argsToUse);
        }
        else {
            //没有配置beanName，尝试使用类型去匹配，如果匹配到多个，会抛异常
            return this.owner.getBean(method.getReturnType(), argsToUse);
        }
    }

#### 4.2 配置lookup-method ####

*  xml配置

*  注解配置，使用@Lookup在方法前配置

@Lookup
    public Apple getApple(){
        //方法体由Spring自动实现
        return null;
    }

配置后，测试一下：

//例4.1
    @Component
    public class Person { 
    
        public Person(){
            System.out.println("Person 初始化...");
        }
        public void eat(){
            Apple apple = getApple();
            System.out.println("Apple hashcode="+apple.hashCode());
        }
        public static void main(String args[]){
            BeanFactory beanFactory = new ClassPathXmlApplicationContext("mvc-dispatcher-servlet.xml");
            System.out.println("容器初始化完成");
            Person person1 = (Person) beanFactory.getBean("person");
            Person person2 = (Person) beanFactory.getBean("person");
            person1.eat();
            person2.eat();
        }
    
        @Lookup
        public Apple getApple(){
            return null;
        }
    }
    
    测试输出：
    Person 初始化...
    容器初始化完成
    Apple 初始化...
    Apple hashcode=1528848756
    Apple 初始化...
    Apple hashcode=719205737

对比例子4.1与3.1，可以看到实现了每次调用Apple都重新创建的功能，当然，有人可能会问，这样写与自己去实现getApple的方法体，去new一个对象有什么区别呢？还是为了解耦，这样写的好处就是Apple的创建依然交给Spring，Person不依赖于Apple的实现。

## 二、Bean的执行流程 ##

### 1.流程图 ###

首先上一张老图，这里主要是用BeanFactory来初始化容器时，创建Bean会经历的流程。如果使用ApplicationContext，则会有很多额外处理与功能。  
![这里写图片描述][20160621142329925]

### 2.Spring源码，Bean的创建与初始化 ###

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
    protected <T> T doGetBean(
                final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
                throws BeansException {
        ...
        return createBean(beanName, mbd, args);
        ...
    }
    
    
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean
    /** * Central method of this class: creates a bean instance, * populates the bean instance, applies post-processors, etc. * @see #doCreateBean */
    @Override
    protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
            throws BeanCreationException {
    
        //查找Bean相关的类
        // Make sure bean class is actually resolved at this point.
        resolveBeanClass(mbd, beanName);
    
        // Prepare method overrides.
        ...
        //检查重载（字面意思，非对象继承）方法是否存在
        mbd.prepareMethodOverrides();
    
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        ...
        //创建Bean
        Object beanInstance = doCreateBean(beanName, mbd, args);
        ...
        return beanInstance;
    }
    
    
    /** * Actually create the specified bean. Pre-creation processing has already happened * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks. * <p>Differentiates between default bean instantiation, use of a * factory method, and autowiring a constructor. * @param beanName the name of the bean * @param mbd the merged bean definition for the bean * @param args arguments to use if creating a prototype using explicit arguments to a * static factory method. This parameter must be {@code null} except in this case. * @return a new instance of the bean * @throws BeanCreationException if the bean could not be created */
    //真正创建Bean的地方
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        // Instantiate the bean.
        ...
        //创建Bean实例，会调用构造函数
        instanceWrapper = createBeanInstance(beanName, mbd, args);
        ...
        //进行属性设置
        populateBean(beanName, mbd, instanceWrapper);
        ...
        /* org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean 初始化Bean,按顺序包括： 1.BeanNameAware,BeanClassLoaderAware,BeanFactoryAware的对应接口方法 2.BeanPostProcessor的预处理postProcessBeforeInitialization 3.InitializingBean接口的afterPropertiesSet 4.自定义的init-method方法 5.BeanPostProcessor的后处理postProcessAfterInitialization */
        exposedObject = initializeBean(beanName, exposedObject, mbd);
        ...
        // Register bean as disposable.
        //注册DisposableBean，只对singleton的Bean处理
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    
        return exposedObject;
    }

### 3.测试代码 ###

public class Person implements BeanNameAware,BeanFactoryAware,BeanClassLoaderAware,InitializingBean,DisposableBean,ApplicationContextAware { 
    
        public Person(){
            System.out.println("Person 初始化...");
        }
        public static void main(String args[]){
            BeanFactory beanFactory = new ClassPathXmlApplicationContext("mvc-dispatcher-servlet.xml");
            System.out.println("容器初始化完成");
            Person person = (Person) beanFactory.getBean("person");
            person = null;
        }
    
        @Override
        public void setBeanClassLoader(ClassLoader classLoader) {
            System.out.println("BeanClassLoaderAware的setBeanClassLoader()方法注入Classloader,hashcode="+classLoader.hashCode());
        }
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            System.out.println("BeanFactoryAware的setBeanFactory()方法注入BeanFactory,hashcode="+beanFactory.hashCode());
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            //ApplicationContext来初始化容器,会有很多额外处理与功能
            System.out.println("ApplicationContextAware的setApplicationContext()方法注入ApplicationContext,hashcode="+applicationContext.hashCode());
        }
    
        @Override
        public void setBeanName(String name) {
            System.out.println("BeanNameAware的setBeanName()方法name,name="+name);
        }
    
        @Override
        public void destroy() throws Exception {
            System.out.println("DisposableBean的destory()方法");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("InitializingBean的afterPropertiesSet()方法");
        }
    
        @PostConstruct
        public void postConstruct(){
            System.out.println("@PostConstruct注解");
        }
    
        public void initMethod() {
            System.out.println("init-method配置");
        }
    
    }
    
    测试输出：
    Person 初始化...
    BeanNameAware的setBeanName()方法name,name=person
    BeanClassLoaderAware的setBeanClassLoader()方法注入Classloader,hashcode=918884489
    BeanFactoryAware的setBeanFactory()方法注入BeanFactory,hashcode=1574407511
    ApplicationContextAware的setApplicationContext()方法注入ApplicationContext,hashcode=916347070
    BeanPostProcessor的预处理方法,beanName=person
    @PostConstruct注解
    InitializingBean的afterPropertiesSet()方法
    init-method配置
    BeanPostProcessor的后处理方法,beanName=person

### 4.总结 ###

Spring在Bean的初始化过程中提供了很多可以进行干涉的方法，不过一般不建议使用实现Spring接口的方式，如实现InitializingBean，而使用@PostConstruct注解或自定义init-method配置，因为实现接口会与Spring相耦合。

[20160621142329925]: /images/20220721/c077cc5b019747e49954db338ce97fd7.png