Spring Security 6 整理

最新推荐文章于 2025-11-10 15:03:29 发布
原创 最新推荐文章于 2025-11-10 15:03:29 发布 · 1k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#1024程序员节 #java #spring security

Spring Security

Spring Security 是一个功能强大且易于使用的框架，能够帮助开发者提高应用程序的安全性和可靠性。无论是简单的身份验证需求，还是复杂的安全策略，Spring Security 都能提供相应的解决方案。

使用 spring boot 版本

    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>3.5.6</version>
    </parent>

Spring Security 依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

Spring Security 过滤链架构

在这里插入图片描述

DelegatingFilterProxy（代理过滤器）

Servlet 容器（如 Tomcat）自身的过滤器（Filter）是由容器直接创建和管理的，而 Spring 应用中的大部分组件（如 Service、Bean 等）是由 Spring 容器管理的。如果我们想让过滤器使用 Spring 容器中的 Bean（例如依赖注入 UserDetailsService 进行认证），直接注册原生 Filter 会面临一个问题：
Servlet 容器无法直接访问 Spring 容器中的 Bean，因为两者的生命周期和管理机制完全独立
DelegatingFilterProxy 正是为了解决这个问题而设计的 ，它作为 Servlet 容器和 Spring 容器之间的 “桥梁”，让过滤器的实际逻辑由 Spring 容器中的 Bean 来实现
DelegatingFilterProxy 本身并不处理具体的过滤逻辑，而是委托给 Spring 容器中一个真正的过滤器 Bean 来执行

FilterChainProxy（安全过滤链的总调度器）

FilterChainProxy 本身是一个由 Spring 容器管理的 Filter 实现类，但它不直接处理安全逻辑，而是管理多个 “安全过滤器链”（SecurityFilterChain），并根据请求的特征（如路径）匹配对应的链，再按顺序执行链中的过滤器。

springSecurityFilterChain (Bean名)
在这里插入图片描述

springSecurityFilterChain 是一个特殊的 Bean 名称，它指向的是 FilterChainProxy 类型的实例（即 Spring Security 核心的过滤链调度器）

FilterChainProxy 与SecurityFilterChain的关系：
FilterChainProxy 是 “总调度器”，内部维护一个 List<SecurityFilterChain>；
当请求到达时，FilterChainProxy 遍历所有 SecurityFilterChain，通过 matches 方法找到第一个匹配的链；
然后执行该链中 getFilters() 返回的过滤器（按顺序执行）。

补充：
可以配置多个SecurityFilterChain，官方文档
在这里插入图片描述

SecurityFilterChain（“请求范围 + 过滤器集合” 的基本单元）

SecurityFilterChain 是 Spring Security 中定义 “一组安全过滤器及其适用范围” 的核心接口，它是 FilterChainProxy 管理的最小单元，用于描述 “哪些请求需要经过哪些安全过滤器”。

public interface SecurityFilterChain {
    // 判断当前请求是否匹配该过滤器链
    boolean matches(HttpServletRequest request);
    // 返回该链中包含的所有安全过滤器（按执行顺序排列）
    List<Filter> getFilters();
}

默认过滤链

如果不配置 Spring Security，只要引入了 Spring Security 依赖就会创建16个默认过滤链，如下：
在这里插入图片描述
在 Spring Security 过滤器链中，会按顺序执行以上过滤链条。如果客户端发出一个请求，就会按顺序经过这些过滤链，顺利通过则到达控制层返回结果。有两种情况会中断过滤链：1.抛异常会中断 2.主动不调用下一个过滤器，中断后就不会到达控制层就不会返回结果，而是异常处理器捕获异常，给客户端返回异常信息，比如密码错误等信息

认证流程图

以UsernamePasswordAuthenticationFilter情况举例：

在这里插入图片描述

鉴权流程图

这两个代码是等价的
在这里插入图片描述
以上配置了会按下面的方式进行鉴权
在这里插入图片描述

核心接口与类

认证接口

AuthenticationManager

AuthenticationManager 是 Spring Security 中负责认证逻辑核心决策的接口，它是认证过程的 “入口点”，主要作用是接收认证请求（Authentication 对象），并返回认证成功的结果或抛出认证失败的异常。

@FunctionalInterface
public interface AuthenticationManager 
{
	//唯一的方法，承担认证的核心逻辑，参数和返回值均为 Authentication 类型，这是 Spring Security 中表示 “认证信息” 的核心类。
    Authentication authenticate(Authentication authentication) throws AuthenticationException;
}

运行步骤：

  1. 接收一个未认证的 Authentication 对象（包含用户提交的凭据，如用户名、密码、令牌等）；
  2. 执行认证逻辑（如调用 UserDetailsService 加载用户信息、比对密码、验证令牌有效性等）；
  3. 认证成功：返回一个已认证的 Authentication 对象（包含用户身份、权限等信息）；
    认证失败：抛出 AuthenticationException 异常（如 BadCredentialsException 密码错误、UsernameNotFoundException 用户不存在等）。

使用方法：
若后续需要开发自定义登录接口（如前后端分离场景的 JSON 登录）

	// 显式暴露 AuthenticationManager 为 Spring Bean，供应用中其他组件（如控制器、服务）注入使用
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
        // AuthenticationConfiguration 是 Spring Security 自动配置的核心类，负责构建 AuthenticationManager
        // 通过 getAuthenticationManager() 方法获取其自动配置的实例，该实例已整合：
        // 1. 本类中定义的 UserDetailsService（此处为基于内存的用户服务）
        // 2. 密码编码器（当前示例使用 {noop} 表示不加密，生产环境需配置 PasswordEncoder）
        // 3. 认证提供者（默认使用 DaoAuthenticationProvider，通过 UserDetailsService 加载用户信息）
        return authenticationConfiguration.getAuthenticationManager();
    }

可注入此 AuthenticationManager 手动触发认证：

@Autowired
private AuthenticationManager authenticationManager;

// 自定义登录接口
@PostMapping("/api/login")
public String customLogin(@RequestBody LoginRequest request) {
    // 构建认证请求对象
    UsernamePasswordAuthenticationToken authRequest = 
        new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword());
    // 调用 AuthenticationManager 执行认证
    Authentication authentication = authenticationManager.authenticate(authRequest);
    // 将认证结果存入 SecurityContext
    SecurityContextHolder.getContext().setAuthentication(authentication);
    return "登录成功";
}

AuthenticationProvider

AuthenticationProvider 是 Spring Security 中负责执行具体认证逻辑的核心接口，它是认证流程的 “实际执行者”，与 AuthenticationManager、UserDetailsService 等组件紧密配合，完成用户名密码校验、令牌验证等具体认证操作

public interface AuthenticationProvider {
    /**
     * 执行具体的认证逻辑
     * @param authentication 待认证的信息（如用户名密码、令牌等）
     * @return 已认证的 Authentication 对象（包含权限等信息）
     * @throws AuthenticationException 认证失败时抛出
     */
    Authentication authenticate(Authentication authentication) throws AuthenticationException;

    /**
     * 判断当前 Provider 是否支持某种 Authentication 类型
     * @param authentication 待认证的类型
     * @return true 表示支持，会调用上面的 authenticate 方法
     */
    boolean supports(Class<?> authentication);
}

核心过程：

  1. 接收未认证的 Authentication 对象（如 UsernamePasswordAuthenticationToken 包含的用户名密码）。
  2. 执行具体认证逻辑（如校验密码、验证令牌签名、检查用户状态等）。
  3. 认证成功则返回已认证的 Authentication 对象（填充权限、用户信息等）；失败则抛出 AuthenticationException（如密码错误、用户锁定）。

Authentication

Authentication 接口是 Spring Security 认证流程的 “数据载体”，贯穿整个认证过程：

  1. 认证前：通常由用户输入构建（如 UsernamePasswordAuthenticationToken 实现类，包含用户名 principal 和密码 credentials，authorities 为空，isAuthenticated 为 false）。
  2. 认证中：AuthenticationManager 接收该对象，执行验证逻辑。
  3. 认证后：验证通过后，principal 可能更新为完整用户对象，authorities 填充实际权限，credentials 可能被清空，isAuthenticated 设为 true。
public interface Authentication extends Principal, Serializable {
    // 获取当前用户拥有的权限集合,例如 "ROLE_USER"、"ROLE_ADMIN" 或具体操作权限 "user:read"
    Collection<? extends GrantedAuthority> getAuthorities(); 
    // 凭证（如用户输入的原始密码 ，String 类型的密码、JWT 令牌等）认证成功后，为了安全起见，该信息可能会被清空（例如密码验证通过后不再保留）
    Object getCredentials(); 
    // 额外信息（如请求 IP、会话 ID）通常是用户名（String 类型）或用户实体对象（如自定义的 User 类），认证成功后，该信息会被保留用于标识当前用户。
    Object getDetails(); 
    // 身份标识（未认证时可能是用户名，认证后通常是 UserDetails）
    Object getPrincipal();     
    // 是否已认证
    boolean isAuthenticated(); 
    // 设置认证状态
    void setAuthenticated(boolean isAuthenticated); 
}

UserDetails

用于封装从数据源（如数据库、缓存）加载的用户静态信息，是系统中 “用户数据” 的标准化表示。

public interface UserDetails extends Serializable {
    String getUsername(); // 用户名
    String getPassword(); // 加密后的密码
    Collection<? extends GrantedAuthority> getAuthorities(); // 权限列表
    boolean isAccountNonExpired(); // 账号是否未过期
    boolean isAccountNonLocked(); // 账号是否未锁定
    boolean isCredentialsNonExpired(); // 密码是否未过期
    boolean isEnabled(); // 账号是否启用
}

UserDetailsService

UserDetailsService 是负责加载用户信息的核心接口，是认证流程中连接 “用户数据源” 与 “认证逻辑” 的关键桥梁。它的主要作用是根据用户名从数据源（如数据库、缓存、LDAP 等）中查询用户的详细信息（用户名、密码、权限、账号状态等），为认证提供必要的用户数据。

/**
 * Spring Security核心接口：用于加载用户特定数据的策略接口
 * 作为用户数据访问对象(DAO)的抽象，被{@link org.springframework.security.authentication.dao.DaoAuthenticationProvider}等认证提供者使用
 * 实现类需提供根据用户名查询用户完整信息的逻辑（如从数据库、缓存或其他数据源获取）
 */
public interface UserDetailsService {

	/**
	 * 根据用户名定位用户并加载其详细信息
	 * 实际实现中，用户名搜索可能区分大小写或不区分大小写，具体取决于实现类的配置
	 * 返回的UserDetails对象中的用户名可能与请求的用户名大小写不同（如数据库存储为大写，请求为小写）
	 * 
	 * @param username 用于标识所需用户数据的用户名（不能为空）
	 * @return 完全填充的用户记录（必须非null，需包含用户名、密码、权限等认证所需信息，如您项目中的{@link org.example.pojo.CustomUser}）
	 * @throws UsernameNotFoundException 如果用户不存在，或用户没有任何权限
	 */
	UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;

}

SecurityContextHolder（不是接口）

SecurityContextHolder 是 Spring Security 中用于存储和访问当前用户认证信息（SecurityContext） 的核心工具类，它提供了线程安全的方式来管理用户的安全上下文，是连接认证流程与后续权限校验的关键组件

核心方法

方法说明
getContext()获取当前线程绑定的 SecurityContext 对象（包含当前用户的 Authentication）
setContext(SecurityContext context)为当前线程设置 SecurityContext（通常由 Spring Security 内部调用，如认证成功后）
clearContext()清除当前线程的 SecurityContext（如用户登出时）
getContextHolderStrategy()获取当前使用的 SecurityContext 存储策略（默认是线程绑定）

补充：
SecurityContextHolder → 持有 SecurityContext → 持有 Authentication（用户认证信息）。

授权接口

AuthorizationManager

在 Spring Security 6 中，AuthorizationManager 是用于权限校验的核心接口，它替代了 Spring Security 5 及之前版本中的 AccessDecisionManager，负责判断当前用户是否有权限访问特定资源（如请求、方法、URL 等）和AccessDecisionVoter

// 授权管理器接口：判断当前登录用户（Authentication）是否有权访问某个资源（如接口、页面）
@FunctionalInterface
public interface AuthorizationManager<T> {

    /**
     * 验证权限：无权限时直接抛异常
     * @param authentication 提供当前用户认证信息的对象（含用户身份、权限）
     * @param object 要访问的资源（如HttpServletRequest、接口路径等）
     */
    default void verify(Supplier<Authentication> authentication, T object) {
        // 先调用check方法判断权限，得到决策结果
        AuthorizationDecision decision = check(authentication, object);
        // 若决策结果存在且为“拒绝访问”，抛出授权失败异常
        if (decision != null && !decision.isGranted()) {
            throw new AuthorizationDeniedException("Access Denied", decision);
        }
    }

    /**
     * （已过时）检查权限：返回决策结果（允许/拒绝），不抛异常
     * @param authentication 提供当前用户认证信息的对象
     * @param object 要访问的资源
     * @return 授权决策结果，null表示未做判断
     */
    @Nullable
    @Deprecated
    AuthorizationDecision check(Supplier<Authentication> authentication, T object);

    /**
     * 检查权限（替代过时的check方法）：返回决策结果，不抛异常
     * @param authentication 提供当前用户认证信息的对象
     * @param object 要访问的资源
     * @return 授权决策结果，null表示未做判断
     */
    @Nullable
    default AuthorizationResult authorize(Supplier<Authentication> authentication, T object) {
        // 默认调用旧的check方法，实现权限检查逻辑
        return check(authentication, object);
    }

}

自定义 AuthorizationManager

// 自定义授权管理器：仅允许特定用户访问
public class CustomAuthorizationManager implements AuthorizationManager<HttpServletRequest> {

    @Override
    AuthorizationResult authorize(Supplier<Authentication> authentication, T object) 
    {
        Authentication auth = authentication.get();
        if (auth == null) {
            // 未认证，拒绝访问
            return new AuthorizationDecision(false);
        }
        // 仅允许用户名包含 "admin" 的用户访问
        String username = auth.getName();
        boolean authorized = username.contains("admin");
        return new AuthorizationDecision(authorized);
    }
}

// 在 Security 配置中使用
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .authorizeHttpRequests(auth -> auth
            // 对 /custom/** 路径应用自定义授权管理器
            .requestMatchers("/custom/**").access(new CustomAuthorizationManager())
            .anyRequest().authenticated()
        );
    return http.build();
}

AuthorizationResult

AuthorizationResult 是 Spring Security 权限校验的 “结果载体”

/**
 * Spring Security 中表示权限校验结果的接口，用于封装"是否允许访问目标资源"的决策结果。
 * 它是权限校验流程的最终输出，由 {@link AuthorizationManager} 生成并返回。
 */
public interface AuthorizationResult extends Serializable {

    /**
     * 判断当前权限校验是否允许访问目标资源。
     *
     * @return true 表示允许访问（权限校验通过），false 表示拒绝访问（权限校验失败）
     */
    boolean isGranted();
}

RequestAuthorizationContext（不是接口）

RequestAuthorizationContext 封装 HTTP 请求相关信息的类，主要用于授权阶段，帮助 AuthorizationManager（授权管理器）判断 “当前请求是否有权访问目标资源”

AuthorizationManager<T> 的泛型T一般是RequestAuthorizationContext对象

// 封装 请求授权上下文：封装HTTP请求及路径变量信息，供授权判断使用
public final class RequestAuthorizationContext {
    // HTTP请求对象（包含请求路径、方法、参数等信息）
    private final HttpServletRequest request;
    // 路径变量映射（如URL中{id}这类变量的键值对）
    private final Map<String, String> variables;

    /**
     * 创建实例
     * @param request HTTP请求对象
     */
    public RequestAuthorizationContext(HttpServletRequest request) {
        this(request, Collections.emptyMap());
    }
    /**
     * 创建实例
     * @param request HTTP请求对象
     * @param variables 路径变量键值对（如从"/user/{id}"中提取的id值）
     */
    public RequestAuthorizationContext(HttpServletRequest request, Map<String, String> variables) {
        this.request = request;
        this.variables = variables;
    }
    /**
     * 获取HTTP请求对象
     * @return 包含请求详情的HttpServletRequest
     */
    public HttpServletRequest getRequest() {
        return this.request;
    }
    /**
     * 获取路径变量
     * @return 路径中变量名与值的映射（如{id: "123"}）
     */
    public Map<String, String> getVariables() {
        return this.variables;
    }
}

认证类

ProviderManager（核心认证类）

ProviderManager 是 Spring Security 中 AuthenticationManager 接口的默认实现类，负责协调多个 AuthenticationProvider（认证提供者）完成认证流程，是认证逻辑的 “调度中心”。它解决了 “多种认证方式共存” 的问题（如用户名密码认证、OAuth2 认证、LDAP 认证等），通过委托不同的 AuthenticationProvider 处理对应类型的认证请求。

核心作用

接收认证请求（Authentication 对象），遍历其管理的 AuthenticationProvider 列表，找到能处理该请求的提供者并委托其执行认证，最终返回认证结果（已认证的 Authentication 或抛出异常）。

内部结构
ProviderManager 内部维护两个关键属性：
List：管理的认证提供者列表（如 DaoAuthenticationProvider 处理用户名密码认证，JwtAuthenticationProvider 处理 JWT 令牌认证）。

AuthenticationManager parent：父认证管理器（可选），当自身所有 AuthenticationProvider 都无法处理请求时，会委托父管理器处理（形成认证链）。

认证流程
当调用 ProviderManager.authenticate(Authentication) 方法时，流程如下：
遍历认证提供者：依次检查 List 中的每个提供者，通过 supports(Class<?>) 方法判断其是否能处理当前 Authentication 类型（如 UsernamePasswordAuthenticationToken 由 DaoAuthenticationProvider 处理）。
委托认证：找到第一个支持该认证类型的 AuthenticationProvider，调用其 authenticate(…) 方法执行具体认证逻辑。

处理结果：
若认证成功，返回已认证的 Authentication 对象（isAuthenticated() == true）。
若认证失败，抛出 AuthenticationException（如密码错误抛出 BadCredentialsException）。
若所有提供者都不支持当前认证类型，且存在父管理器（parent），则委托父管理器处理；若没有父管理器，抛出 ProviderNotFoundException。

DaoAuthenticationProvider

DaoAuthenticationProvider 是 Spring Security 中用于处理用户名密码认证的核心 AuthenticationProvider 实现类，是大多数基于账号密码登录场景的默认认证提供者。它通过整合 UserDetailsService（加载用户信息）和 PasswordEncoder（密码加密与校验），完成从 “接收用户输入” 到 “验证身份合法性” 的完整流程。

核心依赖
DaoAuthenticationProvider 的工作依赖两个关键组件：
UserDetailsService：负责根据用户名从数据源（如数据库、缓存）加载用户信息（UserDetails），包含加密后的密码、权限列表、账号状态（是否锁定、过期等）。
PasswordEncoder：负责密码的加密与校验（如 BCrypt、Argon2 等算法）。用户输入的原始密码会通过它与 UserDetails 中存储的加密密码进行比对。
认证流程
DaoAuthenticationProvider 的 authenticate 方法执行流程如下：

  1. 接收认证请求：接收未认证的 UsernamePasswordAuthenticationToken（包含用户输入的用户名和原始密码）。

  2. 加载用户信息：调用 UserDetailsService.loadUserByUsername(username) 获取 UserDetails 对象。若用户名不存在，抛出 UsernameNotFoundException。

  3. 校验账号状态：检查 UserDetails 中的账号状态（isAccountNonLocked()、isEnabled() 等），若账号锁定、过期或禁用，抛出对应异常（如 LockedException）。

  4. 校验密码：通过 PasswordEncoder.matches(rawPassword, encodedPassword) 比对用户输入的原始密码与 UserDetails 中存储的加密密码。若不匹配，抛出 BadCredentialsException（密码错误）。

  5. 生成认证结果：若上述校验均通过，调用 createSuccessAuthentication 方法生成已认证的 UsernamePasswordAuthenticationToken（包含用户信息、权限，isAuthenticated() 设为 true）并返回。

UsernamePasswordAuthenticationToken

UsernamePasswordAuthenticationToken 是 Spring Security 中用于封装用户名密码认证信息的核心 Authentication 实现类，贯穿于整个用户名密码认证流程，既是 “认证请求的载体”，也是 “认证成功后的凭证”。

核心作用
UsernamePasswordAuthenticationToken 的核心职责是：

认证前：封装用户输入的用户名和原始密码，作为向 AuthenticationManager 发起认证请求的 “未认证令牌”。

认证后：在认证成功后，被填充用户详细信息（UserDetails）和权限列表，作为 “已认证令牌” 存储在 SecurityContext 中，代表用户的身份凭证。

授权类

AuthorizationFilter（权限校验的核心过滤器）

AuthorizationFilter 是 Spring Security 中负责执行权限校验的核心过滤器，它在请求处理流程中拦截请求，调用 AuthorizationManager 进行权限判断，并根据结果决定是否允许请求继续处理（或拒绝访问）。它是 Spring Security 权限控制流程中连接 “请求拦截” 与 “权限决策” 的关键组件

校验核心代码

try {
    AuthorizationResult result = this.authorizationManager.authorize(this::getAuthentication, request);
    this.eventPublisher.publishAuthorizationEvent(this::getAuthentication, request, result);
    if (result != null && !result.isGranted()) {
        throw new AuthorizationDeniedException("Access Denied", result);
    }

    chain.doFilter(request, response);
} finally {
    request.removeAttribute(alreadyFilteredAttributeName);
}

AuthorizationFilter 是 Spring Security 6 授权流程的核心过滤器，通过委托 AuthorizationManager 实现请求的权限校验。它简化了授权流程的设计，强化了 AuthorizationManager 的作用，使开发者能更灵活地配置不同资源的授权规则（如路径匹配、角色校验、认证状态判断等）。在实际开发中，通常无需直接操作 AuthorizationFilter，只需通过 authorizeHttpRequests 配置授权规则即可，其底层会自动完成与 AuthorizationFilter 的关联。

RequestMatcherDelegatingAuthorizationManager

RequestMatcherDelegatingAuthorizationManager 是 Spring Security 中用于基于请求路径（或请求特征）动态匹配授权规则的核心 AuthorizationManager 实现类。它允许为不同的请求路径、HTTP 方法等配置不同的授权策略，是实现 “细粒度 URL 权限控制” 的关键组件。

内部结构：
RequestMatcher 与 AuthorizationManager 的映射
它内部维护一个 Map<RequestMatcher, AuthorizationManager>，其中：
RequestMatcher：用于匹配请求（如通过 AntPathRequestMatcher 匹配 /admin/** 路径，或 MvcRequestMatcher 匹配 Spring MVC 路由）。

AuthorizationManager：对应请求的授权规则（如 AuthenticatedAuthorizationManager 要求 “已认证”，AuthorityAuthorizationManager 要求特定角色）。

工作流程：
当处理请求时，RequestMatcherDelegatingAuthorizationManager 按以下步骤执行：

  1. 匹配请求：遍历内部的 RequestMatcher 列表，找到第一个与当前请求匹配的 RequestMatcher。

  2. 委托授权：调用该 RequestMatcher 对应的 AuthorizationManager 的 check 方法，执行具体授权判断。

  3. 返回结果：将子授权器的判断结果（AuthorizationDecision）作为自身结果返回。

  4. 若没有匹配的 RequestMatcher，则使用默认授权器（默认拒绝访问，可自定义）。

AuthenticatedAuthorizationManager

AuthenticatedAuthorizationManager 是 Spring Security 中一个基础且常用的 AuthorizationManager 实现类，其核心功能是判断当前用户是否已完成认证（即是否已登录），是实现 “登录即可访问” 这类授权逻辑的关键组件。

工作流程：
AuthenticatedAuthorizationManager 通常作为 RequestMatcherDelegatingAuthorizationManager 的子授权器工作，完整流程如下：

  1. 请求到达 AuthorizationFilter（Spring Security 6 的授权过滤器）。
  2. AuthorizationFilter 调用顶层的 RequestMatcherDelegatingAuthorizationManager。
  3. 若请求匹配到 /user/** 等配置了 .authenticated() 的路径，RequestMatcherDelegatingAuthorizationManager 会委托 AuthenticatedAuthorizationManager 执行判断。
  4. AuthenticatedAuthorizationManager 检查用户是否已认证，返回授权结果。
  5. AuthorizationFilter 根据结果决定放行或拒绝访问。

RequestMatcherDelegatingAuthorizationManager 和 AuthenticatedAuthorizationManager关系

RequestMatcherDelegatingAuthorizationManager 和 AuthenticatedAuthorizationManager 最终由 FilterSecurityInterceptor 调用：

  1. FilterSecurityInterceptor 作为授权流程的入口，触发顶层的 RequestMatcherDelegatingAuthorizationManager。
  2. 后者根据请求路径分发到具体的子授权器（如 AuthenticatedAuthorizationManager）完成判断。
  • 这种设计确保了所有请求在访问资源前都经过统一的授权校验，是 Spring Security 权限控制的核心机制

Spring Security配置

@Configuration  // 标记为配置类，让 Spring 解析
@EnableWebSecurity  // 启用 Spring Security 的 Web 安全支持
public class SecurityConfig {

    @Bean
    // 配置 SecurityFilterChain，定义安全拦截规则
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception 
    {
        return http.build();
    }
}

HttpSecurity 配置方法

方法名作用
authorizeHttpRequests()配置 HTTP 请求的授权规则（访问控制）
build()构建 SecurityFilterChain，完成配置
authenticationProvider()注册自定义 AuthenticationProvider（执行认证逻辑）
authenticationManager()指定全局 AuthenticationManager（认证入口，协调多个 Provider）
userDetailsService()配置 UserDetailsService（加载用户信息供认证使用）
formLogin()配置基于表单的登录（自定义登录页、接口、成功 / 失败处理）
httpBasic()配置 HTTP 基本认证（浏览器原生登录框）
logout()配置用户注销行为（注销 URL、成功跳转、会话清理）
csrf()配置跨站请求伪造防护（开启 / 关闭、自定义令牌存储）
cors()配置跨域资源共享（允许指定域名、方法、请求头跨域）
sessionManagement()配置会话行为（创建策略、并发控制、超时处理）
rememberMe()配置 “记住我” 功能（令牌有效期、参数名、用户服务）
headers()配置 HTTP 安全响应头（防御 XSS、点击劫持等）
addFilterBefore()在指定过滤器之前添加自定义过滤器
addFilterAfter()在指定过滤器之后添加自定义过滤器
addFilterAt()在指定过滤器位置添加自定义过滤器（替代或并行执行）
exceptionHandling()配置认证 / 授权失败的处理逻辑（跳转页面、返回 JSON）
anonymous()配置匿名用户的身份（用户名、角色）
oauth2Login()配置 OAuth2/OpenID Connect 第三方登录（如社交登录）
oauth2ResourceServer()配置 OAuth2 资源服务器（验证 JWT 等令牌）
requiresChannel()强制 HTTP/HTTPS 切换（如敏感接口需 HTTPS）
objectPostProcessor()注册 ObjectPostProcessor，增强内部组件（如过滤器、Provider）

authorizeHttpRequests

requestMatchers方法定义当前请求URI范围
常用访问控制规则：

方法作用
.permitAll()允许所有用户访问（包括匿名用户）
.denyAll()拒绝所有用户访问
.authenticated()必须已认证（登录）才能访问
.anonymous()仅允许匿名用户访问
.hasRole(“角色”)需拥有指定角色（自动拼接 ROLE_ 前缀）
.hasAnyRole(“角色1”, “角色2”)拥有任一指定角色即可
.hasAuthority(“权限”)需拥有指定权限（不拼接前缀
.hasAnyAuthority(“权限1”, “权限2”)拥有任一指定权限即可
.access(授权表达式)自定义复杂授权逻辑

objectPostProcessor（不替换组件修改属性）

老版本方法：withObjectPostProcessor
在 Spring Security 中，HttpSecurity 的 objectPostProcessor方法是一个强大的扩展点，用于在 Spring Security 内部组件（如过滤器、认证管理器等）初始化后，对其进行自定义加工。它基于 ObjectPostProcessor 接口工作，允许你在不替换组件的前提下，修改其属性、添加监听器或增强功能。

例子：
如果我想使用默认的配置，但是我想改一些参数,不需要大量修改，可以使用objectPostProcessor方法进行修改，将原来的参数username改为name

http.objectPostProcessor(new ObjectPostProcessor<Object>() {
					@Override
					public <O extends Object> O postProcess(O object) {
						if (object instanceof UsernamePasswordAuthenticationFilter) {
							((UsernamePasswordAuthenticationFilter)object).setUsernameParameter("name");
						}
						return object;
					}
				})
				.formLogin();

在这里插入图片描述

补充：
配置顺序：HttpSecurity 的方法调用顺序决定了内部组件的创建和初始化顺序。将 .objectPostProcessor() 放在 .formLogin() 之前，可确保后处理器在 UsernamePasswordAuthenticationFilter创建时已注册，从而拦截并修改参数username

Spring Security 上下文

Spring Security 的上下文（SecurityContext）是框架中用于存储当前用户认证信息的核心组件，它贯穿整个请求生命周期，是实现用户身份识别、权限控制的基础。

  1. SecurityContext：存储当前用户的认证状态（Authentication 对象），包含用户身份、权限等关键信息。
  2. SecurityContextHolder：全局访问 SecurityContext 的工具类，通过它可以在应用任意位置获取当前上下文（无需手动传递认证信息）。

自定义过滤链

AbstractAuthenticationProcessingFilter

AbstractAuthenticationProcessingFilter 是 Spring Security 中处理认证请求的抽象基类，所有基于 HTTP 请求的认证过滤器（如处理用户名密码的 UsernamePasswordAuthenticationFilter、处理 JWT 的自定义过滤器等）都继承自它。它封装了认证流程的通用逻辑（如请求匹配、认证委托、成功 / 失败处理等），子类只需实现具体的认证信息提取逻辑（attemptAuthentication 方法）。

OncePerRequestFilter

单个过滤器的基类（确保一次请求只执行一次），实现具体的过滤逻辑（如认证、日志等）

GenericFilterBean

GenericFilterBean 是一个抽象类，它提供了一个框架来实现自定义的Servlet过滤器。它扩展了Spring的基础功能，允许开发者将Servlet过滤器集成到Spring应用程序上下文中，并利用Spring的依赖注入和属性填充。

移除过滤器（谨慎使用）

@Configuration  // 标记为配置类，让 Spring 解析
@EnableWebSecurity  // 启用 Spring Security 的 Web 安全支持
public class SecurityConfig {

    @Bean
    // 配置 SecurityFilterChain，定义安全拦截规则
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception 
    {
        // 1. 构建默认的过滤器链
        DefaultSecurityFilterChain defaultChain = http.build();
        // 2. 获取默认过滤器列表
        List<Filter> filters = defaultChain.getFilters();
        // 3. 移除目标过滤器（例如移除UsernamePasswordAuthenticationFilter）
        filters.removeIf(filter -> filter.getClass() ==  UsernamePasswordAuthenticationFilter.class);
        // 4. 构建新的过滤器链（替换默认过滤器列表）
        return new DefaultSecurityFilterChain(defaultChain.getRequestMatcher(), filters);
    }
}

异常处理

Spring Security 的异常处理体系围绕认证（Authentication） 和授权（Authorization） 两大核心流程设计，包含多种内置异常类型及对应的处理机制。以下是主要的异常类型、触发场景及处理方式：

认证相关异常

AuthenticationException 是所有认证相关异常的父类，发生在用户身份验证过程中（如登录失败、令牌无效等）

异常类型触发场景
BadCredentialsException凭证错误（如密码错误、JWT 令牌无效 / 篡改、验证码错误）。
UsernameNotFoundException用户名不存在（如数据库中查询不到该用户）。
AccountExpiredException用户账号已过期（需管理员重置）。
LockedException用户账号被锁定（如多次登录失败后触发）。
DisabledException用户账号被禁用（如管理员手动禁用）。
InsufficientAuthenticationException认证信息不足（如匿名用户访问需认证的资源，或令牌缺少必要信息）。
AuthenticationServiceException认证过程中发生服务异常（如数据库连接失败、第三方认证服务不可用）。
InvalidJwtException（扩展）JWT 令牌格式错误、签名无效、过期等（通常由 JWT 工具类抛出）。

授权相关异常

AccessDeniedException 是授权阶段的核心异常，发生在用户已认证但权限不足时

异常类型触发场景
AccessDeniedException已认证用户访问无权限的资源（如普通用户访问管理员接口）。
CsrfExceptionCSRF 令牌验证失败（如请求中 CSRF 令牌缺失或无效）。

异常处理过程

以默认情况下UsernamePasswordAuthenticationFilter过滤器为例子：
在这里插入图片描述
可以修改UsernamePasswordAuthenticationFilter的失败处理器（AuthenticationFailureHandler failureHandler），改变异常处理逻辑

http.objectPostProcessor(new ObjectPostProcessor<Object>() {
        @Override
        public <O extends Object> O postProcess(O object) {
            if (object instanceof UsernamePasswordAuthenticationFilter) {
                ((UsernamePasswordAuthenticationFilter)object).setAuthenticationFailureHandler(new AuthenticationEntryPointFailureHandler(new Http403ForbiddenEntryPoint()));
            }
            return object;
        }
    })

修改成了登录失败返回403页面
在这里插入图片描述

自定义过滤器异常处理

首先配置HttpSecurity http的异常处理逻辑

http.exceptionHandling(ex -> ex
                        .authenticationEntryPoint((request, response, exp) -> {
                            // 处理未认证：返回 401 JSON
                            response.setContentType("application/json;charset=UTF-8");
                            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                            response.getWriter().write("{\"code\":401,\"msg\":\"请先登录\"}");
                        })
                        .accessDeniedHandler((request, response, exp) -> {
                            // 处理权限不足：返回 403 JSON
                            response.setContentType("application/json;charset=UTF-8");
                            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
                            response.getWriter().write("{\"code\":403,\"msg\":\"权限不足\"}");
                        })
                );

添加自定义过滤器时，必须在ExceptionTranslationFilter过滤器后面，否则自定义过滤器抛出异常，ExceptionTranslationFilter捕获不到异常，例子：
JwtAuthenticationProcessingFilter是我的自定义过滤器

http.addFilterAfter(JwtAuthenticationProcessingFilter.createJwtAuthenticationProcessingFilter(authenticationManager), ExceptionTranslationFilter.class);
上古掌控安全的神-零:Spring Security5.x到Spring Security6.x的迁移
Xayla的博客
04-20 2272
之前有写过一篇关于的文章，但那已经是相对比较旧的版本了，就目前来说，这其中出现了不少的变动和更新，很多API的使用也是有不小的变化，所以我觉得有必要再写几篇文章学习一下，是的，不是一篇，是几篇，下面是初步的写作计划。《上古掌控安全的神-壹:Spring Security6.0+版本初探》《上古掌控安全的神-贰:Spring Security6.0+版本再探》《上古掌控安全的神-叁:Spring Security6.0+版本认证实践》
spring security认证过程知识整理
weixin_43103956的博客
02-05 510
UsernamePasswordAuthenticationFilter ：重点：用于处理基于表单的登录请求，从表单中获取用户名和密码，默认情况下处理来自/login的请求，从表单中获取用户名和密码， 默认使用表单name值为username和password，这两个值可以通过这个过滤器的usernaemparamter个passwordParameter连个参数的值进行修改。Authentication接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息。（2）基于用户名密码构建token。
Spring Security 6 配置方法，废弃 WebSecurityConfigurerAdapter
热门推荐
markvivv随笔
03-26 2万+
在Spring Security 5.7.0-M2中，Spring就废弃了WebSecurityConfigurerAdapter，因为Spring官方鼓励用户转向基于组件的安全配置。本文整理了一下新的配置方法。在下面的例子中，我们使用Spring Security lambda DSL和HttpSecurity#authorizeHttpRequests方法来定义我们的授权规则，从而遵循最佳实践。
SpringSecurity安全框架整理
qq_41951891的博客
12-15 3343
一：简单介绍 Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。 spring security 的核心功能主要包
SpringSecurity笔记整理
yichengjie_c的博客
09-01 908
编写登录页面 form方式一 Publish AuthenticationManager@EnableWebSecurity@Bean////方式二 Configure global AuthenticationManagerBuilder@EnableWebSecurity@Autowired。
spring security 功能整理
LCY133的博客
04-14 961
开发者应结合具体场景选择合适的模块，遵循最小权限原则，并通过持续监控和更新依赖库确保系统安全。处理 HTTP 请求，每个过滤器负责特定安全任务。：自动启用默认安全配置（如表单登录、基础安全头）。：集成数据库、LDAP、OAuth2 等（通过。：通过 ACL 或行级权限控制数据访问。支持自定义认证方式（如短信验证码）。：存储安全上下文（如用户认证信息）。：处理 HTTP Basic 认证。：通过 URL 匹配规则控制访问（：最终决定是否允许访问资源。）实现业务逻辑权限校验。实现非阻塞安全控制。
SpringSecurity原理分析
Feverasa的博客
12-05 7485
距离上次更新已经5个月了，因为这段时间主要是面试准备+适应新公司的内容，8月份离职，9月份入职，虽然看了很多内容，但没有进行系统整理。之后应该也会渐渐的整理一些内容，会继续更新，虽然没什么人看，但还是说明下，_O(∩_∩)O哈哈~。 ​ 这一篇我们主要梳理下SpringSecurity的原理，SpringSecurity主要是用于认证、授权的，其的主要原理就是通过Filter来处理。 一、SpringSecurity的基本原理 1、基本流程 ​ SpringSecurity的基本原理就是应用了Tomcat容
SpringSecurity简单入门
YIYIYI
05-21 550
SpringSecurity简单入门
Spring Security和Shiro的相同点与不同点整理
08-25
Spring Security和Apache Shiro都是Java领域中广泛使用的安全框架，它们为应用程序提供了强大的身份验证、授权和会话管理功能。虽然两者在很多方面有相似之处，但也有各自的特点和适用场景。 **相同点：** 1. **...
Sleeping-Cup-Chat：JavaScript驱动的高效公开聊天新选择
yangrenrui的博客
11-08 691
JavaScript开源项目Sleeping-Cup-Chat提供高效公开聊天解决方案，基于WebSocket实现实时互动。该项目具备完善管理功能，包括权限设置、IP封禁和敏感词过滤，保障聊天秩序。支持历史记录保存和纯公开交流场景，适配企业、教育、社群等多种需求。GitHub地址：https://github.com/YANGRENRUIYRR/Sleeping-Cup-Chat
Java 结构
2501_90980137的博客
11-10 236
，break 用于跳出分支，否则穿透执行。• finally：无论是否发生异常，都会执行的代码块（常用于关闭资源），语法为 try { 代码 } catch (异常类型 e) { 处理代码 } finally { 释放资源 }。• if-else：单条件判断，语法为 if (条件) { 代码块1 } else { 代码块2 }，可嵌套 if-else if-else 实现多条件判断。• 整数型：byte（1字节）、short（2字节）、int（4字节，默认整数类型）、long（8字节，需加后缀 L）。
我与C++的一面之缘
技术人集结地
11-09 357
摘要：文章回忆了作者大学选修C++课程的珍贵经历，虽然现在从事Java开发，但C++课程中学习的"类"、构造函数和析构函数等概念，培养了自己严谨的编程思维。这段短暂的学习经历不仅带来了成就感，更成为影响其职业发展的重要启蒙。作者指出，编程不仅是代码编写，更是一种思维训练和问题解决能力的培养，这段与C++的缘分虽短却终身受益。（150字）
学习理论：代理损失函数的泛化界与Rademacher复杂度
dssfgshdrs的博客
11-07 613
UnifiedTTS 通过统一的 API 屏蔽了不同 TTS 模型的差异，使你无需维护多个 SDK，即可在成本与效果之间自由切换。UnifiedTTS 抽象了不同模型的请求，这样用户可以用同一套请求参数标准来实现对不同TTS模型的调用，这个非常方便。所以，为了简化TTS的客户端调用，非常推荐使用 UnifiedTTS。下面根据API 文档：https://unifiedtts.com/zh/api-docs/tts-sync 实现一个可运行的参考实现，包括配置文件、请求模型、服务类与控制器。
Java场景汇总
weixin_73144915的博客
11-06 1217
传承程序猿的开源精神，分享Java场景的问题和思路，供大家一起探讨学习
android 网络访问拦截器使用后的bug处理
花花鱼的专栏
11-09 985
文章摘要：本文分析了Android客户端调用接口时遇到的405错误问题。核心原因是由于JSESSIONID未及时更新导致header鉴权失效，解决办法是在拦截器中添加清空缓存JSESSIONID的方法，确保每次登录成功后获取最新值。同时强调与服务器交互时保持auth信息一致性的重要性，并介绍了拦截器自动处理请求header的实现方式。
基于SpringBoot的公务员考试管理系统【题库组卷+考试练习】
计算机学姐的博客
11-05 782
【2026最新】基于Java+SpringBoo+Vue+MySQL的公考管理系统，数据可视化分析，题库管理，手动组卷，自动组卷，批量导入导出，在线考试，自由练习，考试记录，练习记录，错题本，成绩分析，答案解析，学习资料，交流论坛等
5 Repository 层接口
最新发布
LSL666_的博客
11-10 542
摘要：本文详细介绍了Spring Data Elasticsearch中Repository层的设计与实现。核心是通过继承ElasticsearchRepository接口来快速获得基础CRUD功能，无需编写实现类。主要内容包括：1）何时需要创建Repository接口；2）接口定义规范（继承关系与泛型参数）；3）框架自动提供的CRUD方法（增删改查及分页查询）；4）派生查询方法的命名规则和使用示例。重点强调了方法命名遵循"关键字+属性名+条件"的模式，以及组合查询、分页排序等高级用法。
JAVA-Redis下
weixin_71184753的博客
11-10 677
Redis 是一种高性能的键值存储系统，它支持多种数据结构，这些数据结构使得 Redis 能够灵活地应对不同的应用场景。接下来我会详细讲述 Redis 常见的五种数据结构及其特点。第一个是====且支持原子操作，比如递增（INCR）、递减（DECR）等，主要用于缓存简单的键值对数据，比如用户会话信息或计数器。（“原子操作”指，中间不会被其他操作插入或看到半成品状态。对并发来说，它像一个不可分割的小“原子”。第二个是====，它是一个有序的字符串集合，支持从两端插入和删除元素。
junit使用
你的指尖有改变世界的力量
11-05 295
本文不搞junit的深层原理，只谈如何使用。
深入解析Spring Security源代码
Spring Security是一个功能强大、可高度定制的身份验证和访问控制框架，它是Spring技术栈中用于提供安全性的主要解决方案。描述部分说明了源代码已经被整理成了一个Eclipse项目，并且能够直接导入到Eclipse工作空间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值