此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Security 6.4.1！spring-doc.cn

架构

本节讨论 Spring Security 在基于 Servlet 的应用程序中的高级体系结构。 我们在参考的 Authentication， Authorization， and Protection against Exploits 部分中建立了这种高级理解。spring-doc.cn

过滤器回顾

Spring Security 的 Servlet 支持基于 Servlet 过滤器，因此通常首先查看过滤器的角色会很有帮助。 下图显示了单个 HTTP 请求的处理程序的典型分层。spring-doc.cn

filterchain （筛选链）
图 1.FilterChain （筛选链）

客户端向应用程序发送请求，容器创建一个包含实例的 ，并且该容器应根据请求 URI 的路径处理 。 在 Spring MVC 应用程序中，它是 DispatcherServlet 的实例。 最多可以处理单个 和 。 但是，可以使用多个 API 来：FilterChainFilterServletHttpServletRequestServletServletHttpServletRequestHttpServletResponseFilterspring-doc.cn

  • 防止下游实例或 被调用。 在这种情况下，通常会写入 .FilterServletFilterHttpServletResponsespring-doc.cn

  • 修改下游实例使用的 or 和 .HttpServletRequestHttpServletResponseFilterServletspring-doc.cn

力量来自传递给它的东西。FilterFilterChainspring-doc.cn

FilterChain使用示例
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
	// do something before the rest of the application
    chain.doFilter(request, response); // invoke the rest of the application
    // do something after the rest of the application
}
fun doFilter(request: ServletRequest, response: ServletResponse, chain: FilterChain) {
    // do something before the rest of the application
    chain.doFilter(request, response) // invoke the rest of the application
    // do something after the rest of the application
}

由于 a 仅影响下游实例和 ，因此调用每个实例的顺序非常重要。FilterFilterServletFilterspring-doc.cn

委托过滤器代理

Spring 提供了一个名为 DelegatingFilterProxy 的实现，它允许在 Servlet 容器的生命周期和 Spring 的生命周期之间进行桥接。 Servlet 容器允许使用自己的标准注册实例，但它不知道 Spring 定义的 Bean。 您可以通过标准的 Servlet 容器机制进行注册，但将所有工作委托给实现 .FilterApplicationContextFilterDelegatingFilterProxyFilterspring-doc.cn

下面是如何适应 Filter 实例和 FilterChain 的图片。DelegatingFilterProxyspring-doc.cn

DelegatingFilterProxy
图 2.委托过滤器代理

DelegatingFilterProxy查找Bean 过滤器0从 和 然后调用ApplicationContextBean 过滤器0. 下面的清单显示了 的伪代码：DelegatingFilterProxyspring-doc.cn

DelegatingFilterProxy伪代码
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
	Filter delegate = getFilterBean(someBeanName); (1)
	delegate.doFilter(request, response); (2)
}
fun doFilter(request: ServletRequest, response: ServletResponse, chain: FilterChain) {
	val delegate: Filter = getFilterBean(someBeanName) (1)
	delegate.doFilter(request, response) (2)
}
1 延迟获取已注册为 Spring Bean 的 Filter。 对于 DelegatingFilterProxy 中的示例，它是delegateBean 过滤器0.
2 将工作委托给 Spring Bean。

另一个好处是它允许延迟查找 bean 实例。 这一点很重要，因为容器需要先注册实例，然后才能启动容器。 但是， Spring 通常使用 a 来加载 Spring Bean，直到需要注册实例后才会完成。DelegatingFilterProxyFilterFilterContextLoaderListenerFilterspring-doc.cn

FilterChainProxy

Spring Security 的 Servlet 支持包含在 中。 是 Spring Security 提供的特殊功能，它允许通过SecurityFilterChain委托给许多实例。 由于 是一个 Bean，因此它通常包装在 DelegatingFilterProxy 中。FilterChainProxyFilterChainProxyFilterFilterFilterChainProxyspring-doc.cn

下图显示了 的角色。FilterChainProxyspring-doc.cn

filterchainproxy
图 3.FilterChainProxy

SecurityFilterChain 安全过滤器链

SecurityFilterChainProxy使用FilterChain来确定应该为当前请求调用哪些 Spring Security 实例。Filterspring-doc.cn

下图显示了 的角色。SecurityFilterChainspring-doc.cn

SecurityFilterChain 安全过滤器链
图 4.SecurityFilterChain 安全过滤器链

中的安全过滤器通常是 Bean，但它们是用 DelegatingFilterProxy 而不是 DelegatingFilterProxy 注册的。 为直接向 Servlet 容器或 DelegatingFilterProxy 注册提供了许多优势。 首先，它为 Spring Security 的所有 Servlet 支持提供了一个起点。 因此，如果您尝试对 Spring Security 的 Servlet 支持进行故障排除，则添加调试点是一个很好的起点。SecurityFilterChainFilterChainProxyFilterChainProxyFilterChainProxyspring-doc.cn

其次，由于它是 Spring Security 使用的核心，因此它可以执行不被视为可选的任务。 例如，它会清除 以避免内存泄漏。 它还应用 Spring Security 的 HttpFirewall 来保护应用程序免受某些类型的攻击。FilterChainProxySecurityContextspring-doc.cn

此外，它还在确定何时应调用 a 方面提供了更大的灵活性。 在 Servlet 容器中，仅根据 URL 调用实例。 但是，可以使用该接口根据 中的任何内容来确定调用。SecurityFilterChainFilterFilterChainProxyHttpServletRequestRequestMatcherspring-doc.cn

下图显示了多个实例：SecurityFilterChainspring-doc.cn

Multi SecurityFilterChain
图 5.多个 SecurityFilterChain

在 Multiple SecurityFilterChain 图中，决定应该使用哪个。 仅调用第一个匹配项。 如果请求 URL ，则它首先匹配 的模式，因此仅调用，即使它也匹配 。 如果请求的 URL 为 ，则它与 的模式不匹配，因此请继续尝试每个 。 假设没有其他实例匹配，则调用。FilterChainProxySecurityFilterChainSecurityFilterChain/api/messages/SecurityFilterChain0/api/**SecurityFilterChain0SecurityFilterChainn/messages/SecurityFilterChain0/api/**FilterChainProxySecurityFilterChainSecurityFilterChainSecurityFilterChainnspring-doc.cn

请注意，它只配置了三个安全实例。 但是，配置了四个安全实例。 请务必注意，每个 Cookie 都可以是唯一的，并且可以单独配置。 事实上，如果应用程序希望 Spring Security 忽略某些请求，则 a 可能没有安全实例。SecurityFilterChain0FilterSecurityFilterChainnFilterSecurityFilterChainSecurityFilterChainFilterspring-doc.cn

安全过滤器

安全筛选器使用 SecurityFilterChain API 插入到 FilterChainProxy 中。 这些过滤器可用于许多不同的目的，例如漏洞利用保护、身份验证、授权等。 过滤器按特定顺序执行，以确保它们在正确的时间调用，例如，应在执行授权的 之前调用执行身份验证的 。 通常不需要知道 Spring Security 的 Sequences。 但是，有时了解顺序是有益的，如果您想了解它们，您可以查看 FilterOrderRegistration 代码。FilterFilterFilterspring-doc.cn

这些安全筛选器通常使用 HttpSecurity 实例进行声明。 为了举例说明上述段落，让我们考虑以下安全配置：spring-doc.cn

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(Customizer.withDefaults())
            .httpBasic(Customizer.withDefaults())
            .formLogin(Customizer.withDefaults())
            .authorizeHttpRequests(authorize -> authorize
                .anyRequest().authenticated()
            );

        return http.build();
    }

}
import org.springframework.security.config.web.servlet.invoke

@Configuration
@EnableWebSecurity
class SecurityConfig {

    @Bean
    fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            csrf { }
            httpBasic { }
            formLogin { }
            authorizeHttpRequests {
                authorize(anyRequest, authenticated)
            }
        }
        return http.build()
    }

}

上述配置将导致以下排序：Filterspring-doc.cn

Filter 添加者

Csrf过滤器spring-doc.cn

HttpSecurity#csrfspring-doc.cn

用户名密码身份验证过滤器spring-doc.cn

HttpSecurity#formLoginspring-doc.cn

BasicAuthenticationFilterspring-doc.cn

HttpSecurity#httpBasicspring-doc.cn

AuthorizationFilterspring-doc.cn

HttpSecurity#authorizeHttpRequestsspring-doc.cn

  1. 首先，调用 the 来防止 CSRF 攻击。CsrfFilterspring-doc.cn

  2. 其次，调用身份验证筛选器来验证请求。spring-doc.cn

  3. 第三，调用 AuthorizationFilter 来授权请求。spring-doc.cn

可能还有其他未在上面列出的实例。 如果要查看为特定请求调用的过滤器列表，可以打印它们。Filterspring-doc.cn

打印安全过滤器

通常，查看为特定请求调用的安全列表非常有用。 例如，您希望确保已添加的过滤器位于安全过滤器列表中。Filterspring-doc.cn

筛选器列表在应用程序启动时以 DEBUG 级别打印，因此您可以在控制台输出上看到如下内容，例如：spring-doc.cn

2023-06-14T08:55:22.321-03:00  DEBUG 76975 --- [           main] o.s.s.web.DefaultSecurityFilterChain     : Will secure any request with [ DisableEncodeUrlFilter, WebAsyncManagerIntegrationFilter, SecurityContextHolderFilter, HeaderWriterFilter, CsrfFilter, LogoutFilter, UsernamePasswordAuthenticationFilter, DefaultLoginPageGeneratingFilter, DefaultLogoutPageGeneratingFilter, BasicAuthenticationFilter, RequestCacheAwareFilter, SecurityContextHolderAwareRequestFilter, AnonymousAuthenticationFilter, ExceptionTranslationFilter, AuthorizationFilter]

这将很好地了解为每个过滤器链配置的安全过滤器。spring-doc.cn

但这还不是全部，您还可以将应用程序配置为打印每个请求的每个单独筛选条件的调用。 这有助于查看是否为特定请求调用了已添加的筛选器，或者检查异常的来源。 为此，您可以将应用程序配置为记录安全事件。spring-doc.cn

将过滤器添加到过滤器链

大多数情况下，默认的 Security Filters 足以为您的应用程序提供安全性。 但是，有时您可能希望向 SecurityFilterChain 添加自定义。Filterspring-doc.cn

HttpSecurity 提供了三种添加过滤器的方法：spring-doc.cn

  • #addFilterBefore(Filter, Class<?>)在另一个过滤器之前添加您的过滤器spring-doc.cn

  • #addFilterAfter(Filter, Class<?>)在另一个过滤器之后添加您的过滤器spring-doc.cn

  • #addFilterAt(Filter, Class<?>)将另一个过滤器替换为您的过滤器spring-doc.cn

添加自定义过滤器

如果要创建自己的过滤器，则需要确定它在过滤器链中的位置。 请查看筛选条件链中发生的以下关键事件：spring-doc.cn

  1. SecurityContext 从会话中加载spring-doc.cn

  2. 请求受到保护，免受常见漏洞的攻击;安全标头、CORS、CSRFspring-doc.cn

  3. 请求已验证spring-doc.cn

  4. 请求已获得授权spring-doc.cn

考虑您需要发生哪些事件才能找到您的过滤器。 以下是经验法则：spring-doc.cn

如果您的过滤器是 a（n） 然后把它放在 由于这些事件已经发生

Exploit Protection 筛选器spring-doc.cn

SecurityContextHolderFilterspring-doc.cn

1spring-doc.cn

身份验证筛选器spring-doc.cn

LogoutFilterspring-doc.cn

1, 2spring-doc.cn

授权过滤器spring-doc.cn

匿名身份验证过滤器spring-doc.cn

1, 2, 3spring-doc.cn
最常见的是，应用程序会添加自定义身份验证。 这意味着它们应该放在 LogoutFilter 之后。

例如，假设您要添加一个获取租户 ID 标头的 URL，并检查当前用户是否有权访问该租户。Filterspring-doc.cn

首先，让我们创建 ：Filterspring-doc.cn

import java.io.IOException;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import org.springframework.security.access.AccessDeniedException;

public class TenantFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        String tenantId = request.getHeader("X-Tenant-Id"); (1)
        boolean hasAccess = isUserAllowed(tenantId); (2)
        if (hasAccess) {
            filterChain.doFilter(request, response); (3)
            return;
        }
        throw new AccessDeniedException("Access denied"); (4)
    }

}

上面的示例代码执行以下操作：spring-doc.cn

1 从请求标头中获取租户 ID。
2 检查当前用户是否有权访问租户 ID。
3 如果用户具有访问权限，则调用链中的其余筛选器。
4 如果用户没有访问权限，则抛出 .AccessDeniedException

您可以从 OncePerRequestFilter 扩展，而不是实现 ，OncePerRequestFilter 是过滤器的基类，每个请求仅调用一次，并提供带有 和 参数的方法。FilterdoFilterInternalHttpServletRequestHttpServletResponsespring-doc.cn

现在，您需要将过滤器添加到 SecurityFilterChain 中。 前面的描述已经给了我们在哪里添加过滤器的线索，因为我们需要知道当前用户，所以我们需要在认证过滤器之后添加它。spring-doc.cn

根据经验法则，将其添加到链中的最后一个身份验证筛选器 AnonymousAuthenticationFilter 之后，如下所示：spring-doc.cn

@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
        // ...
        .addFilterAfter(new TenantFilter(), AnonymousAuthenticationFilter.class); (1)
    return http.build();
}
@Bean
fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http
        // ...
        .addFilterAfter(TenantFilter(), AnonymousAuthenticationFilter::class.java) (1)
    return http.build()
}
1 用于在 .HttpSecurity#addFilterAfterTenantFilterAnonymousAuthenticationFilter

通过在 AnonymousAuthenticationFilter 之后添加过滤器，我们确保在身份验证过滤器之后调用 。TenantFilterspring-doc.cn

就是这样，现在将在过滤器链中调用 ，并检查当前用户是否有权访问租户 ID。TenantFilterspring-doc.cn

将 Filter 声明为 Bean

当你将 a 声明为 Spring bean 时，无论是通过注释它还是在配置中将其声明为 bean，Spring Boot 都会自动将其注册到嵌入式容器中。 这可能会导致过滤器被调用两次，一次由容器调用，一次由 Spring Security 调用，并且顺序不同。Filter@Componentspring-doc.cn

因此，过滤器通常不是 Spring bean。spring-doc.cn

但是，如果你的过滤器需要是一个 Spring bean（例如，为了利用依赖注入），你可以通过声明一个 bean 并将其属性设置为来告诉 Spring Boot 不要在容器中注册它：FilterRegistrationBeanenabledfalsespring-doc.cn

@Bean
public FilterRegistrationBean<TenantFilter> tenantFilterRegistration(TenantFilter filter) {
    FilterRegistrationBean<TenantFilter> registration = new FilterRegistrationBean<>(filter);
    registration.setEnabled(false);
    return registration;
}

这使得 这是唯一添加它的人。HttpSecurityspring-doc.cn

自定义 Spring Security 过滤器

通常，您可以使用过滤器的 DSL 方法来配置 Spring Security 的过滤器。 例如，最简单的添加方法是让 DSL 来做这件事：BasicAuthenticationFilterspring-doc.cn

@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
	http
		.httpBasic(Customizer.withDefaults())
        // ...

	return http.build();
}
@Bean
fun filterChain(http: HttpSecurity): SecurityFilterChain {
	http {
        httpBasic { }
        // ...
	}

	return http.build()
}

但是，如果您想自己构建 Spring Security 过滤器，则可以在 DSL 中使用如下方式指定它：addFilterAtspring-doc.cn

@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
	BasicAuthenticationFilter basic = new BasicAuthenticationFilter();
	// ... configure

	http
		// ...
		.addFilterAt(basic, BasicAuthenticationFilter.class);

	return http.build();
}
@Bean
fun filterChain(http: HttpSecurity): SecurityFilterChain {
	val basic = BasicAuthenticationFilter()
	// ... configure

	http
		// ...
		.addFilterAt(basic, BasicAuthenticationFilter::class.java)

	return http.build()
}

请注意，如果已经添加了该过滤器，则 Spring Security 将引发异常。 例如，调用 HttpSecurity#httpBasic 会为您添加一个。 因此，以下安排失败，因为有两个调用都尝试添加：BasicAuthenticationFilterBasicAuthenticationFilterspring-doc.cn

@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
	BasicAuthenticationFilter basic = new BasicAuthenticationFilter();
	// ... configure

	http
		.httpBasic(Customizer.withDefaults())
		// ... on no! BasicAuthenticationFilter is added twice!
		.addFilterAt(basic, BasicAuthenticationFilter.class);

	return http.build();
}
@Bean
fun filterChain(http: HttpSecurity): SecurityFilterChain {
	val basic = BasicAuthenticationFilter()
	// ... configure

	http {
		httpBasic { }
	}

	// ... on no! BasicAuthenticationFilter is added twice!
    http.addFilterAt(basic, BasicAuthenticationFilter::class.java)

	return http.build()
}

在这种情况下，请删除对 since you are constructing yourself 的调用。httpBasicBasicAuthenticationFilterspring-doc.cn

如果您无法重新配置以不添加某个过滤器，则通常可以通过调用其 DSL 的方法禁用 Spring Security 过滤器，如下所示：HttpSecuritydisablespring-doc.cn

.httpBasic((basic) -> basic.disable())

处理安全异常

ExceptionTranslationFilter 允许将 AccessDeniedException 和 AuthenticationException 转换为 HTTP 响应。spring-doc.cn

ExceptionTranslationFilter作为安全筛选器之一插入到 FilterChainProxy 中。spring-doc.cn

下图显示了 与其他组件的关系：ExceptionTranslationFilterspring-doc.cn

exceptiontranslationfilter

  • 数字 1首先，调用 以调用应用程序的其余部分。ExceptionTranslationFilterFilterChain.doFilter(request, response)spring-doc.cn

  • 编号 2如果用户未经过身份验证或用户是 ，则开始身份验证。AuthenticationExceptionspring-doc.cn

  • 编号 3否则，如果它是 ，则为 Access Denied。 调用 以处理被拒绝的访问。AccessDeniedExceptionAccessDeniedHandlerspring-doc.cn

如果应用程序不抛出 an 或 an ，则不执行任何操作。AccessDeniedExceptionAuthenticationExceptionExceptionTranslationFilterspring-doc.cn

的伪代码如下所示：ExceptionTranslationFilterspring-doc.cn

ExceptionTranslationFilter 伪代码
try {
	filterChain.doFilter(request, response); (1)
} catch (AccessDeniedException | AuthenticationException ex) {
	if (!authenticated || ex instanceof AuthenticationException) {
		startAuthentication(); (2)
	} else {
		accessDenied(); (3)
	}
}
1 如 筛选器回顾 中所述，调用等效于调用应用程序的其余部分。 这意味着，如果应用程序的另一部分（FilterSecurityInterceptor或方法安全性）抛出OR，则会在此处捕获并处理它。FilterChain.doFilter(request, response)AuthenticationExceptionAccessDeniedException
2 如果用户未经过身份验证，或者用户是 Start Authentication。AuthenticationException
3 否则，Access Denied （访问被拒绝）

在身份验证之间保存请求

如处理安全异常中所述，当请求没有身份验证并且针对需要身份验证的资源时，需要保存请求，以便经过身份验证的资源在身份验证成功后重新请求。 在 Spring Security 中，这是通过使用 RequestCache 实现保存来完成的。HttpServletRequestspring-doc.cn

请求缓存

保存在 RequestCache 中。 当用户成功进行身份验证时，将使用 重播原始请求。 RequestCacheAwareFilter 在用户进行身份验证后使用 to get saved，而 在 将用户重定向到登录端点之前，使用 to save after it detect 。HttpServletRequestRequestCacheRequestCacheHttpServletRequestExceptionTranslationFilterRequestCacheHttpServletRequestAuthenticationExceptionspring-doc.cn

默认情况下，使用 an。 下面的代码演示了如何自定义用于检查 for a saved 请求的 for a saved 请求（如果存在 named 的参数）。HttpSessionRequestCacheRequestCacheHttpSessioncontinuespring-doc.cn

RequestCache如果参数存在，则仅检查保存的请求continue
@Bean
DefaultSecurityFilterChain springSecurity(HttpSecurity http) throws Exception {
	HttpSessionRequestCache requestCache = new HttpSessionRequestCache();
	requestCache.setMatchingRequestParameterName("continue");
	http
		// ...
		.requestCache((cache) -> cache
			.requestCache(requestCache)
		);
	return http.build();
}
@Bean
open fun springSecurity(http: HttpSecurity): SecurityFilterChain {
    val httpRequestCache = HttpSessionRequestCache()
    httpRequestCache.setMatchingRequestParameterName("continue")
    http {
        requestCache {
            requestCache = httpRequestCache
        }
    }
    return http.build()
}
<http auto-config="true">
	<!-- ... -->
	<request-cache ref="requestCache"/>
</http>

<b:bean id="requestCache" class="org.springframework.security.web.savedrequest.HttpSessionRequestCache"
	p:matchingRequestParameterName="continue"/>

阻止保存请求

出于多种原因，您可能希望不在会话中存储用户的未经身份验证的请求。 您可能希望将该存储卸载到用户的浏览器上或将其存储在数据库中。 或者您可能希望关闭此功能，因为您总是希望将用户重定向到主页，而不是他们在登录前尝试访问的页面。spring-doc.cn

为此，您可以使用 NullRequestCache 实现。spring-doc.cn

阻止保存请求
@Bean
SecurityFilterChain springSecurity(HttpSecurity http) throws Exception {
    RequestCache nullRequestCache = new NullRequestCache();
    http
        // ...
        .requestCache((cache) -> cache
            .requestCache(nullRequestCache)
        );
    return http.build();
}
@Bean
open fun springSecurity(http: HttpSecurity): SecurityFilterChain {
    val nullRequestCache = NullRequestCache()
    http {
        requestCache {
            requestCache = nullRequestCache
        }
    }
    return http.build()
}
<http auto-config="true">
	<!-- ... -->
	<request-cache ref="nullRequestCache"/>
</http>

<b:bean id="nullRequestCache" class="org.springframework.security.web.savedrequest.NullRequestCache"/>

RequestCacheAwareFilter

RequestCacheAwareFilter使用RequestCache重播原始请求。spring-doc.cn

Logging

Spring Security 在 DEBUG 和 TRACE 级别提供了所有与安全相关的事件的全面日志记录。 这在调试应用程序时非常有用，因为为了安全措施， Spring Security 不会在响应正文中添加请求被拒绝原因的任何详细信息。 如果您遇到 401 或 403 错误，您很可能会找到一条日志消息，帮助您了解发生了什么。spring-doc.cn

让我们考虑一个例子，用户尝试向启用了 CSRF 保护的资源发出请求，但没有 CSRF 令牌。 如果没有日志，用户将看到 403 错误，并且没有解释请求被拒绝的原因。 但是，如果为 Spring Security 启用日志记录，则会看到如下日志消息：POSTspring-doc.cn

2023-06-14T09:44:25.797-03:00 DEBUG 76975 --- [nio-8080-exec-1] o.s.security.web.FilterChainProxy        : Securing POST /hello
2023-06-14T09:44:25.797-03:00 TRACE 76975 --- [nio-8080-exec-1] o.s.security.web.FilterChainProxy        : Invoking DisableEncodeUrlFilter (1/15)
2023-06-14T09:44:25.798-03:00 TRACE 76975 --- [nio-8080-exec-1] o.s.security.web.FilterChainProxy        : Invoking WebAsyncManagerIntegrationFilter (2/15)
2023-06-14T09:44:25.800-03:00 TRACE 76975 --- [nio-8080-exec-1] o.s.security.web.FilterChainProxy        : Invoking SecurityContextHolderFilter (3/15)
2023-06-14T09:44:25.801-03:00 TRACE 76975 --- [nio-8080-exec-1] o.s.security.web.FilterChainProxy        : Invoking HeaderWriterFilter (4/15)
2023-06-14T09:44:25.802-03:00 TRACE 76975 --- [nio-8080-exec-1] o.s.security.web.FilterChainProxy        : Invoking CsrfFilter (5/15)
2023-06-14T09:44:25.814-03:00 DEBUG 76975 --- [nio-8080-exec-1] o.s.security.web.csrf.CsrfFilter         : Invalid CSRF token found for http://localhost:8080/hello
2023-06-14T09:44:25.814-03:00 DEBUG 76975 --- [nio-8080-exec-1] o.s.s.w.access.AccessDeniedHandlerImpl   : Responding with 403 status code
2023-06-14T09:44:25.814-03:00 TRACE 76975 --- [nio-8080-exec-1] o.s.s.w.header.writers.HstsHeaderWriter  : Not injecting HSTS header since it did not match request to [Is Secure]

很明显，CSRF 令牌丢失了，这就是请求被拒绝的原因。spring-doc.cn

要将应用程序配置为记录所有安全事件，可以将以下内容添加到应用程序中：spring-doc.cn

Spring Boot 中的 application.properties
logging.level.org.springframework.security=TRACE
logback.xml
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- ... -->
    </appender>
    <!-- ... -->
    <logger name="org.springframework.security" level="trace" additivity="false">
        <appender-ref ref="Console" />
    </logger>
</configuration>