Spring Bean的作用域具体实现(单例、多例、请求、会话、Application)

目录

• 概念
• Bean 的作用域
• 代码测试
• 观察 Bean 的作用域
• 1.单例作用域
• 2.多例作用域
• 3.请求作用域
• 4.会话作用域
• 5.Application作用域

概念

在 Spring Ioc&DI 戒断，我们学习了 Spring 是如何帮助我们管理对象的

1. 通过 @Controller，@Service，@Repository，@Component，@Configuration，@Bean 来声明 Bean 对象
2. 通过 ApplicationContext 或者 BeanFactory 来获取对象
3. 通过 @Autowired，Setter 方法或者构造方法等来为应用程序注入所依赖的 Bean 对象

我们来简单回顾一下

1. 通过 @Bean 声明 bean，把 bean 存在 Spring 容器中

public class Dog {  
    private String name;  
    public void setName(String name) {  
        this.name = name;  
 javascript   }  
}

@Component  
public class DogBeanConfig {  
    @Bean  
    public Dog dog() {  
        Dog dog = new Dog();  
        dog.setName("旺旺");  
        return dog;  
    }  
}

2. 从 Spring 容器中获取 Bean
   • 通过在代码中直接注入 ApplicationContext 的方式

@SpringBootTest  
class ApplicationTests {  
    @Autowired  
    private ApplicationContext applicationContext;  
    @Test  
    void contextLoads() {  
        DogBeanConfig dog1 = applicationContext.getBean(DogBeanConfig.class);;  
        System.out.println(dog1);  
    }  
}

司改代码，从 Spring 容器中多次获取 Bean

@SpringBootTest  
class ApplicationTests {  
    @Autowired  
    private ApplicationContext applicationContext;  
    @Test  
    void contextLoads() {  
        DogBeanConfig dog1 = applicationContext.getBean(DogBeanConfig.class);;  
        System.out.println(dog1);  
        DogBeanConfig dog2 = applicationContext.getBean(DogBeanConfig.class);;  
        System.out.println(dog2);  
    }  
}

观察运行结果

发现输出的 bean 对象地址是一样的，说明每次从 Spring 容器中取出来的对象都是同一个

• 这也是“单例模式”
• 单例模式：确保一个类只有一个实例，多次创建也不会创建出多个实例

Bean 的作用域是值 Bean 在 Spring 框架中的某种行为模式

比如单例作用域：表示 Bean 在整个 Spring 中只有一份，它是全局共享的。那么当其他人修改了这个值之后，那么另一个人读到的就是被修改后的值

修改上述代码，给 UserController 添加属性 name

@SpringBootTest  
class ApplicationTests {  
    @Autowired  
    private ApplicationContext applicationContext;  
    @Test  
    void contextLoads() {  
        Dog dog1 = applicationContext.getBean(Dog.class);  
        dog1.setName("狗狗1");  
        System.out.println(dog1);  
        System.out.println(dog1.getName());  
        Dog dog2 = applicationContext.getBean(Dog.class);;  
        System.out.println(dog2);  
        System.out.println(dog2.getName());  
    }  
}

观察运行结果：

• dog1 和 dog2 为同一个对象，dog2 拿到了 dog1 设置的值

那能不能将 bean 对象设置为非单例的（每次获取的 bean 都是一个新对象呢）

• 这就是 Bean 的不同作用域了

Bean 的作用域

在 Spring 中支持 6 中作用域，后 4 种在 Spring MVC 环境才生效

1. singleton：单例作用域
   • 每个 Spring Ioc 容器内同名称的 Bean 只有一个实例(单例)(默认)
2. prototype：原型作用域（多例作用域）
   • 每次使用该 bean 时会创建新的实例(非单例)
3. request：请求作用域
   • 每个 HTTP 请求生命周期内，创建新的实例（Web 环境中，了解）
4. session：会话作用域
   • 每个 HTTP Session 生命周期内，创建新的实例（Web 环境中，了解）
5. Application：全局作用域
   • 每个 ServletContext 生命周期里内，创建新的实例（web 环境中，了解）
6. websocket：HTTP WebSocket 作用域
   • 每个 WebSocket 生命周期内，创建新的实例（web 环境中，了解）

我们来看简单的代码实现

定义几个不同作用域的 bean

@Component  
public class DogBeanConfig {  
    @Bean  
    public Dog dog() {  
        Dog dog = new Dog();  
        dog.setName("旺旺");  
        return dog;  
    }  
    @Bean  
    @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)  
    public Dog singleDog() {  
        Dog dog = new Dog();  
        return dog;  
    }  
    @Bean  
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)  
    public Dog prototype() {  
        Dog dog = new Dog();  
        return dog;  
    }  
    @Bean  
    @RequestScope    
    public Dog requestDog() {  
        Dog dog = new Dog();  
        return dog;  
    }  
    @Bean  
    @SessionScope    
    public Dog sessionDog() {  
        Dog dog = new Dog();  
        return dog;  
    }  
    @Bean  
    @A编程pplicationScope    
    public Dog applicationDog() {  
        Dog dog = new Dog();  
        return dog;  
    }  
}

• @RequestScope 等同于 @Scope (value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
• @SessionScope 等同于 @Scope (value =WebApplicationContext.SCOPE_SESSION, proxyMode =ScopedProxyMode.TARGET_CLASS)
• @ApplicationScope 等同于 @Scope (value =WebApplicatijavascriptonContext. SCOPE_APPLICATION, proxyMode =ScopedProxyMode. TARGET_CLASS)

proxyMode ⽤来为 springbean 设置代理 .proxyMode = ScopedProxyMode.TARGET_CLASS 表⽰这个 Bean 基于 CGLIB 实现动js态代理，Request，session 和 application 作⽤域的 Bean 需要设置 proxyMode

代码测试

测试不同作用域的 bean 取到的对象是否一样

@RestController  
public class DogController {  
    @Autowired  
    private Dog singleDog;  
    @Autowired  
    private Dog prototypeDog;  
    @Autowired  
    private Dog requestDog;  
    @Autowired  
    private Dog sessionDog;  
    @Autowired  
    private Dog applicationDog;  
    @Autowired  
    private ApplicationContext applicationContext;  
    @RequestMapping("/single")  
    public String single(){  
        Dog contexDog = (Dog) applicationContext.getBean("singleDog");  
        return "dog: " + singleDog.toString() + ", contextDog: " + contexDog;  
    }  
    @RequestMapping("/prototype")  
    public String prototype() {  
        Dog contextDog = (Dog) applicationContext.getBean("prototypeDog");  
        return "dog: " + prototypeDog.toString() + ", contextDog: " + contextDog;  
    }  
    @RequestMapping("/request")  
    public String request(){  
        Dog contexDog = (Dog) applicationContext.getBean("requestDog");  
        return "dog: " + requestDog.toString() + ", contextDog: " + contexDog;  
    }  
    @RequestMapping("/session")  
    public String session() {  
        Dog contextDog = (Dog) applicationContext.getBean("sessionDog");  
        return "dog: " + sessionDog.toString() + ", contextDog: " + contextDog;  
    }  
    @RequestMapping("/application")  
    public String application() {  
        Dog contextDog = (Dog) applicationContext.getBean("applicationDog");  
        return "dog: " + applicationDog.toString() + ", contextDog: " + contextDog;  
    }  
}

• 每个请求都获取两次 Bean
• @Autowired 和 applicationContext.getBean("singleDog") 都是从 Spring 容器中获取对象

观察 Bean 的作用域

1.单例作用域

地址： http://127.0.0.1:8080/single

多次访问，得到的都是同一个对象，并且 @Autowired 和 applicationContext.getBean() 也是同一个对象

2.多例作用域

地址： http://127.0.0.1:8080/prototype

观察 ContextDog，每次获取的对象都不一样（注入的对象在 Spring 容器启动时，就已经注入了，所以多次请求访问也不会发生变化）

3.请求作用域

地址： http://127.0.0.1:8080/request

在一次请求中，@Autowired 和 applicationContext.getBean() 也是同一个对象，但是每次请求，都会重新创建对象

4.会话作用域

地址： http://127.0.0.1:8080/session

在一个 session 中，多次请求，获取到的对象都是同一个

换一个浏览器访问，发现会重新创建对象（另一个 session）

5.Application作用域

地址： http://127.0.0.1:8080/application

在一个应用中，多次访php问都是同一个对象

• Application scope 就是对于整个 web 容器来说，bean 的作用域是 ServletContext 级别的
• 这个和 singleton 有点类似，区别在于：Application scope 是 ServletContext 的单例，singleton 是一个 ApplicationContext 的单例
• 在一个 web 容器中 ApplicationContext 可以有多个（了解即可）

到此这篇关于Spring Bean的作用域具体实现(单例、多例、请求、会话、Application)的文章就介绍到这了,更多相关Spring Bean作用域内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！