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

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

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

1. 初识Bean的作用域

• 所谓Bean的作用域 是Bean在spring框架中(或者项目中)的某种行为,这是专业术语.
• 其实我们从接触编程开始,我们就已经接触了作用域,全局变量和局部变量可以理解为不同的作用域.

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

1.1 使用Lombok

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

2. 引入Lombok的依赖.

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

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

3. 使用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();
    }
}

运行结果如下 :

简单分析 :

• 张三给对象赋初值,通过张三这个类,打印出来的还是张三.
• 把张三的类注入到李四里面,李四通过一个变量赋值张三的所有信息,然后修改名字为李四,打印的是李四,没有问题.
• 王五把张三这里类注入到自己这里,没做任何操作,但是结果是张三的信息.

总结 :

• 之所以会发生上面的情况,我们的Bean对象,默认情况下是单例模式,所有的人都会使用相同的对象,因此张三,李四,王五其实共有一个对象.
• 单例模式可以提高性能,因此spring的Bean对象作用域默认为单例模式,只是猜测官方这样设计哈.

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

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

2.1 Bean的常见作用域

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

1. singleton: 单例作用域
2. prototype: 原型作用域(多例作用域)
3. request: 请求作用域
4. session: 回话作用域
5. application: 全局作用域
6. 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 的作⽤域.

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

王五调用张三的实例,虽然李四在此之前已经把名字修改为李四了,但是王五调用的时候,又创建了新的实例,结果仍然是张三.

设置作用域的两种方式:

• 直接设置值：@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.

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

• 实例化和属性设置是 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();
    }

• 我们调用A,但是A注入了B的依赖,那么进入 B,B又注入了C的依赖.
• 然后反过来一次执行CBA,就像套娃的过程.