会话管理 (Session Management) _ Spring Security6.3.1中文文档(官方文档中文翻译)|Spring 教程 —

获得对请求进行身份验证的应用程序后，请务必考虑如何在将来的请求中保留和还原生成的身份验证。

默认情况下，这是自动完成的，因此不需要其他代码，但了解中的含义很重要。requireExplicitSaveHttpSecurity

如果你愿意，你可以阅读更多关于requireExplicitSave正在做什么或为什么它很重要的信息。否则，在大多数情况下，您已经完成了本节。

但在您离开之前，请考虑以下用例是否适合您的应用程序：

我想了解会话管理的组件
我想限制用户可以同时登录的次数
我想直接自己存储身份验证，而不是 Spring Security 为我做
我正在手动存储身份验证，并且想要将其删除
我正在使用 SessionManagementFilter，我需要有关摆脱它的指导
我想将身份验证存储在会话以外的其他内容中
我正在使用无状态身份验证，但我仍然希望将其存储在会话中
我正在使用，但应用程序仍在创建会话。SessionCreationPolicy.NEVER

了解会话管理的组件

会话管理支持由几个组件组成，这些组件协同工作以提供功能。这些组件是 SecurityContextHolderFilter、SecurityContextPersistenceFilter 和 SessionManagementFilter。

在 Spring Security 6 中，默认情况下不设置和。除此之外，任何应用程序都应该只有 or set，而不应该同时具有两者。SecurityContextPersistenceFilterSessionManagementFilterSecurityContextHolderFilterSecurityContextPersistenceFilter

这`SessionManagementFilter`

根据当前内容检查用户的内容，以确定用户在当前请求期间是否已通过身份验证，通常通过非交互式身份验证机制（如预身份验证或记住我）SessionManagementFilterSecurityContextRepositorySecurityContextHolder^[1]. 如果存储库包含安全上下文，则筛选器不执行任何操作。如果没有，并且 thread-local 包含（非匿名）对象，则筛选器假定它们已由堆栈中的先前筛选器进行身份验证。然后，它将调用配置的 .SecurityContextAuthenticationSessionAuthenticationStrategy

如果用户当前未通过身份验证，则筛选器将检查是否请求了无效的会话 ID（例如，由于超时），并将调用已配置的（如果设置了）。最常见的行为只是重定向到固定的URL，这封装在标准实现中。如前所述，在通过命名空间配置无效会话 URL 时，也会使用后者。InvalidSessionStrategySimpleRedirectInvalidSessionStrategy

远离`SessionManagementFilter`

在 Spring Security 5 中，默认配置依赖于检测用户是否刚刚进行身份验证并调用 SessionAuthenticationStrategy。这样做的问题在于，这意味着在典型的设置中，必须为每个请求读取。SessionManagementFilterHttpSession

在 Spring Security 6 中，默认情况下身份验证机制本身必须调用 . 这意味着无需检测何时完成，因此不需要为每个请求读取SessionAuthenticationStrategyAuthenticationHttpSession

搬离时要考虑的事项`SessionManagementFilter`

在 Spring Security 6 中，默认情况下不使用，因此，DSL 中的某些方法不会产生任何影响。SessionManagementFiltersessionManagement

方法更换

方法	更换
`sessionAuthenticationErrorUrl`	在身份验证机制中配置 `AuthenticationFailureHandler`
`sessionAuthenticationFailureHandler`	在身份验证机制中配置 `AuthenticationFailureHandler`
`sessionAuthenticationStrategy`	如上所述，在身份验证机制中配置`SessionAuthenticationStrategy`

sessionAuthenticationErrorUrl

在身份验证机制中配置 AuthenticationFailureHandler

sessionAuthenticationFailureHandler

在身份验证机制中配置 AuthenticationFailureHandler

sessionAuthenticationStrategy

如上所述，在身份验证机制中配置SessionAuthenticationStrategy

如果尝试使用其中任何一种方法，则会引发异常。

方法更换

方法	更换
`sessionAuthenticationErrorUrl`	在身份验证机制中配置 `AuthenticationFailureHandler`
`sessionAuthenticationFailureHandler`	在身份验证机制中配置 `AuthenticationFailureHandler`
`sessionAuthenticationStrategy`	如上所述，在身份验证机制中配置`SessionAuthenticationStrategy`

sessionAuthenticationErrorUrl

在身份验证机制中配置 AuthenticationFailureHandler

sessionAuthenticationFailureHandler

在身份验证机制中配置 AuthenticationFailureHandler

sessionAuthenticationStrategy

如上所述，在身份验证机制中配置SessionAuthenticationStrategy

自定义身份验证的存储位置

默认情况下，Spring Security 将安全上下文存储在 HTTP 会话中。但是，您可能希望自定义它的几个原因如下：

您可能需要调用实例上的各个 setterHttpSessionSecurityContextRepository
您可能希望将安全上下文存储在缓存或数据库中，以启用水平扩展

首先，您需要创建或使用像这样的现有实现，然后可以在中设置它。SecurityContextRepositoryHttpSessionSecurityContextRepositoryHttpSecurity

自定义SecurityContextRepository

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    SecurityContextRepository repo = new MyCustomSecurityContextRepository();
    http
        // ...
        .securityContext((context) -> context
            .securityContextRepository(repo)
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    val repo = MyCustomSecurityContextRepository()
    http {
        // ...
        securityContext {
            securityContextRepository = repo
        }
    }
    return http.build()
}

<http security-context-repository-ref="repo">
    <!-- ... -->
</http>
<bean name="repo" class="com.example.MyCustomSecurityContextRepository" />

上述配置设置了 on 和参与身份验证过滤器，例如 . 若要在无状态筛选器中设置它，请参阅如何自定义无状态身份验证的 SecurityContextRepository。SecurityContextRepositorySecurityContextHolderFilterUsernamePasswordAuthenticationFilter

如果您使用的是自定义身份验证机制，则可能需要自行存储身份验证。

手动存储`Authentication`

例如，在某些情况下，您可能正在手动验证用户身份，而不是依赖 Spring Security 过滤器。您可以使用自定义筛选器或 Spring MVC 控制器端点来执行此操作。如果要保存请求之间的身份验证，例如，必须这样做：HttpSession

Java

private SecurityContextRepository securityContextRepository =
        new HttpSessionSecurityContextRepository(); (1)

@PostMapping("/login")
public void login(@RequestBody LoginRequest loginRequest, HttpServletRequest request, HttpServletResponse response) { (2)
    UsernamePasswordAuthenticationToken token = UsernamePasswordAuthenticationToken.unauthenticated(
        loginRequest.getUsername(), loginRequest.getPassword()); (3)
    Authentication authentication = authenticationManager.authenticate(token); (4)
    SecurityContext context = securityContextHolderStrategy.createEmptyContext();
    context.setAuthentication(authentication); (5)
    securityContextHolderStrategy.setContext(context);
    securityContextRepository.saveContext(context, request, response); (6)
}

class LoginRequest {

    private String username;
    private String password;

    // getters and setters
}

1	将添加到控制器`SecurityContextRepository`
2	注入和为了能够保存`HttpServletRequestHttpServletResponseSecurityContext`
3	使用提供的凭据创建未经身份验证的`UsernamePasswordAuthenticationToken`
4	调用以对用户进行身份验证`AuthenticationManager#authenticate`
5	创建一个并在其中设置`SecurityContextAuthentication`
6	将`SecurityContextSecurityContextRepository`

就是这样。如果您不确定上面示例中的内容，可以在使用 SecurityContextStrategy 部分中阅读有关它的更多信息。securityContextHolderStrategy

正确清除身份验证

如果您使用的是 Spring Security 的注销支持，那么它会为您处理很多事情，包括清除和保存上下文。但是，假设您需要手动将用户注销您的应用程序。在这种情况下，您需要确保正确清除和保存上下文。

为无状态身份验证配置持久性

有时无需创建和维护，例如，跨请求保留身份验证。某些身份验证机制（如 HTTP Basic）是无状态的，因此会在每个请求时重新对用户进行身份验证。HttpSession

如果您不想创建会话，可以使用，如下所示：SessionCreationPolicy.STATELESS

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        // ...
        .sessionManagement((session) -> session
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        // ...
        sessionManagement {
            sessionCreationPolicy = SessionCreationPolicy.STATELESS
        }
    }
    return http.build()
}

<http create-session="stateless">
    <!-- ... -->
</http>

上述配置将 SecurityContextRepository 配置为使用，并且还阻止将请求保存在会话中。NullSecurityContextRepository

如果您正在使用，您可能会注意到应用程序仍在创建 . 在大多数情况下，发生这种情况是因为请求保存在会话中，以便经过身份验证的资源在身份验证成功后重新请求。为避免这种情况，请参阅如何防止被保存请求部分。SessionCreationPolicy.NEVERHttpSession

在会话中存储无状态身份验证

如果出于某种原因，您使用的是无状态身份验证机制，但仍希望将身份验证存储在会话中，则可以使用而不是 .HttpSessionSecurityContextRepositoryNullSecurityContextRepository

对于 HTTP Basic，您可以添加一个 ObjectPostProcessor，该处理器将：SecurityContextRepositoryBasicAuthenticationFilter

将 HTTP 基本身份验证存储在HttpSession

Java

@Bean
SecurityFilterChain web(HttpSecurity http) throws Exception {
    http
        // ...
        .httpBasic((basic) -> basic
            .addObjectPostProcessor(new ObjectPostProcessor<BasicAuthenticationFilter>() {
                @Override
                public <O extends BasicAuthenticationFilter> O postProcess(O filter) {
                    filter.setSecurityContextRepository(new HttpSessionSecurityContextRepository());
                    return filter;
                }
            })
        );

    return http.build();
}

上述内容也适用于其他身份验证机制，例如持有者令牌身份验证。

1	将添加到控制器`SecurityContextRepository`
2	注入和为了能够保存`HttpServletRequestHttpServletResponseSecurityContext`
3	使用提供的凭据创建未经身份验证的`UsernamePasswordAuthenticationToken`
4	调用以对用户进行身份验证`AuthenticationManager#authenticate`
5	创建一个并在其中设置`SecurityContextAuthentication`
6	将`SecurityContextSecurityContextRepository`

了解需要显式保存

在 Spring Security 5 中，默认行为是使用 SecurityContextPersistenceFilter 自动将 SecurityContext 保存到 SecurityContextRepository。保存必须在提交之前和之前完成。不幸的是，在请求完成之前（即在提交之前）完成的自动持久性可能会让用户感到惊讶。跟踪状态以确定是否需要保存也很复杂，有时会导致对（即）进行不必要的写入。HttpServletResponseSecurityContextPersistenceFilterSecurityContextHttpServletResponseSecurityContextRepositoryHttpSession

由于这些原因，已弃用，取而代之的是 . 在 Spring Security 6 中，默认行为是 SecurityContextHolderFilter 只会从中读取并将其填充到 . 用户现在必须显式保存 with 如果他们希望在请求之间持续存在。这消除了歧义，并通过仅在必要时写入（即）来提高性能。SecurityContextPersistenceFilterSecurityContextHolderFilterSecurityContextSecurityContextRepositorySecurityContextHolderSecurityContextSecurityContextRepositorySecurityContextSecurityContextRepositoryHttpSession

运作方式

总之，当是时，Spring Security 会设置 SecurityContextHolderFilter 而不是 SecurityContextPersistenceFilterrequireExplicitSavetrue

配置并发会话控制

如果您希望对单个用户登录应用程序的能力进行限制，Spring Security 通过以下简单的添加来支持开箱即用的功能。首先，您需要将以下侦听器添加到配置中，以使 Spring Security 更新会话生命周期事件：

Java
Kotlin
web.xml

@Bean
public HttpSessionEventPublisher httpSessionEventPublisher() {
    return new HttpSessionEventPublisher();
}

@Bean
open fun httpSessionEventPublisher(): HttpSessionEventPublisher {
    return HttpSessionEventPublisher()
}

<listener>
<listener-class>
    org.springframework.security.web.session.HttpSessionEventPublisher
</listener-class>
</listener>

然后将以下行添加到您的安全配置中：

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .sessionManagement(session -> session
            .maximumSessions(1)
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        sessionManagement {
            sessionConcurrency {
                maximumSessions = 1
            }
        }
    }
    return http.build()
}

<http>
...
<session-management>
    <concurrency-control max-sessions="1" />
</session-management>
</http>

这将阻止用户多次登录 - 第二次登录将导致第一次登录失效。

使用 Spring Boot，您可以通过以下方式测试上述配置场景：

Java

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc
public class MaximumSessionsTests {

    @Autowired
    private MockMvc mvc;

    @Test
    void loginOnSecondLoginThenFirstSessionTerminated() throws Exception {
        MvcResult mvcResult = this.mvc.perform(formLogin())
                .andExpect(authenticated())
                .andReturn();

        MockHttpSession firstLoginSession = (MockHttpSession) mvcResult.getRequest().getSession();

        this.mvc.perform(get("/").session(firstLoginSession))
                .andExpect(authenticated());

        this.mvc.perform(formLogin()).andExpect(authenticated());

        // first session is terminated by second login
        this.mvc.perform(get("/").session(firstLoginSession))
                .andExpect(unauthenticated());
    }

}

您可以使用“最大会话数”示例进行尝试。

您也希望阻止第二次登录，在这种情况下，您可以使用：

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .sessionManagement(session -> session
            .maximumSessions(1)
            .maxSessionsPreventsLogin(true)
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        sessionManagement {
            sessionConcurrency {
                maximumSessions = 1
                maxSessionsPreventsLogin = true
            }
        }
    }
    return http.build()
}

<http>
<session-management>
    <concurrency-control max-sessions="1" error-if-maximum-exceeded="true" />
</session-management>
</http>

然后，第二次登录将被拒绝。通过“拒绝”，我们的意思是如果正在使用基于表单的登录，用户将被发送到。如果通过其他非交互机制（如“记住我”）进行第二次身份验证，则将向客户端发送“未经授权”（401）错误。如果要改用错误页，则可以将属性添加到元素中。authentication-failure-urlsession-authentication-error-urlsession-management

使用 Spring Boot，您可以通过以下方式测试上述配置：

Java

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc
public class MaximumSessionsPreventLoginTests {

    @Autowired
    private MockMvc mvc;

    @Test
    void loginOnSecondLoginThenPreventLogin() throws Exception {
        MvcResult mvcResult = this.mvc.perform(formLogin())
                .andExpect(authenticated())
                .andReturn();

        MockHttpSession firstLoginSession = (MockHttpSession) mvcResult.getRequest().getSession();

        this.mvc.perform(get("/").session(firstLoginSession))
                .andExpect(authenticated());

        // second login is prevented
        this.mvc.perform(formLogin()).andExpect(unauthenticated());

        // first session is still valid
        this.mvc.perform(get("/").session(firstLoginSession))
                .andExpect(authenticated());
    }

}

如果使用自定义的身份验证筛选器进行基于表单的登录，则必须显式配置并发会话控制支持。您可以使用最大会话数阻止登录示例进行尝试。

检测超时

会话会自行过期，无需执行任何操作即可确保删除安全上下文。也就是说，Spring Security 可以检测会话何时过期并执行您指示的特定操作。例如，当用户使用已过期的会话发出请求时，您可能希望重定向到特定终端节点。这是通过以下方式实现的：invalidSessionUrlHttpSecurity

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .sessionManagement(session -> session
            .invalidSessionUrl("/invalidSession")
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        sessionManagement {
            invalidSessionUrl = "/invalidSession"
        }
    }
    return http.build()
}

<http>
...
<session-management invalid-session-url="/invalidSession" />
</http>

请注意，如果使用此机制检测会话超时，如果用户注销然后重新登录而不关闭浏览器，则可能会错误地报告错误。这是因为当您使会话无效时，会话 cookie 不会被清除，即使用户已注销，也会重新提交。如果是这种情况，您可能需要配置注销以清除会话 cookie。

自定义无效会话策略

这是使用 SimpleRedirectInvalidSessionStrategy 实现设置的便捷方法。如果要自定义行为，可以实现 InvalidSessionStrategy 接口并使用以下方法对其进行配置：invalidSessionUrlInvalidSessionStrategyinvalidSessionStrategy

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .sessionManagement(session -> session
            .invalidSessionStrategy(new MyCustomInvalidSessionStrategy())
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        sessionManagement {
            invalidSessionStrategy = MyCustomInvalidSessionStrategy()
        }
    }
    return http.build()
}

<http>
...
<session-management invalid-session-strategy-ref="myCustomInvalidSessionStrategy" />
<bean name="myCustomInvalidSessionStrategy" class="com.example.MyCustomInvalidSessionStrategy" />
</http>

您可以在注销时显式删除 JSESSIONID cookie，例如，通过在注销处理程序中使用 Clear-Site-Data 标头：

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .logout((logout) -> logout
            .addLogoutHandler(new HeaderWriterLogoutHandler(new ClearSiteDataHeaderWriter(COOKIES)))
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        logout {
            addLogoutHandler(HeaderWriterLogoutHandler(ClearSiteDataHeaderWriter(COOKIES)))
        }
    }
    return http.build()
}

<http>
<logout success-handler-ref="clearSiteDataHandler" />
<b:bean id="clearSiteDataHandler" class="org.springframework.security.web.authentication.logout.HeaderWriterLogoutHandler">
    <b:constructor-arg>
        <b:bean class="org.springframework.security.web.header.writers.ClearSiteDataHeaderWriter">
            <b:constructor-arg>
                <b:list>
                    <b:value>COOKIES</b:value>
                </b:list>
            </b:constructor-arg>
        </b:bean>
    </b:constructor-arg>
</b:bean>
</http>

这样做的优点是与容器无关，并且可以与任何支持标头的容器一起使用。Clear-Site-Data

或者，还可以在注销处理程序中使用以下语法：

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .logout(logout -> logout
            .deleteCookies("JSESSIONID")
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        logout {
            deleteCookies("JSESSIONID")
        }
    }
    return http.build()
}

<http>
  <logout delete-cookies="JSESSIONID" />
</http>

不幸的是，这不能保证适用于每个 servlet 容器，因此您需要在环境中对其进行测试。

如果在代理后面运行应用程序，则还可以通过配置代理服务器来删除会话 cookie。例如，通过使用 Apache HTTPD 的，以下指令通过在对注销请求的响应中使 cookie 过期来删除 cookie（假设应用程序部署在路径下）：mod_headersJSESSIONID/tutorial

<LocationMatch "/tutorial/logout">
Header always set Set-Cookie "JSESSIONID=;Path=/tutorial;Expires=Thu, 01 Jan 1970 00:00:00 GMT"
</LocationMatch>

有关“清除站点数据”和“注销”部分的更多详细信息。

了解会话固定攻击防护

会话固定攻击是一种潜在风险，恶意攻击者可能通过访问站点来创建会话，然后说服其他用户使用同一会话登录（例如，通过向他们发送包含会话标识符作为参数的链接）。 Spring Security 通过在用户登录时创建新会话或以其他方式更改会话 ID 来自动防止这种情况。

配置会话固定保护

您可以通过在三个推荐选项之间进行选择来控制会话固定保护的策略：

changeSessionId- 不要创建新会话。相反，请使用 Servlet 容器（）提供的会话固定保护。此选项仅在 Servlet 3.1 （Java EE 7）和更新的容器中可用。在较旧的容器中指定它将导致异常。这是 Servlet 3.1 和更高版本容器中的默认设置。HttpServletRequest#changeSessionId()
newSession- 创建一个新的“干净”会话，而不复制现有的会话数据（仍将复制与 Spring Security 相关的属性）。
migrateSession- 创建一个新会话并将所有现有会话属性复制到新会话。这是 Servlet 3.0 或更早版本容器中的缺省设置。

您可以通过执行以下操作来配置会话固定保护：

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .sessionManagement((session) -> session
            .sessionFixation((sessionFixation) -> sessionFixation
                .newSession()
            )
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        sessionManagement {
            sessionFixation {
                newSession()
            }
        }
    }
    return http.build()
}

<http>
  <session-management session-fixation-protection="newSession" />
</http>

当会话固定保护发生时，它会导致在应用程序上下文中发布。如果使用，此保护也会导致通知任何 s，因此，如果您的代码侦听这两个事件，请谨慎行事。SessionFixationProtectionEventchangeSessionIdjakarta.servlet.http.HttpSessionIdListener

您还可以将会话固定保护设置为禁用它，但不建议这样做，因为它会使您的应用程序容易受到攻击。none

用`SecurityContextHolderStrategy`

请考虑以下代码块：

Java

UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(
        loginRequest.getUsername(), loginRequest.getPassword());
Authentication authentication = this.authenticationManager.authenticate(token);
// ...
SecurityContext context = SecurityContextHolder.createEmptyContext(); (1)
context.setAuthentication(authentication); (2)
SecurityContextHolder.setContext(context); (3)

通过静态访问创建一个空实例。SecurityContextSecurityContextHolder
设置实例中的对象。AuthenticationSecurityContext
静态地设置实例。SecurityContextSecurityContextHolder

虽然上面的代码工作正常，但它可能会产生一些不希望的效果：当组件静态访问时，当有多个应用程序上下文想要指定 . 这是因为每个类装入器都有一个策略，而不是每个应用程序上下文有一个策略。SecurityContextSecurityContextHolderSecurityContextHolderStrategySecurityContextHolder

为了解决这个问题，组件可以从应用程序上下文进行连接。默认情况下，他们仍将从中查找策略。SecurityContextHolderStrategySecurityContextHolder

这些更改主要是内部的，但它们为应用程序提供了自动连接而不是静态访问的机会。为此，应将代码更改为以下内容：SecurityContextHolderStrategySecurityContext

Java

public class SomeClass {

    private final SecurityContextHolderStrategy securityContextHolderStrategy = SecurityContextHolder.getContextHolderStrategy();

    public void someMethod() {
        UsernamePasswordAuthenticationToken token = UsernamePasswordAuthenticationToken.unauthenticated(
                loginRequest.getUsername(), loginRequest.getPassword());
        Authentication authentication = this.authenticationManager.authenticate(token);
        // ...
        SecurityContext context = this.securityContextHolderStrategy.createEmptyContext(); (1)
        context.setAuthentication(authentication); (2)
        this.securityContextHolderStrategy.setContext(context); (3)
    }

}

使用配置的创建空实例。SecurityContextSecurityContextHolderStrategy
设置实例中的对象。AuthenticationSecurityContext
在 .SecurityContextSecurityContextHolderStrategy

强制创建紧急会话

有时，急切地创建会话可能很有价值。这可以通过使用 ForceEagerSessionCreationFilter 来完成，该过滤器可以使用以下方式进行配置：

Java
Kotlin
XML

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .sessionManagement(session -> session
            .sessionCreationPolicy(SessionCreationPolicy.ALWAYS)
        );
    return http.build();
}

@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        sessionManagement {
            sessionCreationPolicy = SessionCreationPolicy.ALWAYS
        }
    }
    return http.build()
}

<http create-session="ALWAYS">

</http>

接下来要读什么

使用 Spring Session 的群集会话

1. 身份验证后执行重定向的机制（如 form-login）的身份验证不会被检测到，因为在身份验证请求期间不会调用过滤器。在这些情况下，会话管理功能必须单独处理。SessionManagementFilter

了解会话管理的组件

这SessionManagementFilter

远离SessionManagementFilter

搬离时要考虑的事项SessionManagementFilter

自定义身份验证的存储位置

手动存储Authentication

正确清除身份验证

为无状态身份验证配置持久性

在会话中存储无状态身份验证

了解需要显式保存

运作方式

配置并发会话控制

检测超时

自定义无效会话策略

在注销时清除会话 Cookie

了解会话固定攻击防护

配置会话固定保护

用SecurityContextHolderStrategy

强制创建紧急会话

接下来要读什么

这`SessionManagementFilter`

远离`SessionManagementFilter`

搬离时要考虑的事项`SessionManagementFilter`

手动存储`Authentication`

用`SecurityContextHolderStrategy`