Java EE 突击 6 - Bean 作用域和生命周期

最新推荐文章于 2024-09-01 20:08:06 发布

加勒比海涛

最新推荐文章于 2024-09-01 20:08:06 发布

阅读量618

点赞数

分类专栏： JavaEE 新手入门文章标签： java-ee java

本文链接：https://blog.csdn.net/m0_53117341/article/details/132054010

版权

JavaEE 新手入门专栏收录该内容

15 篇文章 2 订阅

订阅专栏

本文详细介绍了Spring框架中的Bean作用域，包括单例和多例模式的区别，以及Spring执行流程与Bean的生命周期。通过实例分析了如何在SpringMVC项目中设置和使用不同作用域的Bean，以及为何先设置属性再进行初始化的重要性。

摘要由CSDN通过智能技术生成

这个专栏给大家介绍一下 Java 家族的核心产品 - SSM 框架
JavaEE 进阶专栏

Java 语言能走到现在 , 仍然屹立不衰的原因 , 有一部分就是因为 SSM 框架的存在

接下来 , 博主会带大家了解一下 Spring、Spring Boot、Spring MVC、MyBatis 相关知识点

并且带领大家进行环境的配置 , 让大家真正用好框架、学懂框架

来上一篇文章复习一下吧
点击即可跳转到我的小秘密

在好久好久之前的学习中 , 我们了解过作用域这个概念 .
作用域（scope）是程序设计概念，通常来说 , 一段程序代码中所用到的名字并不总是有效/可用的 , 而限定这个名字的可用性的代码范围就是这个名字的作用域。

局部变量的作用域是变量所在的局部范围。
全局变量的作用域是整个工程。

比如这段代码

public class Main {
    private int c = 0;// c 可以在整个类当中使用
    public void test() {
        int a = 0;// a 只能在这个函数里面使用
    }

    public static void main(String[] args) {
        int b = 0;// b 可以在 main 方法里面使用
    }
}

如果还记得这个概念的话 , 那么接下来就都好说了

一 . 通过一个案例来看 Bean 作用域的问题

假设张三开发出了一个公共的 Bean 叫做 “张三” , 提供给李四和王五使用 , 但是在使用的过程中 , 李四不小心的把 “张三” 改成了 “李四” , 这个时候王五在使用的时候还按照 “张三” 去使用 , 就会出现问题 .
那么大家可能感觉不知所云 , 就举个栗子吧 .
我们创建一个 model 类 , 在里面创建一个 Dog 类 , 有他的编号、姓名、年龄

package model;

public class Dog {
    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Dog{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

然后我们在 Controller 包底下去创建一个类 : DogBean
这个类就是张三开发出的公共模块 , 用来给李四和王五使用的

package controller;

import model.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class DogBean {
    @Bean
    public Dog dog() {
        Dog dog = new Dog();
        dog.setId(1);
        dog.setName("大黑");
        dog.setAge(1);
        return dog;
    }
}

李四和王五就可以调用这段代码
这时候李四就去使用他了
创建一个类 : ScopeController.java

package controller;

import model.Dog;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class ScopeController {

    @Autowired
    private Dog dog;//这里我们为什么去使用属性注入呢?因为方便

    public void doScope() {
        System.out.println("Do scope controller.");
        System.out.println("原数据:" + dog);
        // 这是李四写的代码
        // 但是他进行了一些修改
        Dog dog2 = dog;// 他为了不影响之前的dog,自己新建一个dog
        dog2.setName("旺旺");
        System.out.println("修改之后的数据" + dog2);
    }
}

李四是这样想的 , 我自己新创建一个 dog , 然后针对自己的 dog 去修改 , 不改变张三的 dog
然后王五开始写代码了 : ScopeController2.java

package controller;

import model.Dog;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

@Controller
public class ScopeController2 {
    @Resource
    private Dog dog;

    public void doSCope() {
        System.out.println("Do SCope controller 2.");
        System.out.println(dog);
    }
}

然后我们在启动类运行一下

import com.ethan.controller.ScopeController;
import com.ethan.controller.ScopeController2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        ScopeController scopeController = context.getBean("scopeController", ScopeController.class);
        scopeController.doScope();

        System.out.println("----------------------------------------------------------------");

        ScopeController2 scopeController2 = context.getBean("scopeController2", ScopeController2.class);
        scopeController2.doScope2();
    }
}

这是为什么呢 ?
这要追溯到我们之前学习的基础类型和引用类型的知识了

这是因为我们 Spring 是单例模式 , 默认情况下 , dog 只有一份 , 我们会先去 Spring 里面拿 dog , 所以拿到的都是一个 dog , 获取到的也就是一个对象 , 就导致了这个问题 .

二 . 作用域定义

Bean 的作用域是指 Bean 对象在整个 Spring 中的某种行为模式
比如单例作用域，就表示 Bean 在整个 Spring 框架中只有⼀份，它是全局共享的，那么当其他⼈修改了这个值之后，那么另⼀个人读取到的就是被修改的值。

2.1 Bean 的 6 种作用域

singleton : 单例作用域(默认作用域)

Spring 默认的是单例作用域 , 因为它只存在一份 , 性能比较高 , 消耗的资源比较少 , 糟糕的问题就是当有一个人修改之后 , 其他人拿到的也就是被修改的作用域

prototype : 原型作用域(多例作用域)

request : 请求作用域
session : 会话作用域
application : 全局作用域
websocket : HTTP WebSocket 作用域

ps. 下面这 4 个是 Spring MVC 里面的作用域 , 在普通的 Spring 项目 (Spring FrameWork Core) 里面只有前两种

sigleton : 单例模式[默认的作用域]

官方说明 : (Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
描述 : 该作用域下的 Bean 在 IoC 容器中只存在⼀个实例：获取 Bean(即通过applicationContext.getBean等方法获取) 及装配 Bean (即通过 @Autowired 注入) 都是同⼀个对象。
场景 : 通常无状态的 Bean 使用该作用域。无状态表示 Bean 对象的属性状态不需要更新(不需要进行修改的 Bean)
备注 : Spring 默认选择该作用域

prototype : 原型模式

原来的形状的模式 , 原来是什么样我们就给你什么样 , 那怎么才能保证原型模式呢 ?
那就每一次使用都复制一份 , 他的模板是不变的 , 然后有人需要的话就复制一份一模一样的给你

描述 : 每次对该作用域下的 Bean 的请求都会创建新的实例 : 获取 Bean (即通过applicationContext.getBean 等方法获取) 及装配 Bean (即通过 @Autowired 注入) 都是新的对象实例。

这里怎么没说可以去从 @Resource 获取呢 ?
这是因为我们的 Spring 公司是不会去推销别人家的东西的 , @Resource 是 Java 的 , 我为什么要帮他打广告 , 但是其实 @Resource 是可以使用的

场景 : 通常有状态的 Bean 使用该作用域(有状态 : 总去修改的 Bean)

request : 请求作用域[只能在 Spring MVC 里面使用]

在这里 , request 表示请求作用域 , 而不是在 Servlet 里面的请求对象

官方说明 : Scopes a single bean definition to the lifecycle of a single HTTP request. That is,each HTTP request has its own instance of a bean created off the back of a single beandefinition. Only valid in the context of a web-aware Spring ApplicationContext.
描述 : 每次 http 请求会创建新的 Bean 实例 , 类似于 prototype

prototype 每次访问都会创建一个新对象 , 比如 : 每次类里面添加了 @Autowired , 就会新建一个对象
Request 而是每一次 HTTP 请求 , 就会创建一个 Bean 对象

场景 : ⼀次 HTTP 的请求和响应的共享 Bean
备注 : 限定 SpringMVC 中使用

session : 会话作用域[只能在 Spring MVC 里面使用]

官方说明 : Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid inthe context of a web-aware Spring ApplicationContext.
描述 : 在⼀个 HTTP session 中，定义⼀个 Bean 实例

登陆成功 , 是一次会话 , 在这一次会话里面 , 任何地方使用了这个对象 , 都是一个 Bean 对象
退出登录再登陆之后 , 又是一个新的 session 了
每次 (session) 会话使用一个 bean 对象

场景 : 用户会话的共享 Bean, 比如 : 记录⼀个用户的登陆信息
备注 : 限定 SpringMVC 中使用

application : 全局作用域[只能在 Spring MVC 里面使用]

一个 HTTP Servlet context 中共享一个对象

websocket : HTTP WebSocket 作用域[只能在 WebSocket 程序中使用]

WebSocket 是什么 ?
现在其实这个技术有点不常见了 , 但是在日常生活中应用还是比较广泛的 , 比如网页聊天室 , 比如 : 某个网站上有在线客服 , 你们可以在线解决问题 . 还比如网页游戏等等
它的底层协议是 TCP/UDP
他是和 HTTP 协议同一级别的应用层的协议

我们只需要重点记住前四个即可

单例作用域 (singleton) VS 全局作用域 (application)

singleton 是 Spring Core 的作用域 ; application 是 Spring Web 中的作用域；
singleton 作用于 IoC 的容器，而 application 作用于 Servlet 容器。

2.2 设置作用域

使用 @Scope 标签就可以用来声明 Bean 的作用域，比如设置 Bean 的作用域

把它放到你要存储的对象的上边

@Scope 标签既可以修饰方法也可以修饰类，@Scope 有两种设置方式：

直接设置值：@Scope(“prototype”)
使用枚举设置：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

来看之前的例子

package controller;

import model.Dog;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
public class DogBean {
    // 写法一
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    // @Scope(ConfigurableListableBeanFactory.SCOPE_PROTOTYPE) //这种写法也是可以的
    // 写法二
    // @Scope("prototype")
    @Bean
    public Dog dog() {
        Dog dog = new Dog();
        dog.setId(1);
        dog.setName("大黑");
        dog.setAge(1);
        return dog;
    }
}

然后运行一下

说明现在就是多例的模式
那我们再使用写法二来看一下

也成功了
但是我们还是推荐写法1 这种方法 , 因为它可以进行代码提示 , 我们不容易出错

三 . Spring 执行流程与生命周期

3.1 Spring 主要的执行流程

3.2 Bean 生命周期

实例化 Bean (为 Bean 分配内存空间)

不等于初始化
实例化就是分配内存空间
比如 : 我们想要在一个城市安身立业 , 咱们的传统就是得先有个家才算安身了 , 那么实例化就是在这个地方买个房子 , 但是现在这个叫家吗 ? 显然不是 , 我们还需要装修买家具等等

设置属性 (Bean 注入和装配)
Bean 初始化
1. 实现了各种 Aware 通知的方法，如 BeanNameAware、BeanFactoryAware、ApplicationContextAware 的接口方法；

加入我们现在有个 Bean , Bean 是有自己的名称的 , 我给这个 Bean 起名 , 这是一个事件 , 然后我给这个 Bean 设置好名字之后就会有一个通知 , 叫做 BeanNameAware

设置属性[依赖注入-DI]
初始化
1. 执行各种通知
2. 初始化的前置方法

通过 spring-config.xml 里面定义 init-mtehod
也可以通过 @PostConstruct 注解

  3. 初始化方法
  4. 初始化的后置方法

使用 Bean
销毁 Bean

销毁容器的各种方法，如 @PreDestroy、DisposableBean 接口方法、destroy-method

大致步骤也在图片里面画了

生命周期的演示

我们在 Controller 里面创建一个类 , 叫做 BeanLifeComponent (Bean 的一生)
然后先把注解加上

package controller;

import org.springframework.stereotype.Component;

@Component
public class BeanLifeComponent {
    
}

接下来 , 先写通知 , 我们就需要实现 BeanNameAware , 然后重写他的通知方法

package controller;

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

@Component
public class BeanLifeComponent implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了 Bean Name 的通知:" + s);
    }
}

然后我们在写一个方法
(我们为了测试 xml 时代的写法 , 就先把 @Component 注解去掉)

package controller;

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

//@Component
public class BeanLifeComponent implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了 Bean Name 的通知:" + s);
    }

    /**
     * 方法名随便定义
     * 在 xml 中 init-method 指定的方法
     */
    public void initMethod() {
        System.out.println("执行了 init method 方法");
    }
}

接下来我们在 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">
    <content:component-scan base-package="controller"></content:component-scan>
    
    <bean id="beanlife" class="controller.BeanLifeComponent" init-method="initMethod"></bean>
</beans>

然后接下来 , 我们编写初始化的代码 , 在上面加一个注解 : @PostConstruct

package controller;

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

import javax.annotation.PostConstruct;

//@Component
public class BeanLifeComponent implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了 Bean Name 的通知:" + s);
    }

    /**
     * 方法名随便定义
     * 在 xml 中 init-method 指定的方法
     */
    public void initMethod() {
        System.out.println("执行了 init method 方法");
    }

    /**
     * 方法名随便定义
     * 尽量要符合规范
     */
    @PostConstruct
    public void myPostConstruct() {
        System.out.println("执行了 PostConstruct 方法");
    }
}

然后执行销毁方法

package controller;

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("执行了 Bean Name 的通知:" + s);
    }

    /**
     * 方法名随便定义
     * 在 xml 中 init-method 指定的方法
     */
    public void initMethod() {
        System.out.println("执行了 init method 方法");
    }

    /**
     * 方法名随便定义
     * 尽量要符合规范
     */
    @PostConstruct
    public void myPostConstruct() {
        System.out.println("执行了 PostConstruct 方法");
    }

    @PreDestroy
    public void myPreDestroy() {
        System.out.println("执行了 PreDestroy 方法");
    }
}

最后我们再写一个普通方法来进行测试

package controller;

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("执行了 Bean Name 的通知:" + s);
    }

    /**
     * 方法名随便定义
     * 在 xml 中 init-method 指定的方法
     */
    public void initMethod() {
        System.out.println("执行了 init method 方法");
    }

    /**
     * 方法名随便定义
     * 尽量要符合规范
     */
    @PostConstruct
    public void myPostConstruct() {
        System.out.println("执行了 PostConstruct 方法");
    }

    /**
     * 销毁前执行方法
     */
    @PreDestroy
    public void myPreDestroy() {
        System.out.println("执行了 PreDestroy 方法");
    }

    public void use() {
        System.out.println("执行了 use 方法");
    }

}

但是这个写法和之前的写法就不太一样了
如果我们要去销毁他 , 就必须调用他的 myPreDestroy 方法 , 但是我们还不能使用 ApplicationContext , 因为 ApplicationContext 没有销毁方法 , 所以咱们就使用 ClassPathXmlApplicationContext 方法定义上下文对象 , 才有 myPreDestroy 方法

import controller.BeanLifeComponent;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeComponent component = context.getBean("beanlife",BeanLifeComponent.class);
        component.use();
        // 关闭容器
        context.destroy();
    }
}

运行一下

我们来分析一下

接下来 , 我再实现一个构造方法 , 来看一下效果

package com.ethan.controller;

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.annotation.Autowired;
import com.ethan.service.UserService;

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

//@Component
public class BeanLifeComponent implements BeanNameAware {

    @Override
    public void setBeanName(String s) {
        System.out.println("执行了 Bean Name 的通知:" + s);
    }

    /**
     * 方法名随便定义
     * 在 xml 中 init-method 指定的方法
     */
    public void initMethod() {
        System.out.println("执行了 init method 方法");
    }

    /**
     * 方法名随便定义
     * 尽量要符合规范
     */
    @PostConstruct
    public void myPostConstruct() {
        System.out.println("执行了 PostConstruct 方法");
    }

    /**
     * 销毁前执行方法
     */
    @PreDestroy
    public void myPreDestroy() {
        System.out.println("执行了 PreDestroy 方法");
    }

    public void use() {
        System.out.println("执行了 use 方法");
    }

    public BeanLifeComponent() {
        System.out.println("BeanLifeComponent 的构造方法");
    }

}

构造方法是最先执行的 , 这是因为构造方法是我们 JDK 的 , 在 JDK 中构造方法优先执行 , 我们的 Spring 也是要遵循 JDK 的
接下来我们新建一个 service 包 , 底下新建一个类 , 叫做 UserService
然后编写以下代码

package com.ethan.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public UserService() {
        System.out.println("UserService 的构造方法");
    }
    public void doService() {
        System.out.println("doService()");
    }
}

接下来在我们的 BeanLifeComponent 类里面添加 @Autowired 注解

package com.ethan.controller;

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.annotation.Autowired;
import com.ethan.service.UserService;

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

//@Component
public class BeanLifeComponent implements BeanNameAware {

    @Autowired
    private UserService userService;
    
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了 Bean Name 的通知:" + s);
    }

    /**
     * 方法名随便定义
     * 在 xml 中 init-method 指定的方法
     */
    public void initMethod() {
        System.out.println("执行了 init method 方法");
    }

    /**
     * 方法名随便定义
     * 尽量要符合规范
     */
    @PostConstruct
    public void myPostConstruct() {
        System.out.println("执行了 PostConstruct 方法");
    }

    /**
     * 销毁前执行方法
     */
    @PreDestroy
    public void myPreDestroy() {
        System.out.println("执行了 PreDestroy 方法");
    }

    public void use() {
        System.out.println("执行了 use 方法");
    }

    public BeanLifeComponent() {
        System.out.println("BeanLifeComponent 的构造方法");
    }

}

运行一下

为什么会执行我们的 UserService 的构造方法呢 ?
这是因为我们引入了 Userservice 对象 , 里面有他的构造方法 .
那么这两个构造方法的先后顺序都比较特殊 , 他们都来自于 JDK , 先加载那个类是不一定的 , 所以先打印谁后打印谁都是不一定的 .

生命周期的故事

先买房 (实例化 , 从无到有)
装修 (设置属性)
买家电 ([各种]初始化)
入住 (使用 Bean)
不想住然后卖出去 (Bean 销毁)

思考：为什么要先设置属性在进行初始化呢？

在初始化的过程中 , 有很多个方法 , 在这些方法中 , 有可能会调用属性里面的某个对象里面的某个方法 , 而如果先初始化再设置属性的话 , 调用的时候就会报空指针异常
举个栗子 :

所以我们会先进行对象注入 , 防止以后需要使用对象的时候会报错

加勒比海涛

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java EE 突击 6 - Bean 作用域和生命周期

Bean 的作用域是指 Bean 对象在整个 Spring 中的某种行为模式比如单例作用域，就表示 Bean 在整个 Spring 框架中只有⼀份，它是全局共享的，那么当其他⼈修改了这个值之后，那么另⼀个人读取到的就是被修改的值。
复制链接

扫一扫