SpringSecurity源码学习四：会话管理

SpringSecurity源码学习四：会话管理
目录
1. 什么是会话管理

会话管理是指在Java应用程序中管理用户会话状态的过程。在Spring框架中，可以使用Spring Session来实现会话管理。Spring Session提供了一种机制，用于在不同的会话存储后端（例如内存、数据库、Redis等）中存储和管理会话数据。

通过使用Spring Session，您可以轻松地在Spring应用程序中管理会话。它提供了简单的API，用于创建、读取、更新和删除会话数据。您可以使用Spring的依赖注入机制将Spring Session集成到您的应用程序中，并根据需要配置会话存储后端。

会话管理在Web应用程序中尤为重要，因为它允许您跟踪用户的登录状态、存储用户特定的数据，并提供一种机制来管理会话的过期和超时。通过有效地管理会话，您可以提供更安全、可靠的用户体验，并确保应用程序的性能和可扩展性。

总而言之，会话管理是通过Spring Session在Java应用程序中管理用户会话状态的过程，它提供了一种机制来存储和管理会话数据，并确保应用程序的安全性和性能。

2. springSecurity中的session管理怎么做的

在Spring Security中，可以通过配置来管理会话。以下是在Spring Security中进行会话管理的一般步骤：
1. 添加Spring Security依赖：在项目的构建文件（如pom.xml）中添加Spring Security的依赖项。
2. 配置会话管理：在Spring Security的配置文件中，可以使用 sessionManagement() 方法来配置会话管理。例如，您可以设置会话超时时间、最大并发会话数等。
3. 配置会话固定攻击防护：为了防止会话固定攻击，您可以使用 sessionFixation() 方法配置会话固定攻击防护策略。常见的防护策略包括更改会话ID、使用cookie作为会话ID等。
4. 配置会话存储后端：您可以选择将会话数据存储在不同的后端，如内存、数据库、Redis等。根据您的需求，配置会话存储后端以存储和管理会话数据。
5. 定义访问控制规则：使用Spring Security的访问控制规则，您可以定义哪些URL需要进行会话管理和访问控制。例如，您可以配置需要进行身份验证的URL，或者需要特定角色或权限才能访问的URL。
通过以上步骤，您可以在Spring Security中实现会话管理。具体的配置和实现方式可能会根据您的应用程序需求而有所不同。您可以参考Spring Security的官方文档和示例代码，以获得更详细的指导和示例。

3. springSecurity源码中的session管理

Security源码中会话管理的一般实现方式：
1. SessionManagementConfigurer 接口：这是一个配置接口，用于配置会话管理的各个方面，如会话超时时间、最大并发会话数等。您可以使用 sessionManagement() 方法获取 SessionManagementConfigurer 实例，并通过调用其方法来配置会话管理。
2. SessionFixationConfigurer 接口：这是一个配置接口，用于配置会话固定攻击防护策略。您可以使用 sessionFixation() 方法获取 SessionFixationConfigurer 实例，并通过调用其方法来配置会话固定攻击防护。
3. SessionRegistry 接口：这是一个接口，用于管理并发会话。它提供了注册、注销和获取会话的方法，以及获取活动会话数等功能。 SessionRegistry 的默认实现是 SessionRegistryImpl 。
4. ConcurrentSessionControlAuthenticationStrategy 类：这是一个会话控制策略类，用于限制并发会话数。它通过与 SessionRegistry 结合使用，检查当前用户的会话数并处理超出限制的情况。
5. SessionAuthenticationStrategy 接口：这是一个接口，用于处理用户身份验证时的会话管理。它定义了在用户登录时如何处理会话，包括创建新会话、销毁旧会话等。
  以上是Spring Security源码中会话管理的一般实现方式。具体的实现细节和类可能会根据不同版本的Spring Security而有所不同。如果您有兴趣深入了解Spring Security的会话管理实现，请参考Spring Security的源代码和文档。
4. 代码示例
```
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
     @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .sessionManagement()
                .invalidSessionStrategy(invalidSessionStrategy())
                .maximumSessions(1) // 最大并发会话数
                .maxSessionsPreventsLogin(true) // 超出最大会话数时阻止登录
                .expiredSessionStrategy(expiredSessionStrategy())
                .and()
            .and()
            .logout()
                .deleteCookies("JSESSIONID") // 在注销时删除会话ID的Cookie
                .invalidateHttpSession(true); // 注销时使会话失效
    }
     @Bean
    public InvalidSessionStrategy invalidSessionStrategy() {
        return new CustomInvalidSessionStrategy();
    }
     @Bean
    public SessionInformationExpiredStrategy expiredSessionStrategy() {
        return new CustomExpiredSessionStrategy();
    }
}
 public class CustomInvalidSessionStrategy implements InvalidSessionStrategy {
     @Override
    public void onInvalidSessionDetected(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        // 自定义会话失效处理逻辑
        response.sendRedirect("/session-invalid"); // 重定向到会话失效页面
    }
}
 public class CustomExpiredSessionStrategy implements SessionInformationExpiredStrategy {
     @Override
    public void onExpiredSessionDetected(SessionInformationExpiredEvent event) throws IOException, ServletException {
        // 自定义会话过期处理逻辑
        HttpServletResponse response = event.getResponse();
        response.sendRedirect("/session-expired"); // 重定向到会话过期页面
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
```
在上述代码中，通过 invalidSessionStrategy() 方法和 expiredSessionStrategy() 方法分别定义了自定义的会话失效策略和会话过期策略。您可以在相应的自定义策略类中实现自己的会话失效和会话过期处理逻辑。在示例中， CustomInvalidSessionStrategy 类处理会话失效， CustomExpiredSessionStrategy 类处理会话过期。您可以根据实际需求修改这些类来实现您自己的逻辑。

请注意，以上代码只是一个简单的示例，您可以根据实际需求进行更详细的配置和自定义。

5. 源码

查看源码，WebSecurityConfigurerAdapter类的applyDefaultConfiguration()方法，
```
	private void applyDefaultConfiguration(HttpSecurity http) throws Exception {
		http.csrf();
		http.addFilter(new WebAsyncManagerIntegrationFilter());
		//exceptionHandling 方法，这个方法会将 ExceptionHandlingConfigurer 配置进来，
		// 最终调用 ExceptionHandlingConfigurer#configure 方法将 ExceptionTranslationFilter 添加到 Spring Security
		http.exceptionHandling();
		http.headers();
		//进行session管理
		http.sessionManagement();
		http.securityContext();
		http.requestCache();
		http.anonymous();
		http.servletApi();
		http.apply(new DefaultLoginPageConfigurer<>());
		http.logout();
	}

	public SessionManagementConfigurer<HttpSecurity> sessionManagement() throws Exception {
		return getOrApply(new SessionManagementConfigurer<>());
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
```
可以看到会话管理是由SessionManagementConfigurer类处理。SessionManagementConfigurer类源码：
```
public final class SessionManagementConfigurer<H extends HttpSecurityBuilder<H>>
		extends org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer<SessionManagementConfigurer<H>, H> {

	//默认策略
	private final SessionAuthenticationStrategy DEFAULT_SESSION_FIXATION_STRATEGY = createDefaultSessionFixationProtectionStrategy();

	//策略赋值
	private SessionAuthenticationStrategy sessionFixationAuthenticationStrategy = this.DEFAULT_SESSION_FIXATION_STRATEGY;
	
	/**
	 * Invokes {@link #postProcess(Object)} and sets the
	 * {@link SessionAuthenticationStrategy} for session fixation.
	 * 
	 * 默认策略
	 * @param sessionFixationAuthenticationStrategy
	 */
	private void setSessionFixationAuthenticationStrategy(
			SessionAuthenticationStrategy sessionFixationAuthenticationStrategy) {
		this.sessionFixationAuthenticationStrategy = postProcess(sessionFixationAuthenticationStrategy);
	}

	/**
	 * Allows configuring SessionFixation protection
	 * 不同策略初始化
	 * @author Rob Winch
	 */
	public final class SessionFixationConfigurer {

		/**
		 * Specifies that a new session should be created, but the session attributes from
		 * the original {@link HttpSession} should not be retained.
		 * @return the {@link SessionManagementConfigurer} for further customizations
		 */
		public SessionManagementConfigurer<H> newSession() {
			SessionFixationProtectionStrategy sessionFixationProtectionStrategy = new SessionFixationProtectionStrategy();
			sessionFixationProtectionStrategy.setMigrateSessionAttributes(false);
			setSessionFixationAuthenticationStrategy(sessionFixationProtectionStrategy);
			return SessionManagementConfigurer.this;
		}

		/**
		 * Specifies that a new session should be created and the session attributes from
		 * the original {@link HttpSession} should be retained.
		 * @return the {@link SessionManagementConfigurer} for further customizations
		 */
		public SessionManagementConfigurer<H> migrateSession() {
			setSessionFixationAuthenticationStrategy(new SessionFixationProtectionStrategy());
			return SessionManagementConfigurer.this;
		}

		/**
		 * Specifies that the Servlet container-provided session fixation protection
		 * should be used. When a session authenticates, the Servlet method
		 * {@code HttpServletRequest#changeSessionId()} is called to change the session ID
		 * and retain all session attributes.
		 * @return the {@link SessionManagementConfigurer} for further customizations
		 */
		public SessionManagementConfigurer<H> changeSessionId() {
			setSessionFixationAuthenticationStrategy(new ChangeSessionIdAuthenticationStrategy());
			return SessionManagementConfigurer.this;
		}

		/**
		 * Specifies that no session fixation protection should be enabled. This may be
		 * useful when utilizing other mechanisms for protecting against session fixation.
		 * For example, if application container session fixation protection is already in
		 * use. Otherwise, this option is not recommended.
		 * @return the {@link SessionManagementConfigurer} for further customizations
		 */
		public SessionManagementConfigurer<H> none() {
			setSessionFixationAuthenticationStrategy(new NullAuthenticatedSessionStrategy());
			return SessionManagementConfigurer.this;
		}

	}
}
	......

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
```
5.1 不同策略的含义

不同的session策略是为了解决会话固定攻击的。会话固定攻击（Session Fixation Attack）是一种安全漏洞，利用该漏洞攻击者可以劫持用户的会话。在Spring Security中，会话固定攻击指的是攻击者在用户登录之前获取到了一个会话ID，并将其注入到用户的浏览器中，然后用户使用该会话ID进行登录。这样，攻击者就可以通过使用相同的会话ID来劫持用户的会话，获取用户的敏感信息或执行恶意操作。为了防止会话固定攻击，Spring Security提供了一些机制，如使用随机生成的会话ID、在用户登录时重新生成会话ID等。这些机制可以有效地保护用户的会话安全。

SessionFixationConfigurer类是Spring Security中的一个配置类，用于配置会话固定攻击保护。它提供了一些方法来配置会话ID的处理方式，以防止会话固定攻击。
1. newSession：登录之后创建一个新的session
2. migrateSession：登录之后创建一个新的session，并将旧的session中的数据复制过来
3. changeSessionId：不创建新的会话，而是使用由Servlet容器提供的会话固定保护
4. none：不做任何的处理，登陆之后沿用就的session
6. 集群模式session管理

在Spring Security集群模式下，可以使用分布式缓存来管理会话。
1. 首先，确保你的项目中已经引入了Redis的依赖。
2. 在Spring配置文件中配置Redis连接信息：
3. 创建一个实现 org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration> 的配置类：
```
import org.springframework.context.annotation.Configuration;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
 @Configuration
@EnableRedisHttpSession
public class SessionConfig {
    // 可以在这里配置会话过期时间等参数
}
1
2
3
4
5
6
7
```
1. 在Spring Security配置类中启用会话管理：
```
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 public class SecurityConfig extends WebSecurityConfigurerAdapter {
     @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // 其他Spring Security配置
            .and()
            .sessionManagement()
                .maximumSessions(1) // 设置允许的最大会话数
                .maxSessionsPreventsLogin(false) // 当达到最大会话数时，是否阻止新登录
                .expiredUrl("/session-expired"); // 会话过期后跳转的URL
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
通过以上配置，Spring Security将会话信息存储在Redis中，实现了会话在集群环境下的管理和共享。你可以根据自己的需求进行相关配置和调整。以上代码只是简单的代码示例，具体使用要根据具体情况而定。

7. 总结

Spring Security会话管理的原理如下：
1. 用户登录时，Spring Security会为用户创建一个会话，并生成一个唯一的会话ID。
2. 会话ID会被存储在用户的浏览器Cookie中，或者作为请求参数传递给服务器。
3. 在后续的请求中，用户会携带会话ID来进行身份验证和授权。
4. 服务器接收到请求后，会根据会话ID来查找对应的会话信息。
5. 通过会话信息，服务器可以验证用户的身份，并进行相应的授权操作。
6. 如果会话过期或被注销，服务器会清除对应的会话信息，并要求用户重新登录。
7. Spring Security提供了一些配置选项和机制，如会话超时时间、并发会话控制、会话固定攻击保护等，可以根据需求进行定制和扩展。
  通过这种方式，Spring Security实现了对用户会话的管理和安全控制，确保用户的身份验证和授权操作的可靠性和安全性。
相关阅读:
js+html实现打字游戏v1
xCode14.3.1运行MonkeyDev出现“Executable Not Found“的解决办法
 怎么学编程效率高，编程练习网站编程软件下载，中文编程开发语言工具下载
 什么是微格式
 删除的数据如何恢复？误删了文件怎么恢复
 QEMU开发入门
 【毕业季·进击的技术er】从事自己热爱的行业，保持学习，成为一个无可替代的人
 c++语法拾遗，一些细节与特性
 三国志14信息查询小程序（历史武将信息一览）制作更新过程06-复现小程序
 【代码随想录】二刷-字符串
原文地址：https://blog.csdn.net/qq_27586963/article/details/133967631

目录

1. 什么是会话管理

2. springSecurity中的session管理怎么做的

3. springSecurity源码中的session管理

4. 代码示例

5. 源码

5.1 不同策略的含义

6. 集群模式session管理

7. 总结