JavaEE --- Bean 对象的生命周期和作用域

目录：

1. Bean 的作用域

• 1.1 观看案例
• 1.2 作用域的定义
• 1.3 Bean 的 6 种作用域
• 1.4 如何设置 Bean 的作用域
  • ①、@Scope(“prototype”
  • ②、@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE))
• 2. Bean 的生命周期
• 2.1 Bean 的执行流程
• 2.2 Bean 生命周期
• 2.3 生命周期演示代码
  • 主要代码
  • xml 的配置
  • 测试运行:
  • 查看结果:

---

1. Bean 的作用域

1.1 观看案例

现在有一个公共的 bean

 @Bean(name = "user1")
    public User user1(){
        User user = new User();
        user.setName("张三");
        user.setId(1);

        return user;
    }

用户 A 进行修改操作：（修改名字为悟空）

@Controller
public class UserControllerA {
    @Autowired
    @Qualifier(value = "user1")
    private User user;

    public User getUser(){
        user.setName("悟空");
        return user;
    }
}

用户 B 直接返回原始的 user 对象

package com.beans;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Lenovo
 * Date: 2022-07-08
 * Time: 16:09
 */
@Controller
public class ControllerB {
    @Autowired
    @Qualifier(value = "user1")
    private User user;

    public User getUser(){
        return user;
    }
}

打印用户1和用户2公共Bean的值

package com;

import com.beans.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.annotation.Resource;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Lenovo
 * Date: 2022-07-08
 * Time: 12:06
 */
public class App {

    public static void main(String[] args) {

//        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
//
//        User user = context.getBean(User.class);
//        UserController3 user = context.getBean(UserController3.class);
//        user.getUserInfo();
//        User user = context.getBean("zhangsan",User.class);

//        User user = context.getBean("user1",User.class);
//        UserController userController = context.getBean(UserController.class);
//        userController.sayHi();
//        UserController2 userController2 = context.getBean(UserController2.class);
//        userController2.sayHi();

        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        UserControllerA userControllerA = context.getBean(UserControllerA.class);
        ControllerB controllerB = context.getBean(ControllerB.class);

        System.out.println(userControllerA.getUser().getName());
        System.out.println(controllerB.getUser().getName());

    }
}

运行结果：

原因：

Spring 中 bean 对象默认的作用域是 singleton 单例模型，所有人使用的都是统一对象

1.2 作用域的定义

之前所说的作用域, 是在程序中定义的某个变量的某个区域就叫做作用域.这里的Bean作用域不同.

Bean 的作用域是指：Bean 在 Spring 框架中某种行为模式

1.3 Bean 的 6 种作用域

Spring 容器在初始化一个 Bean 的示例时, 同时会指定该实例的作用域.

Spring 有 6 种作用域:

• singleton: 单例作用域
• prototype: 原型作用域 (多例作用域)
• request: 请求作用域session: 回话作用域
• application: 全局作用域
• websocket: HTTP WebSocket 作用域

1.4 如何设置 Bean 的作用域

两种设置方法：

①、@Scope(“prototype”)

②、@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE

运行结果：

对象实例）

原因：

多例模型：每次对该作⽤域下的 Bean 的请求都会创建新的实例：获取Bean（即通applicationContext.getBean 等⽅法获取）及装配Bean（即通过@Autowired注⼊）都是新的对象实例

2. Bean 的生命周期

2.1 Bean 的执行流程

• 启动 spring 容器
• 加载 spring 配置文件
• 加载配置文件中的 bean ，或者根据配置文件中的根路径进行 Bean 对象扫描
• Bean 对象注册到 spring 中
• 执行完毕,执行销毁操作
  

2.2 Bean 生命周期

• 1、实例化 Bean（为 Bean 分配内存空间）
• 2、设置属性（Bean 的注入和装配）
• 3、Bean 的初始化

①.各种通知 Aware【BeanNameAware、BeanFactoryAware、ApplicationContextAware的接⼝⽅法】
②、执⾏ BeanPostProcessor 初始化前置⽅法
③、执⾏ @PostConstruct 初始化⽅法，依赖注⼊操作之后被执⾏
④、执⾏⾃⼰指定的 init-method ⽅法（如果有指定的话）
⑤、执⾏ BeanPostProcessor 初始化后置⽅法

• 4、使用 Bean
• 5、销毁 Bean

① 执行销毁前方法 @PreDestory
② 如果有接口 DisposableBean, 执行实现方法
③ 执行销毁前的方法 destory-method

2.3 生命周期演示代码

主要代码：

package com.wwzz.util;

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanLifeComponent implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("执行通知: BeanNameAware " + s);
    }
    @PostConstruct
    public void postConstruct(){
        System.out.println("执行 @PostConstruct");
    }
    public void init() {
        System.out.println("执行 init-method");
    }
    @PreDestroy
    public void preDestroy(){
        System.out.println("执行 @PreDestroy");
    }
    public void destroy() {
        System.out.println("执行 destroy");
    }
}

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"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置 Spring 扫描的根路径（此根路径下的所有 Spring 存对象的注解才能生效） -->
    <content:component-scan base-package="com.wwzz"></content:component-scan>

    <beans>
        <bean id="beanLifeComponent" class="com.wwzz.util.BeanLifeComponent" init-method="init" destroy-method="destroy"></bean>
    </beans>
</beans>

测试运行：

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        BeanLifeComponent beanLifeComponent = context.getBean("beanLifeComponent",BeanLifeComponent.class);
        context.destroy();
    }

运行结果