【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.-Toy模板网

这篇具有很好参考价值的文章主要介绍了【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言:
大家好,我是良辰丫,我们已经学会了Spring的存取,今天我们将一起来学习Bean对象的作用域和生命周期.💌💌💌

🧑个人主页：良辰针不戳
📖所属专栏：javaEE进阶篇之框架学习
🍎励志语句：生活也许会让我们遍体鳞伤，但最终这些伤口会成为我们一辈子的财富。
💦期待大家三连，关注，点赞，收藏。
💌作者能力有限，可能也会出错，欢迎大家指正。
💞愿与君为伴，共探Java汪洋大海。

1. 初识Bean的作用域

所谓Bean的作用域 是Bean在spring框架中(或者项目中)的某种行为,这是专业术语.

其实我们从接触编程开始,我们就已经接触了作用域,全局变量和局部变量可以理解为不同的作用域.

接下来,我们来看一个简单的例子,来看一下Bean对象作用域可能出现的问题,在此之前,我们先了解idea里面的一个插件Lombok.

1.1 使用Lombok

我们首先要去安装这个插件,点击File,进入设置settings,找到插件按钮plugins,进去搜索Lombok,然后进行安装.

【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.

引入Lombok的依赖.

进入maven中央仓库搜索Lombok,点击使用量最多的,复制依赖,引入到idea的pom.xml中.

【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
    <scope>provided</scope>
</dependency>

【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.

使用Lombok的注解.

Lombok里面有很多注解,后面会详细介绍,咱们先来简单介绍一个set和get的注解.

我们可以写两个注解@Setter和@Getter,这两个注解有什么用呢?如果我们类的属性有几百个呢?别说几百个,就是几十个,我们写set与get的代码也会看上去不舒服,那么这两个注解就可以很好的解决这个问题.这两个注解就是我们刚刚的Lombok引入的,只需要两行注解就可以实现get与set.
两行注解也不想写呢?我们可以使用@Data注解,这个注解包含许多注解的功能,目前不介绍,大家只需要知道这一个注解就包含set和get两个注解.而且还有一个好处,这个注解自带tostring方法.

import lombok.Data;
@Data
public class Student {
    private int id;
    private String name;
  }

1.2 Beqan作用域出现的问题

因为作用域会出现问题,我们才会进行研究它,那么我们先来看一个简单的例子吧.

代码如下,大家也可以去运行一下,观察结果.

package com.demo.Controller;
import lombok.Data;
@Data
public class User {
    private int id;
    private String name;
    private String password;
}

package com.demo.Controller;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
/**
 * 作者：张三
 */
@Component
public class UserBeans {
    @Bean
    public User user() {
        User user = new User();
        user.setId(1);
        user.setName("张三");
        user.setPassword("12345");
        return user;
    }
}

package com.demo.Controller;

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

/**
 * author:李四
 */
@Controller
public class UserController {

    @Autowired
    private User user;

    public void getUser() {
        System.out.println("张三 : " + user);
        User u = user;
        u.setName("李四");
        System.out.println("李四 : " + u);
    }

}

package com.demo.Controller;

import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

/**
 * author：王五
 */
@Controller
public class UserController2 {

    @Resource
    private User user;

    public void getUser() {
        System.out.println("王五 : " + user);
    }

}

import com.demo.Controller.UserController2;
import com.demo.Controller.UserController;
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.xml");
        UserController user1 = context.getBean("userController", UserController.class);
        user1.getUser();

        UserController2 user2 = context.getBean("userController2", UserController2.class);
        user2.getUser();
    }
}

运行结果如下 :

【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.

简单分析 :

张三给对象赋初值,通过张三这个类,打印出来的还是张三.

把张三的类注入到李四里面,李四通过一个变量赋值张三的所有信息,然后修改名字为李四,打印的是李四,没有问题.

王五把张三这里类注入到自己这里,没做任何操作,但是结果是张三的信息.

总结 :

之所以会发生上面的情况,我们的Bean对象,默认情况下是单例模式,所有的人都会使用相同的对象,因此张三,李四,王五其实共有一个对象.

单例模式可以提高性能,因此spring的Bean对象作用域默认为单例模式,只是猜测官方这样设计哈.

2. 进一步认识Bean的作用域

我们已经认识到程序中变量的可用范围叫做作用域,我们也可以理解为变量的使用范围.
上面已经介绍了官方概念,Bean的作用域是Bean在spring整个框架的某种行为模式.单例模式的作用域就是表示Bean对象在整个spring中只有一份,全局共享同一个对象.

2.1 Bean的常见作用域

我们经常使用的作用域有6种,我在使用Bean对象的时候,通常会指定作用域,前两种是我们这篇文章要讲的,后面四种是在Spring MVC中涉及.

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

2.1.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默认选择该作⽤域

2.1.2 prototype

官⽅说明：Scopes a single bean definition to any number of object instances.

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

场景：通常有状态的Bean使用该作用域.

2.1.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中使⽤

2.1.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实例

场景：⽤户回话的共享Bean, ⽐如：记录⼀个⽤户的登陆信息

备注：限定SpringMVC中使⽤

2.1.5 application（了解即可）

官⽅说明：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实例

场景：Web应⽤的上下⽂信息，⽐如：记录⼀个应⽤的共享信息

备注：限定SpringMVC中使⽤

2.1.6 websocket（了解即可）

官⽅说明：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.2 单例作⽤域(singleton) VS 全局作⽤域(application)

singleton 是 Spring Core 的作⽤域；application 是 Spring Web 中的作⽤域；
singleton 作⽤于 IoC 的容器，⽽ application 作⽤于 Servlet 容器。

2.3 给Bean设置作用域

使⽤ @Scope 标签就可以⽤来声明 Bean 的作⽤域.

【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.

那么,我们来看一下运行结果.

【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.
王五调用张三的实例,虽然李四在此之前已经把名字修改为李四了,但是王五调用的时候,又创建了新的实例,结果仍然是张三.

设置作用域的两种方式:

直接设置值：@Scope(“prototype”)

使⽤枚举设置(全局变量的方式)：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

3. spring的执行流程

启动容器,也就是启动项目.
加载配置文件,进行初始化.
①使用xml配置文件注册Bean.
②配置Bean对象的扫描路径.
将Bean存储到spring中,通过类注解进行扫描和装配.
@Controller
@Service
@Component
@Repository
将Bean对象从spring中取出来,装配到相应的类上.
@Autowired
@Resource

小结Bean 执⾏流程（Spring 执⾏流程）：

启动 Spring 容器

实例化 Bean（分配内存空间，从⽆到有）

Bean 注册到 Spring 中（存操作）

将 Bean 装配到需要的类中（取操作)。

4. Bean对象的生命周期

4.1 描述Bean对象的生命周期

⽣命周期指的是⼀个对象从诞⽣到销毁的整个⽣命过程，我们把这个过程就叫做⼀个对象的⽣命周期.

实例化Bean对象(对应JVM中的加载,从无到有,将字节码转换成内存中的对象,只是分配了内存).比喻成买了一个空壳房子.

设置属性(Bean对象的注入和装配).购买装修材料.

Bean的初始化.房子进行装修.
实现了各种Aware通知的方法.
初始化的前置工作.
执行@PostConstruct初始化方法,依赖注入操作之后被执行.
执行自己指定的init-method方法
执行BeanPostProcessor初始化的后置方法.

使用Bean.

销毁Bean.

【Spring学习】Bean对象的作用域和生命周期,了解了这些你就真正熟悉spring框架了.

实例化和初始化有什么区别呢?

实例化和属性设置是 Java 级别的系统“事件”，其操作过程不可⼈⼯⼲预和修改；

⽽初始化是给开发者提供的，可以在实例化之后，类加载完成之前进⾏⾃定义“事件”处理。

为什么先设置属性再进行初始化呢?
就像房子,我们有了装修材料才能进行装修,这也是一样,类比一下,有了属性才能进行初始化,什么属性都没有,给谁进行初始化呢?

4.2 例子来加深认识

下面的例子是为了证明先注入依赖,然后再进行初始化.

package com.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@Service
public class AService {

    @Autowired
    private BService bComponent; 

    @PostConstruct
    public void postConstruct() {
        //bComponent.sayHi(); // 先 ① 再 ② 不会有问题，但如果先 ② 再 ① 就会空指针报错
        System.out.println("执行了 A 对象的 PostConstruct 方法");
    }

}

package com.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@Service
public class BService {

    @Autowired
    private CService component;

    @PostConstruct
    public void postConstruct() {
        System.out.println("执行了 B 对象的 PostConstruct 方法");
    }

    public void sayHi() {
        System.out.println("hi,BComponent~");
    }

}

package com.demo.service;

import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@Service
public class CService {
    @PostConstruct
    public void postConstruct() {

        System.out.println("执行了 C 对象的 PostConstruct 方法");
    }
}

 public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring.xml");
        AService aService = context.getBean("AService",AService.class);
        //aService.postConstruct();
    }