Spring（二）Bean的作用域与生命周期

概论

假设现在有⼀个公共的 Bean，提供给 A ⽤户和 B ⽤户使⽤，然⽽在使⽤的途中 A ⽤户却“悄悄”地修改了公共 Bean 的数据，导致 B 用户在使⽤时发⽣了预期之外的逻辑错误。

我们预期的结果是，公共 Bean 可以在各⾃的类中被修改，但不能影响到其他类，实际并不是。

因为进行了浅拷贝，如果是深拷贝就不存在这个问题。更主要的原因是Bean对象默认是单例模式。在程序运行中这个对象只有一个。

解决？使用@Scope

我们对他的范围进行设置。及作用域：Bean 的作⽤域是指 Bean 在 Spring 整个框架中的某种⾏为模式（单例、原型…）。Spring有 6 种作⽤域，最后四种是基于 Spring MVC ⽣效的：

1. singleton：单例作⽤域（单例）（线程并不安全）

该作⽤域下的Bean在IoC容器中只存在⼀个实例：获取Bean（即通过applicationContext.getBean等⽅法获取）及装配Bean（即通过@Autowired注⼊）都是同⼀个对
象。通常⽆状态的Bean使⽤该作⽤域

@Component
public class User2 {

    /*公共对象
    * */
    @Bean("user")

    public User getUser(){
        User user=new User();
        user.setName("666");
        return user;
    }
}

2. prototype：原型作⽤域（多例作⽤域）(原型)

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

@Component
public class User2 {

    /*公共对象
    * */
    @Bean("user")
    @Scope("prototype")
    public User getUser(){
        User user=new User();
        user.setName("666");
        return user;
    }
}

4. request：请求作⽤域

每次http请求会创建新的Bean实例，类似于prototype，⼀次http的请求和响应的共享Bean

6. session：回话作⽤域

在⼀个http session中，定义⼀个Bean实例，⽤户回话的共享Bean，**Http会话共享一个bean。**⽐如：记录⼀个⽤户的登陆信息

6. application：全局作⽤域

在⼀个http servlet Context中，定义⼀个Bean实例，Web应⽤的上下⽂信息，**一个Context容器共享一个作用域，**⽐如：记录⼀个应⽤的共享信息

7. websocket：HTTP WebSocket 作⽤域

在⼀个HTTP WebSocket的⽣命周期中，定义⼀个Bean实例，WebSocket的每次会话中，保存了⼀个Map结构的头信息，将⽤来包裹客户端消息头。第⼀次初始化后，直到WebSocket结束都是同⼀个Bean。webscoket作用域。只适用于websoket作用域。

• singleton作用于一个IoC容器，而Application是对不同的IoC容器产生作用。
• singleton 是 Spring Core 的作⽤域，application 是 Spring Web 中的作⽤域

设置Bean的作用域

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

@Component
public class User2 {

    /*公共对象
    * */
    @Bean("user")
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public User getUser(){
        User user=new User();
        user.setName("666");
        return user;
    }
}

Spring的执行流程

1.启动容器
加载配置文件。（xml文件）

ApplicationContext context=new ClassPathXmlApplicationContext(“spring-config.xml”);

2.根据配置完成bean的初始化
扫描com.xie.demo下的Spring注解
@Controller，@Servie，@Component，@Repository，@Configuration

<content:component-scan base-package=“com.xie.demo”></content:component-scan>

3.将Bean对象存放到容器中
如果Bean对象需要适用其他Bean对象作为属性，可以使用注解，@Autowired，@Resource

@Autowired//DI 依赖注入
private UserRepository userRepository;

@Service
public class UserService {
    @Autowired//DI 依赖注入
    private  UserRepository userRepository;
    public User getUser(){
        return userRepository.getUser();
    }
}

4.装配Bean的属性
给当前类的属性DI，进行赋值。

Bean 执⾏流程（Spring 执⾏流程）：启动 Spring 容器 --> 实例化 Bean（分配内存空间，从⽆到有）–> Bean 注册到 Spring 中（存操作）–> 将 Bean 装配到需要的类中（取操作)。

Bean的生命周期

Bean 的⽣命周期分为以下 5 ⼤部分：
1.实例化（为Bean分配内存空间）
2.设置属性（依赖注入，将依赖的Bean赋值到当前类的属性上）
3.Bean初始化

• 3.1执行各种通知 ，Aware 通知：如BeanNameAware；
• 3.2初始化的前置方法，执⾏ BeanPostProcessor 初始化前置⽅法
• 3.3执⾏ @PostConstruct 初始化⽅法，依赖注⼊操作之后被执⾏（执⾏⾃⼰指定的 init-method ⽅法（如果有指定的话））
• 3.4初始化的后置方法，执⾏ BeanPostProcessor 初始化后置⽅法

4.使用Bean
5.销毁Bean
销毁容器的各种⽅法，如 @PreDestroy、DisposableBean 接⼝⽅法、destroy-method。

<?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="com.xie.demo"></content:component-scan>

<!--        <bean id="user" class="com.xie.demo.Megger"></bean>-->
        <bean id="myinti" class="com.xie.demo.com.BeanLifeCompontent" init-method="myinti"></bean>

</beans>

public class BeanLifeCompontent implements BeanNameAware
{
	//通知
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了 BeanNameAware->"+s);
    }

    //jdk5之后的初始化方法
    @PostConstruct
    public void doPostConstruct(){
        System.out.println("执行了@PostConstruct");
    }
    //jdk5之前的初始化方法
    public void myinti(){
        System.out.println("执行了 myinti");
    }


	//销毁
    @PreDestroy
    public  void doPreDestroy(){
        System.out.println("执行了@PreDestroy");
    }

    public void sayHi(){
        System.out.println("使用Bean");
    }
}

public class BeanLifeTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context=
                new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeCompontent beanLifeCompontent=
                context.getBean("myinti",BeanLifeCompontent.class);
        beanLifeCompontent.sayHi();
        context.close();

    }
}

实例化和属性设置是 Java 级别的系统“事件”，其操作过程不可⼈⼯⼲预和修改；⽽初始化是给开发者提供的，可以在实例化之后，类加载完成之前进⾏⾃定义“事件”处理。

为什么要先设置属性在进⾏初始化呢？其原因在于，后面在调用属性的时候，就意味着必须先进行属性设置。