Spring全家桶源码解析--2.6 Spring scope 限制bean的作用范围

最新推荐文章于 2024-07-12 09:16:51 发布

拽着尾巴的鱼儿

最新推荐文章于 2024-07-12 09:16:51 发布

阅读量134

点赞数

分类专栏： Spring框架篇源码解析篇文章标签： spring java 后端

本文链接：https://blog.csdn.net/l123lgx/article/details/134195914

版权

Spring框架篇同时被 2 个专栏收录

72 篇文章 4 订阅

订阅专栏

源码解析篇

54 篇文章 0 订阅

订阅专栏

文章目录

前言
一、Scope是什么？
二、Scope使用
总结：

前言

在Maven 中我们可以通过标签来现在依赖的作用范围，在Spring 中也提供@Scope 注解来限制bean 的作用范围。

一、Scope是什么？

在平时的开发中我们可能通过@Bean，@Component，@Import ，@Configuration 等注解来为容器中注入bean ，虽然我们没有声明，但是他们都被默认成了单例对象，Spring 开发者是基于什么考虑来提供@Scope 注解。
我们看下Scope 注解的作用：
@Scope注解是Spring框架中用于限定Bean作用范围的注解。它可以应用于Bean定义的类级别，以指定Bean的实例化和销毁规则；

在Spring中，Bean的作用域定义了Bean对象在应用程序中的存在范围和生命周期，包括多例（prototype）、单例（singleton）、会话（session）、请求（request）等几种常用的作用域。
作用域的意义主要包括以下几个方面：

控制对象的创建和销毁：通过定义不同的作用域，可以指定Bean对象的创建和销毁行为。例如，使用单例作用域的Bean在应用程序启动时创建，直到应用程序关闭时才销毁；而使用多例作用域的Bean在每次通过容器获取时都会创建一个新的实例，不由容器管理其生命周期。
控制对象的共享与隔离：不同的作用域决定了Bean对象在应用程序中的共享程度。单例作用域的Bean是全局唯一的，可以在应用的任何地方共享；而多例作用域的Bean每次获取都会创建一个新的实例，相互之间是隔离的。
提供灵活的对象管理：通过合理使用不同作用域的Bean，可以满足不同业务场景下的需求。比如，使用会话作用域的Bean可以在用户会话期间保持状态，而请求作用域的Bean可以处理每个HTTP请求的相关逻辑。
提高性能和资源利用率：单例作用域的Bean在应用程序启动时被创建，可以在整个应用程序生命周期内重复使用，避免了重复创建对象的开销。这样可以提高应用程序的性能并节省资源的使用。
作用域在Spring中起到了控制对象创建和销毁、对象共享与隔离、对象管理和性能优化等作用。根据实际需求，合理选择适当的作用域可以帮助我们更好地管理Bean对象，提高应用程序的性能和灵活性。

二、Scope使用

2.1 单例：

在Spring中，单例（Singleton）作用域是最常用的一种作用域。当一个Bean被定义为单例作用域时，Spring容器只会创建一个该类型的实例，并在容器的生命周期中共享这个实例。

单例Bean在Spring容器启动时被创建，并保存在容器内部的一个缓存中。当应用程序需要获取该类型的Bean时，容器会返回已经存在的实例。这样可以避免重复创建对象的开销，提高应用程序的性能和资源利用率。

在平时的开发中我们没有定义@Scope 那么这个bean 默认就是单例的；

2.1.1 单例Bean的特点如下：

全局唯一性：单例Bean在应用程序的整个生命周期内只会创建一个实例，不管在哪里调用都会得到同一个实例。
共享：所有使用该单例Bean的组件将共享同一个实例，这样可以方便地进行数据的共享和状态的管理。
线程安全：单例Bean默认对多线程是线程安全的，即使多个线程同时访问该Bean的方法，也不会出现线程冲突的问题。
生命周期管理：单例Bean的生命周期由Spring容器管理，容器会在必要时创建和销毁单例Bean。
要将一个Bean定义为单例作用域，可以使用@Scope("singleton")注解，或者直接省略@Scope注解，默认为单例作用域。
需要特别注意的是，单例Bean应该是无状态的，不应该包含可变状态。如果单例Bean包含可变状态，可能会引发线程安全问题。如果需要在单例Bean中保存状态，应该使用线程安全的方式进行操作，或者考虑将Bean的作用域定义为原型（Prototype）。
单例Bean是Spring中最常用的作用域之一，它提供了全局唯一性、共享和线程安全的特性。合理使用单例Bean可以提高应用程序的性能和资源利用率，并方便管理对象的状态和数据共享。

2.1.2 单例设计模式与单例bean：

单例 bean 是有spring 容器进行生成和销毁的，其生命周期由spring 控制，一个类可以生成多个相同类型但是不同名称的单例bean
设计单例模式，是一种开发的规范模式，一个类只会有一个实例存在，并提供全局访问点，从概念上讲可以说两个根本就是不同的东西；

2.2 原型bean：

容器只负责创建和初始化，spring 本身不进行存储，原型（Prototype）作用域的Bean是Spring中的一种作用域，与单例作用域相对。当Bean被定义为原型作用域时，在每次通过容器获取该Bean时，都会创建一个新的实例。

2.2.1 原型Bean的特点：

多实例：每次通过容器获取原型Bean时，都会创建一个新的实例。相同的原型Bean可以有多个独立的实例。
灵活性：原型Bean适用于需要频繁创建新实例且不需要保持状态或数据共享的情况。每次获取原型Bean时，都可以获得一个全新的实例。
生命周期管理：容器在创建原型Bean实例后，不负责对其进行生命周期的管理。这意味着如果原型Bean依赖其他Bean，容器不会自动处理依赖的初始化和销毁。
对象创建时机：原型Bean的创建时机是在每次通过容器获取Bean时。而单例Bean在容器启动时就会创建。
要将一个Bean定义为原型作用域，可以@Scope(“prototype”)注解
需要注意的是，原型Bean在被注入到其他单例Bean中时，每次注入都会创建一个新的实例。因此，在使用原型Bean时要注意管理生命周期和资源释放，特别是在具有复杂依赖关系和状态的情况下。
原型Bean是Spring框架中的一种作用域，每次通过容器获取原型Bean时都会创建一个新的实例。原型作用域适用于需要频繁创建新实例的情况，且不需要保持状态或数据共享。通过合理使用原型Bean，可以满足动态创建对象实例的需求。
原型Bean是由Spring容器创建和管理的，但是它的生命周期并不受Spring容器的控制。因此，原型Bean不由Spring销毁，而是由使用该Bean的客户端负责销毁。

2.2.2 原型Bean的销毁：

当从Spring容器获取一个原型Bean时，Spring容器会创建一个新的实例，并将其返回给客户端。客户端可以使用该实例进行操作，但是在实例不再使用时，客户端需要负责销毁它。

原型Bean的销毁工作可以通过以下几种方式来实现：
（1）. 显式销毁：客户端可以在不再使用原型Bean时，主动调用销毁方法进行销毁。这可以是一个自定义的销毁方法，例如实现了DisposableBean接口的destroy()方法，或者使用@PreDestroy注解标注的方法。在该方法中，可以执行必要的清理操作，例如释放资源。

@Component
@Scope("prototype")
public class PrototypeBean implements DisposableBean {
    
    @Override
    public void destroy() throws Exception {
        // 执行销毁操作
    }
}

（2）. 手动销毁：客户端可以在原型Bean不再使用时，手动调用销毁方法进行销毁。这可以使用通过Spring容器提供的ApplicationContext对象获取原型Bean，并调用销毁方法。

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
PrototypeBean bean = context.getBean(PrototypeBean.class);
// 使用原型Bean
// 销毁Bean
((Disposable) bean).destroy();

需要注意的是，Spring容器会管理单例Bean的生命周期，括创建和销毁。但是对于原型Bean，Spring容器只负责创建，不负责销毁。因此，在使用原型Bean时，应该确保在不使用时及时销毁，以避免资源泄漏和内存泄漏问题。

另外，Spring容器在创建原型Bean时不会对其进行任何的依赖注入和初始化操作。每次获取原型Bean时，都会创建一个新的实例，并返回给客户端。因此，原型Bean的状态不会被其他Bean所影响，每次获取到的实例都是全新的。

2.3 Request bean 和 Session bean：

2.3.1 Request bean ：

Request 作用域的bean 需要和web 进行关联，在Web应用中，每个请求都会有一个独立的Bean实例。即每个请求都会有自己的Bean实例。请求（Request）作域是Spring框架中一种作用域，表示在每次HTTP请求中创建一个新的Bean实例。请求作用域的Bean将在每个请求过程中保持独立，这使得我们可以在每个请求中使用不同的Bean实例。
要将Bean定义为请求作用域，可以使用@Scope(“request”)注解或RequestScope注解。

示例代码如下：

@Component
@Scope("request")
public class MyRequestScopedBean {
    // Bean的定义
}

在上述示例中，MyRequestScopedBean被定义为请求作用域的Bean。每次HTTP请求都会创建一个新的MyRequestScopedBean实例，并且该实例仅在当前请求中有效。当请求结束后，该实例将被销毁。

2.3.1.1 Request bean 特点：

请求作用域的Bean只能在Web应用程序中使用，并且仅适用于使用了Spring Web MVC或Spring Boot的Web应用。
在使用请求作用域的Bean之前，需要在Spring上下文中启用对请求作用域的支持。可以通过配置RequestContextListener或使用注解@EnableWebMvc来启用。
在同一个请求中多次使用请求作用域的Bean将会得到同一个实例。但不同请求之间的Bean实例是独立的。
请求作用域的Bean对于并发请求是线程安全的。每个线程在处理请求时都会获得自己的Bean实例。
请求作用域是Spring框架中的一种作用域，用于在每个HTTP请求中创建独立的Bean实例。它适用于需要在每个请求中维持独立状态的Bean。通过使用@Scope(“request”)注解或RequestScope注解，我们可以将Bean定义为请求作用域，实现请求级别的状态管理。

2.3.2 session bean ：

在Web应用中，每个用户会话都会有一个独立的Bean实例。即每个用户在会话期间都有自己的Bean实例

Session作用域是Java Web应用中的一种作用域范围，用于在用户会话期间保持数据的独立状态。可以将数据存储在Session对象中，并在整个会话过程中进行共享和访问。

在Java EE中，Session作用域可以通过HttpSession对象来实现。HttpSession对象是由Servlet容器在每个用户会话期间创建和管理的，它表示了与特定用户相关联的会话对象。通过HttpSession对象，可以在会话作用域中存储和获取数据。

2.3.1.2 session bean 特点：

会话范围：Session作用域的生命周期与用户会话的启动和结束相对应。当用户首次访问Web应用时，Servlet容器会为该用户创建一个唯一的会话，并为其分配一个Session对象。该Session对象在整个会话期间都是有效的，直到用户主动结束会话或会话过期。
跨页面共享数据：Session作用域中的数据可以在用户会话期间的不同页面中进行共享和访问。当一个页面将数据存储在Session对象中后，其他页面可以通过相同的Session对象来获取存储的数据。这对于需要在多个页面之间传递数据或保持用户的状态特别有用。
容器管理：Session对象由Servlet容器自动创建和管理，无需显式创建或销毁。当用户会话结束或会话过期时，Servlet容器会自动销毁相关的Session对象及其对应的数据。
在使用Session作用域时，一般会借助HttpServletRequest对象来获取和操作Session对象。以下是一些示例代码，演示了如何在Session作用域中存储和获取数据。

在使用Session作用域时，一般会借助HttpServletRequest对象来获取和操作Session对象。以下是一些示例代码，演示了如何在Session作用域中存储和获取数据。

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class SessionScopedBean {
    
    @Autowired
    private HttpServletRequest request;

    public void storeData() {
        HttpSession session = request.getSession();
        session.setAttribute("key", "value");
    }

    public void retrieveData() {
        HttpSession session = request.getSession();
        String value = (String) session.getAttribute("key");
        // 使用值进行其他操作
    }
}

在上述示例中，SessionScopedBean是一个会话作用域的Bean，通过注入HttpServletRequest对象，可以获取当前会话的HttpSession对象。然后可以使用HttpSession对象将数据存储在会话作用域中，并在整个会话期间进行获取和使用。

需要注意的是，Session作用域中的数据是与用户会话绑定的，并且在跨多个用户会话之间是独立的。每个用户会话都有自己独立的Session对象和相应的数据。

综上所述，Session作用域是Java Web应用中一种用于在会话期间保持数据独立状态的作用域范围。通过HttpSession对象，可以在会话作用域中存储和获取数据。

2.3.3 Request、Session bean的实现：

浏览器在发起第一次请求到达服务器，服务发现浏览器请求头没有携带requestedSessionId / 携带了但是没有找到session（如重新启动tomcat）则通过.createSession(sessionId) 方法创建一个新的session并返回；

AbstractRequestAttributesScope 类中get 方法:

public Object get(String name, ObjectFactory<?> objectFactory) {
	// 从一个请求上下文容器中拿到请求的Attributes
    RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
	// 从属性中获取scope对象, 需要传入name 和 scope类型
	// 每次都是新的request 请求，所有从属性中获取对应的bean 是空的 ，则通过objectFactory.getObject()
	// 完成bean 的创建，创建完成放入到request 的属性中;
	// 如果是session 域在进入该方法之前 回先去获取当前request 请求对应的那个session 通过
	// requestedSessionId  获取session 如果获取到则返回，获取不到则认为是新窗口则创建session;
	// 从reques 或者session 获取 对应的bean 如果获取不到则进行创建，并放入到属性中，
	// 如果获取到了则直接返回
    Object scopedObject = attributes.getAttribute(name, this.getScope());
    if (scopedObject == null) {
        scopedObject = objectFactory.getObject();
        attributes.setAttribute(name, scopedObject, this.getScope());
        Object retrievedObject = attributes.getAttribute(name, this.getScope());
        if (retrievedObject != null) {
            scopedObject = retrievedObject;
        }
    }

    return scopedObject;
}

RequestContextHolder ServletRequestAttributes#getAttribute:

public Object getAttribute(String name, int scope) {
	// 如果是request
	if (scope == SCOPE_REQUEST) {
		if (!isRequestActive()) {
			throw new IllegalStateException(
					"Cannot ask for request attribute - request is not active anymore!");
		}
		// 从request中根据name获取 bean
		return this.request.getAttribute(name);
	}
	else {
		// 如果是session
		HttpSession session = getSession(false);
		if (session != null) {
			try {
				// 从session中根据name获取 bean
				Object value = session.getAttribute(name);
				if (value != null) {
					this.sessionAttributesToUpdate.put(name, value);
				}
				return value;
			}
			catch (IllegalStateException ex) {
				// Session invalidated - shouldn't usually happen.
			}
		}
		return null;
	}
}

2.3.4 bean 的request，session作用域同 web 浏览器 session会话和http 请求的关系：

在Web开发中，Spring框架提供了一些特殊的作用域来管理bean对象的生命周期，这些作用域与浏览器的会话（session）和HTTP请求息息相关。

Request作用域:
Request作用域是指将bean的生命周期限定在单个HTTP请求之内。当一个HTTP请求到达服务器，并且在处理请求的过程中需要使用到某个bean对象，Spring会创建该bean对象并将其置于Request作用域中。这意味着在同一个请求中多次获取该bean对象，会得到同一个实例。
Session作用域:
Session作用域是指将bean的生命周期限定在用户的会话期间。当用户通过浏览器与Web应用程序建立会话后，Spring会创建各个bean对象，并将其置于Session作用域中。这样，在同一个会话中多次获取该bean对象，会得到同一个实例。不同的用户会话之间拥有不同的实例。

现在来看一下Web浏览器的会话（session）和HTTP请求之间的关系。当用户使用浏览器访问Web应用程序时，浏览器会与服务器建立一个会话。会话可以跨越多个HTTP请求，直到会话超时或用户关闭浏览器。

对于每个HTTP请求，浏览器会将请求发送到服务器，并附带上之前建立的会话ID（可能通过Cookie或URL重写机制）。服务器接收到请求后，可以通过会话ID找到与该会话相关的信息，包括Session作用域中的bean对象。

在Spring中，使用Request作用域或Session作用域可以方便地管理bean对象的生命周期，并实现在请求或会话期间共享数据。可以通过在bean的声明中添加相应的作用域注解来指定相应的作用域，例如@RequestScope或@SessionScope。

综上所述:
(1) 他们是两个概念，一个是spring 中bean 的作用域，一个是浏览器与服务器的会话请求，但是他们直接又有关联，当声明为request 的作用域，每次进行http 请求都户创建一个新的bean 并被放入到该request的属性中，所以在同一个http 请求中多次获取到的这个bean 是同一个对象，但是在不同的http 请求中获取到的bean 是不同的；
对于session作用域的bean，在一个http请求中去获取改bean ，首先判断当前request 请求是否携带了sessionId 如果没有携带或者携带了但是没有找到session，此时session 为空，会重新创建一个新的session 并放入到response 中，后续多次进行http 请求，在使用改bean 的时候会先从session 的属性中获取，获取不到则进bean 的创建并吧创建之后的bean 放入的session 的属性中，所以在一个浏览器窗口的多次http 请求对应session作用域的bean 获取的是同一个对象，不同窗口因为session会话是两个，则取到的bean 是不同的；

总结：

不同bean的作用范围图解：
在这里插入图片描述

Spring 通过@Scope 注解为bean 定义需要的声明周期，Singleton（单例）：默认的作用范围，每个Spring容器中只会存在一个Bean实例。Prototype（原型）：每次获取Bean时都会创建一个新的实例。Request（请求）：每个HTTP请求都会创建一个新的实例，该实例仅在当前请求内部有效。Session（会话）：每个HTTP会话都会创建一个新的实例，该实例在整个会话期间有效。

拽着尾巴的鱼儿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring全家桶源码解析--2.6 Spring scope 限制bean的作用范围

在Maven 中我们可以通过标签来现在依赖的作用范围，在Spring 中也提供@Scope 注解来限制bean 的作用范围。不同bean的作用范围图解：Spring 通过@Scope 注解为bean 定义需要的声明周期，Singleton（单例）：默认的作用范围，每个Spring容器中只会存在一个Bean实例。Prototype（原型）：每次获取Bean时都会创建一个新的实例。Request（请求）：每个HTTP请求都会创建一个新的实例，该实例仅在当前请求内部有效。
复制链接

扫一扫