Bean作用域和生命周期

hi,今天为大家带啦Bean的作用域和生命周期的相关知识

💚1.Bean 的作用域

🧊1.1Bean的作用域的定义

Bean的作用域和我们之前学过的不一样,我们之前学的作用域是一个范围,而现在指的是 Bean在Spring框架中的某种行为模式,也就是一个动作.
这样干巴巴的说看我可能无法理解,我们来举个例子

🧊1.2代码理解Bean的作用域

创建一个公共类的一个公共对象,两个人各自调用这个方法

package com.java.demo.model;

import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 小魏
 * Date: 2023-07-29
 * Time: 10:17
 */

/**
 * Users是公共类
 */
@Component
public class Users {
    /**
     * Bean对象是公共对象,默认是单例模式
     * @return
     */
    @Bean("user")
    public User getUser(){
        User user=new User();
        user.setId(1);
        user.setName("lisi");
        return user;
    }
}

用户1

package com.java.demo.controller;

import com.java.demo.model.User;
import com.java.demo.model.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: zh
 * Date: 2023-07-29
 * Time: 10:22
 */
@Controller
public class UserController2 {
    @Autowired
    private User user;
    public void sayHi(){
    User user2=user;
        System.out.println("User"+user2);
    user2.setName("王一博");

        System.out.println("User"+user2);
    }

}

用户2

package com.java.demo.controller;

import com.java.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: WHY
 * Date: 2023-07-29
 * Time: 10:26
 */
@Controller
public class UserController3 {
    @Autowired
    private User user;
    public void sayhi(){
        System.out.println("User"+user);
    }

}

我们的用户WHY只想单纯的调用公共对象并打印,但是结果变成了用户zh修改以后的代码,这是为啥呢?
因为Bean对象在Spring框架里面就是默认是单例模式的,也就是一份代码里就一个对象,是公共的,一旦有人修改,拿到的数据就是修改以后的

这里定义了一个user2对象指向user对象,所以在后面的修改中,改变了user2也就是改变了user,也就是我们之前学过的浅克隆
那么怎么解决这个问题呢?,采用@Scope注解,Scope就是作用域的意思

prototype代表原型模式,又称多例模式,每次用注解请求bean对象的时候都再次new一个原来的对象
总结一下:Bean的作用域就是Bean在spring容器中的某种行为(比如单例,原型)单例情况下只有一份,修改以后其他人拿到的就是修改后的,加上scope注解,每次都会new一个原来的对象

🧊1.3Bean的六种作用域

🍉1.3.1 singleton:单例作用域

官方说明:(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对象的属性状态不需要更新
这个是Spring默认的模式,那么单例模式的Bean是线程安全的吗?
不是,我们可以采用ThreadLocal(本地线程变量)
回忆一下,保证线程安全的方法:
1.使用线程安全的容器2.使用锁.例如synchronized,Lock 3使用ThreadLocal

🍉1.3.2 pprototype:原型作用域

官⽅说明：Scopes a single bean definition to any number of object instances.
描述：每次对该作⽤域下的Bean的请求都会创建新的实例：获取Bean（即通过
applicationContext.getBean等⽅法获取）及装配Bean（即通过@Autowired注⼊）都是新的对象
实例。
场景：通常有状态的Bean使⽤该作⽤域

🍉1.3.3 request:请求作用域

官⽅说明：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 bean
definition. Only valid in the context of a web-aware Spring ApplicationContext.
描述：每次http请求会创建新的Bean实例，类似于prototype
场景：⼀次http的请求和响应的共享Bean
限定SpringMVC中使⽤

🍉1.3.4 session:会话作用域

官⽅说明：Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in
the context of a web-aware Spring ApplicationContext.
描述：在⼀个http session中，定义⼀个Bean实例,一个http共享一个Bean
场景：⽤户回话的共享Bean, ⽐如：记录⼀个⽤户的登陆信息
限定SpringMVC中使⽤

🍉1.3.5application作用域

官⽅说明：Scopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.
描述：在⼀个http servlet Context中，定义⼀个Bean实例.一个context容器共享一个作用域
场景：Web应⽤的上下⽂信息，⽐如：记录⼀个应⽤的共享信息
限定SpringMVC中使⽤

🍉1.3.6websocket作用域

官⽅说明：Scopes a single bean definition to the lifecycle of a WebSocket. Only valid in the
context of a web-aware Spring ApplicationContext.
描述：在⼀个HTTP WebSocket的⽣命周期中，定义⼀个Bean实例
场景：WebSocket的每次会话中，保存了⼀个Map结构的头信息，将⽤来包裹客户端消息头。第⼀
次初始化后，直到WebSocket结束都是同⼀个Bean。
限定Spring WebSocket中使⽤

💚2.设置作用域

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

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

🧊单例作⽤域(singleton) VS 全局作⽤域(application)

1.singleton是spring core的作用域,application是Spring web的作用域
2.singleon作用于IOC的容器,application作用于Servlet容器
3.singleton是在一个IOC容器里使用,application是有多个servlet容器里面使用,每个容器都有每个的bean对象

💚3.Spring执行流程和Bean的生命周期

🧊3.1Spring执行流程

1.配置文件加载：Spring启动时，会根据配置文件加载信息，读取XML、注解或Java配置文件中的Bean定义，将其转换为内部的BeanDefinition对象，并放入BeanFactory中。
2.Bean 实例化：当BeanFactory初始化完成后，Spring会根据Bean定义中的配置信息，实例化Bean对象，并将其保存在BeanFactory中。
3.Bean 属性注入：Spring容器会查找所有Bean的属性，查找其是否配置了需要注入的依赖项，如果有，则将依赖项注入到当前Bean中。

4.Bean 初始化：Spring容器会执行定义在Bean上的初始化方法，这些方法可以使用注解或XML配置指定。

5.容器初始化完成：所有Bean初始化完成后，Spring容器会广播一个容器初始化完成事件，通知所有的监听器。

6.应用程序使用：应用程序可以使用Spring容器中的Bean来处理请求或执行任务。

7.Bean销毁：当应用程序关闭时，Spring容器会调用所有Bean的销毁方法，它们可以使用注解或XML配置指定，来清理任何资源，并释放系统资源。

🧊3.2Bean生命周期

拿房子举例🐶
1.实例化(分配内存)[买房,划地]
2.设置Bean属性(DI,将依赖的Bean赋值到当前类的属性上)[需要钢筋水泥工人建房子]
3.Bean的初始化[装修]
3.1执行各种通知,实现了各种 Aware 通知的⽅法，比如BeanNameAwareBeanFactoryAware
3.2初始化的前置方法
3.3@PostConstruct 初始化方法,依赖注入操作之后被执行
3.4执行自己指定的init-method方法(没有就不执行)
3.5初始化的后置方法
4.使用Bean [入住]
5.销毁Bean[房子过期拆房]
执行流程图

说到这里,我们来回忆一下初始化实例化的相关知识
初始化是指创建对象时为对象的属性或变量赋初值。在程序中，通常使用构造函数来完成初始化工作。

实例化是指创建一个类的具体实例（对象）的过程。当类定义完成后，通过使用类来创建对象。

因此，可以说实例化之前需要先进行初始化，而实例化本身是创建对象的过程。

🧊3.3生命周期演示

import org.springframework.beans.factory.BeanNameAware;

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: WHY
 * Date: 2023-07-29
 * Time: 17:49
 */
public class BeanLifeComponent implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了BeanMNameAware->"+s);//s就是通知的名字,表明给bean起好了名字
    }
    //使用当前注解表示在这个类里面可以实现初始化方法,
    @PostConstruct
    public void doPostConstruct(){
        System.out.println("执行了PostConstruct");
    }
    //使用xml形式也实现了初始化方法
        public void init(){
            System.out.println("执行了init方法");
        }

//销毁bean 1.使用xml形式
    public void destroy(){
        System.out.println("执行了destroy方法");
    }
    //2.使用注解销毁bean
    @PreDestroy
    public void doDestroy(){
        System.out.println("执行了PreDestroy");
    }
    public void sayhi(){
        System.out.println("执行sayhi");
    }

}

这里就是使用xml形式进行注入方法

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: WHY
 * Date: 2023-07-29
 * Time: 18:09
 */
public class BeanLifeTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context=
                new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeComponent beanLifeComponent=context.getBean("mybean",BeanLifeComponent.class);
        beanLifeComponent.sayhi();
        context.close();

    }
}

注意,使用的是ClassPathXmlApplicationContext方法,因为这个子类方法有销毁方法,Application方法没有销毁方法

🧊3.4为什么属性设置要在初始化之前呢?

举个例子

这时注入了一个类属性,我有可能会在初始化方法里面调用这个属性的方法,所以当我先设置属性,后面调用的时候就不会报错,如果先初始化后设置属性,一定会报错

今天的讲解就到这里吧,我们下期再见咯