1 Bean 的作用域

指定程序中某个变量的使用范围就叫做作用域。而 Bean 的作用域指的是 Bean 在 Spring 整个框架的行为模式。比如单例模式，就意味着 Bean 在整个 Spring 中只有一份，为全局共享的，如果有人修改这个值，那么另一个人拿到的，就是被修改过后的值。

1.1 singleton：单例模式

该作用域下的 Bean 在 IoC 容器中只存在一个实例，所以获取 Bean 或者注入 Bean(通过 @Autowired 注入)都是同一个对象

package com.java.demo.Model;

public class User {
    private String name;
    private int Id;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", Id=" + Id +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return Id;
    }

    public void setId(int id) {
        Id = id;
    }
}

package com.java.demo.Model;

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

/**
* 公共类
 */
@Component
public class Users {
    /*
    * 公共对象 -> 默认单例模式
     */
    @Bean("user")
    public User getUser(){
        User user = new User();
        user.setName("唐三藏");
        user.setId(11);
        return user;
    }
}

package com.java.demo.Controller;

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

@Controller
public class UserController {
    @Autowired
    private User user;

    public void doMethod(){
        User user1 = user;
        System.out.println("UserController 修改之前 ：User -> " + user);
        user1.setName("如来佛祖");
        System.out.println("UserController 修改之后 ：User -> " + user);
    }
}

package com.java.demo.Controller;

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

@Controller
public class UserController2 {
    @Autowired
    private User user;

    public void doMethod(){
        System.out.println("UserController2 ：User -> " + user);
    }
}

package com.java.demo;

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

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

输出：

UserController 修改之前：User -> User{name='唐三藏', Id=11}
UserController 修改之后：User -> User{name='如来佛祖', Id=11}
UserController2 ：User -> User{name='如来佛祖', Id=11}

可以发现，单例模式中，user的姓名被修改了。

1.2 prototype：原型模式

在该作用域下，每次 Bean 请求都会创建新的实例，因此获取 Bean 以及注入 Bean 都是新的对象实例。

可以使用 @Scope 标签来设置作用域。@Scope 既可以修饰方法也可以修饰类，有以下两种写法：

1. 直接设置：@Scope("prototype")

2. 枚举设置：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

package com.java.demo.Model;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
* 公共类
 */
@Component
public class Users {
    /*
    * 公共对象 -> 默认单例模式
     */
    @Bean("user")
    //@Scope("prototype") // 原型模式/多例模式
    // 亦可写成：
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public User getUser(){
        User user = new User();
        user.setName("唐三藏");
        user.setId(11);
        return user;
    }
}

输出：

UserController 修改之前：User -> User{name='唐三藏', Id=11}
UserController 修改之后：User -> User{name='如来佛祖', Id=11}
UserController2 ：User -> User{name='唐三藏', Id=11}

1.3 Bean 的其他作用域

只适用于 Spring MVC 项目（Spring Web）：

request：请求作用域。每次 http 请求都会创建新的 Bean 实例。一次 http 请求和响应共享 Bean

session：会话作用域。一个 Http 会话共享一个 Bean。

application：应用作用域。表示的是一个 Context 容器共享一个作用域。

只适用于 websocket ：

websocket 作用域

2 Spring 生命周期(执行流程)

2.1 启动容器

2.2 读取配置文件完成 Bean 初始化(实例化)

2.3 将 Bean 对象放到容器中

这里只会扫描包路径上的类并且使用 Spring 的注解才可以被放到容器中。

扫描 com.java.demo 包下的 Spring 注解，像 @Controller、@Service、@Component、@Repository

2.4 注入 Bean 属性(给当前类的属性DI，进行赋值)

如果 Bean 对象需要使用其他 Bean 对象作为属性，可以使用注解：@Autowired、@Resource

3 Bean 生命周期

Bean 的生命周期指的是 Bean 从诞生到销毁的整个生命过程，这样的过程就叫做生命周期，可以大致分为以下 5 个部分：

1. 实例化 Bean（为 Bean 分配内存空间）

2. 设置 Bean 属性（进行依赖注入，将依赖的 Bean 赋值到当前类的属性上）

3. Bean 初始化

实现了各种 Aware 通知的⽅法，如 BeanNameAware、BeanFactoryAware、 ApplicationContextAware 的接⼝⽅法；

执⾏ BeanPostProcessor 初始化前置⽅法；

执⾏ @PostConstruct 初始化⽅法，依赖注⼊操作之后被执⾏；

执⾏⾃⼰指定的 init-method ⽅法（如果有指定的话）；

执⾏ BeanPostProcessor 初始化后置⽅法。

4. 使用 Bean

5. 销毁 Bean

销毁容器的各种⽅法，如 @PreDestroy、DisposableBean 接⼝⽅法、destroy- method。

package com.java.demo;

import com.java.demo.Model.User;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.annotation.Autowired;

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

public class BeanLifeComponent implements BeanNameAware {
    @Autowired
    private User user;

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

    @PostConstruct
    public void doPostConstruct(){
        System.out.println("执行了 @PostConstruct");
        System.out.println(user.toString());
    }

    public void myInit(){
        System.out.println("执行了 myInit");
    }

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

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

package com.java.demo;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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