javabean的生命周期有哪些 javabean生命周期scope

一：bean的作用域 

在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加如下表

scope:设置bean的作用域 scope="singleton/prototype" singleton(单例)：表示获取该bean所对应的对象都是同一个 prototype(多例)：表示获取该bean所对应的对象都不是同一个

<bean id="student" class="com.tian.spring.pojo.Student" scope="prototype">
        <property name="sid" value="1001"></property>
        <property name="sname" value="张三"></property>
    </bean>

@Test
    public void testScope() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-scope.xml");
        Student student1 = ioc.getBean(Student.class);
        Student student2 = ioc.getBean(Student.class);
        System.out.println(student1 == student2);
    }

结果会发现如果使用的是单例则返回true；如果是多例则返回false

二：bean的生命周期

具体的生命周期过程

bean对象创建（调用无参构造器）

给bean对象设置属性 bean对象初始化之前操作（由bean的后置处理器负责）

bean对象初始化（需在配置bean时指定初始化方法）

bean对象初始化之后操作（由bean的后置处理器负责）

bean对象就绪可以使用 bean对象销毁（需在配置bean时指定销毁方法）

IOC容器关闭

 ①创建实体类User

package com.tian.spring.pojo;

public class User {

    private Integer id;
    private String username;
    private String password;
    private Integer age;

    public User() {
        System.out.println("生命周期：1、创建对象");
    }

    public User(Integer id, String username, String password, Integer age) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        System.out.println("生命周期：2、依赖注入");
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void initMethod() {
        System.out.println("生命周期：3、初始化");
    }

    public void destroyMethod() {
        System.out.println("生命周期：5、销毁");
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

②配置bean，创建文件spring-lifecycle

<bean id="User" class="com.tian.spring.pojo.User" init-method="initMethod" destroy-method="destroyMethod">
        <property name="id" value="1"></property>
        <property name="username" value="admin"></property>
        <property name="password" value="123456"></property>
        <property name="age" value="23"></property>
    </bean>

③测试类

ConfigurableApplicationContext是ApplicationContext的子接口，其中扩展了刷新和关闭容器的方法

@Test
    public void test() {
        ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        User user = ioc.getBean(User.class);
        System.out.println(user);
        ioc.close();
    }

结果：

生命周期：1、创建对象
生命周期：2、依赖注入
生命周期：3、初始化
User{id=1, username='admin', password='123456', age=23}
生命周期：4、销毁

结论：

1.实例化

2.依赖注入

3.初始化，需要通过bean的init-method属性指定初始化的方法

4.IOC容器关闭时销毁 ，需要通过bean的destroy-method属性指定销毁的方法

三：bean的作用域对生命周期的影响和后置处理器

1：bean的作用域对生命周期的影响

注意：

若bean的作用域为单例时，生命周期的前三个步骤会在获取IOC容器时执行

若bean的作用域为多例时，生命周期的前三个步骤会在获取bean时执行

<bean id="User" class="com.tian.spring.pojo.User" init-method="initMethod" destroy-method="destroyMethod" scope="prototype">
        <property name="id" value="1"></property>
        <property name="username" value="admin"></property>
        <property name="password" value="123456"></property>
        <property name="age" value="23"></property>
    </bean>

@Test
    public void test() {
        ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
//        User user = ioc.getBean(User.class);
//        System.out.println(user);
//        ioc.close();
    }

若为单例结果：

生命周期：1、创建对象
生命周期：2、依赖注入
生命周期：3、初始化

若为多例结果则什么也不输出

①测试类：

@Test
    public void test() {
        ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        User user = ioc.getBean(User.class);
        System.out.println(user);
        ioc.close();
    }

为单例时： 

生命周期：1、创建对象
生命周期：2、依赖注入
生命周期：3、初始化
User{id=1, username='admin', password='123456', age=23}
生命周期：4、销毁

为多例时：

生命周期：1、创建对象
生命周期：2、依赖注入
生命周期：3、初始化
User{id=1, username='admin', password='123456', age=23}

2：后置处理器

bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口， 且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容 器中所有bean都会执行

①创建bean的后置处理器

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //此方法在bean的生命周期初始化之前执行
        System.out.println("MyBeanPostProcessor-->后置处理器postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //此方法在bean的生命周期初始化之后执行
        System.out.println("MyBeanPostProcessor-->后置处理器postProcessAfterInitialization");
        return bean;
    }
}

②在IOC容器中配置后置处理器： 

<bean id="myBeanPostProcessor" class="com.tian.spring.process.MyBeanPostProcessor"></bean>

测试类：

public class LifeCycleTest {
    @Test
    public void test() {
        ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        User user = ioc.getBean(User.class);
        System.out.println(user);
        ioc.close();
    }
}

结果：

生命周期：1、创建对象
生命周期：2、依赖注入
MyBeanPostProcessor-->后置处理器postProcessBeforeInitialization
生命周期：3、初始化
MyBeanPostProcessor-->后置处理器postProcessAfterInitialization
User{id=1, username='admin', password='123456', age=23}
生命周期：4、销毁

结论：

1.实例化

2.依赖注入

3.后置处理器的postProcessBeforeInitialization

4.初始化，需要通过bean的init-method属性指定初始化的方法

5.后置处理器的postProcessAfterInitialization

6.IOC容器关闭时销毁 ，需要通过bean的destroy-method属性指定销毁的方法