Spring Bean的生命周期

Spring自带了两种不同的类型的容器。

两种容器的的bean生命周期略有不同 ​

1:bean工厂(由org.springframework.beans.factory.BeanFactory接口定义)是最简单的容器,提供基本的DI 支持。 ​

2:应用上下文(由org.springframework.context.ApplicationContext接口定义),基于BeanFactory构建,

并提供应用框架级别的服务,例如 从属性文件解析文本信息以及发布应用事件给感兴趣的事件监听者。

 

ApplicationContext Bean生命周期: 

1.Spring对bean进行实例化;

2.Spring将值和bean的引用注入到bean对应的属性中;

3.如果bean实现了BeanNameAware接口,Spring将bean的ID传递给setBeanName()方法;

4.如果bean实现了BeanFactoryAware接口,Spring将调用setBeanFactory()方法,将BeanFactory容器实例传入;

5.如果bean实现了ApplicationContextAware接口,Spring将调用setApplicationContext()方法,将bean所在的应用上下文的引用传入进来;

6.如果上下文中存在实现了BeanPostProcessor接口的bean,Spring将调用它们的postProcessBeforeInitialization()方法;

7.如果bean实现了InitializingBean接口,Spring将调用它们的afterPropertiesSet()方法。

8.如果bean使用init-method声明了初始化方法,该方法被调用;

9.如果上下文中存在实现了BeanPostProcessor接口的bean,Spring将调用它们的postProcessAfterInitialization()方法;

 

经过以上过程之后,就可以正式使用该Bean了,对于scope为singleton的Bean,它们将一直驻留在应用上下文中,直到该应用上下文被销毁;

而对于scope为prototype的Bean,每次被调用都回new一个对象,而且生命周期也交给调用方管理了,不再是Spring容器进行管理了。

 

10. 容器关闭后,如果Bean实现了DisposableBean接口,则会调用该接口的destroy()方法。

11. 如果Bean配置了destroy-method方法,则会执行destroy-method配置的方法,至此,整个Bean生命周期结束。

 

 

 

 

BeanFactory Bean生命周期: 与ApplicationContext相比,有如下几点不同:

  1. BeanFactory容器中,不会调用ApplicationContextAware接口的setApplicationContext()方法。
  2. BeanPostProcessor接口的postProcessBeforeInitialization方法和postProcessAfterInitialization方法不会自动调用,必须自己通过代码手动注册
  3. BeanFactory容器启动的时候,不会去实例化所有bean,包括所有scope为singleton且非延迟加载的bean也是一样,而是在调用的时候去实例化。

详细代码参阅:https://github.com/yucong/spring-bean

UserService.java:

package com.yucong.spring.applicationcontext;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * 该类实现了BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean, DisposableBean五个接口,
 * 并且在applicationContext.xml文件中配置了该Bean的id为userService,
 * 并且配置了init-method和destroy-method,为该Bean配置了属性name为userSercie的值,
 * 然后定义了一个名为MyBeanPostProcessor的bean, 该bean定义类实现了BeanPostProcessor接口
 * 
 * 
 */
public class UserService implements BeanNameAware, BeanFactoryAware,
        ApplicationContextAware, InitializingBean, DisposableBean {

    private String name;

    public UserService() {
        System.out.println("1.UserService 被实例化,UserService()构造方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2.注入属性,setName() 被调用");
    }

    public void setBeanName(String beanName) {
        System.out.println("3.注入beanName,BeanNameAware接口的setBeanName被调用, beanName : " + beanName);
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4.注入beanFactory,BeanFactoryAware接口的setBeanFactory被调用, beanFactory : " + beanFactory);
    }

    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        System.out.println("5.注入applicationContext,ApplicationContextAware接口的setApplicationContext() 被调用, applicationContext : " + applicationContext);
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("7.InitializingBean接口afterPropertiesSet() 被调用");
    }

    public void myInit() {
        System.out.println("8.init-method配置的myInit() 被调用");
    }

    public void destroy() throws Exception {
        System.out.println("10.DisposableBean接口的destroy() 被调用");
    }

    public void myDestroy() {
        System.out.println("11.destroy-method配置的myDestroy() 被调用");
    }

    public String toString() {
        return "UserService[name=" + name + "]";
    }
}

 

MyBeanPostProcessor.java
package com.yucong.spring.applicationcontext;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("9.MyBeanPostProcessor的postProcessAfterInitialization被调用, beanName : "+ beanName);
        return bean;
    }

    /**
     *  实例化、依赖注入完毕,在调用显式的初始化之前完成一些定制的初始化任务
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("6.MyBeanPostProcessor的postProcessBeforeInitialization被调用, beanName : "+ beanName);
        return bean;
    }

}

 

测试类:Test.java

public class Test {


    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        @SuppressWarnings("unused")
        UserService userService = (UserService) applicationContext.getBean("userService");

        ((ClassPathXmlApplicationContext) applicationContext).close();
    }
}

 

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.yucong.spring.applicationcontext.UserService"
        init-method="myInit" destroy-method="myDestroy">
        <property name="name" value="张三"></property>
    </bean>

    <bean id="myPostProcessor"
        class="com.yucong.spring.applicationcontext.MyBeanPostProcessor"></bean>

</beans> 

 

运行结果:

1.UserService 被实例化,UserService()构造方法
2.注入属性,setName() 被调用
3.注入beanName,BeanNameAware接口的setBeanName被调用, beanName : userService
4.注入beanFactory,BeanFactoryAware接口的setBeanFactory被调用, beanFactory : org.springframework.beans.factory.support.DefaultListableBeanFactory@60addb54: defining beans [userService,myPostProcessor]; root of factory hierarchy
5.注入applicationContext,ApplicationContextAware接口的setApplicationContext() 被调用, applicationContext : org.springframework.context.support.ClassPathXmlApplicationContext@41906a77: startup date [Tue Jul 09 20:02:38 CST 2019]; root of context hierarchy
6.MyBeanPostProcessor的postProcessBeforeInitialization被调用, beanName : userService
7.InitializingBean接口afterPropertiesSet() 被调用
8.init-method配置的myInit() 被调用
9.MyBeanPostProcessor的postProcessAfterInitialization被调用, beanName : userService
10.DisposableBean接口的destroy() 被调用
11.destroy-method配置的myDestroy() 被调用

 

 



posted @ 2019-07-09 19:40  喻聪  阅读(658)  评论(0编辑  收藏  举报