💚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为什么属性设置要在初始化之前呢?

举个例子

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

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