1. Toy模板网首页
  2. > Toy博客

SpringSecurity认证和授权流程详解

5月前 作者：LvLaoTou 分类：Toy博客 阅读(35) 违法举报

这篇具有很好参考价值的文章主要介绍了SpringSecurity认证和授权流程详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

什么是SpringSecurity

Spring Security是一个Java框架，用于保护应用程序的安全性。它提供了一套全面的安全解决方案，包括身份验证、授权、防止攻击等功能。Spring Security基于过滤器链的概念，可以轻松地集成到任何基于Spring的应用程序中。它支持多种身份验证选项和授权策略，开发人员可以根据需要选择适合的方式。此外，Spring Security还提供了一些附加功能，如集成第三方身份验证提供商和单点登录，以及会话管理和密码编码等。

Spring Security是一个强大且易于使用的框架，可以帮助开发人员提高应用程序的安全性和可靠性。而我们最常用的两个功能就是认证和鉴权，因此作为入门文章本文也只介绍这两个功能的使用。

❝

Spring Security可以用于Servlet应用和Reactive应用，本文主要介绍基于Servlet应用的场景

❞

如需更详细的使用方式请参考官方文档：https://spring.io/projects/spring-security

架构

SpringSecurity认证和授权流程详解

上图是Spring Security官方提供的架构图。我们先看图的左边部分，就是一个典型Servlet Filter （过滤器）处理流程，我们依次讲解流程涉及的组件。

FilterChain

FilterChain ：过滤器链，是Servlet容器在接收到客户端发送的请求时创建的，一个FilterChain可以包含多个Filter和一个Servlet，Servlet容器根据请求URI的路径来处理HttpServletRequest。

在Spring MVC中，Servlet 就是 DispatcherServlet实例。一个 Servlet 最多只能处理一个 HttpServletRequest 和 HttpServletResponse。然而，可以使用多个 Filter 来完成如下工作。

  • 防止下游的 Filter 或 Servlet 被调用。在这种阻断请求的情况下，Filter 通常会使用 HttpServletResponse 对客户端写入响应内容。
  • 修改下游的 Filter 和 Servlet 所使用的 HttpServletRequest 或 HttpServletResponse。

DelegatingFilterProxy

DelegatingFilterProxy ：Spring Security 对 Servlet 的支持是基于Servlet Filter的，而DelegatingFilterProxy 就是Spring Security的Filter实现。

DelegatingFilterProxy允许在 Servlet 容器的生命周期和 Spring 的 ApplicationContext 之间建立桥梁。Servlet容器允许通过使用自己的标准来注册 Filter 实例，但Servlet容器不知道 Spring 定义的 Bean。因此大多数情况下我们通过标准的Servlet容器机制来注册 DelegatingFilterProxy，但将所有工作委托给实现 Filter 的Spring Bean。

❝

Spring Security会自动向Servlet容器机制注册 DelegatingFilterProxy ，无需我们手动去注册

❞

FilterChainProxy

FilterChainProxy ：是 Spring Security 提供的一个特殊的 Filter，允许通过 SecurityFilterChain 委托给许多 Filter 实例。由于 FilterChainProxy 是一个Spring Bean，因此它被包含在 DelegatingFilterProxy 中。

SecurityFilterChain

SecurityFilterChain ：是FilterChainProxy用来确定当前请求应该调用哪些Spring Security Filter 实例的过滤器链。

SecurityFilterChain 中的 Security Filter 一般都是Spring Bean，但这些Security Filter是用 FilterChainProxy 进行注册，而不是通过DelegatingFilterProxy注册。与直接向Servlet容器或 DelegatingFilterProxy 注册相比，FilterChainProxy 有很多优势。

  • 首先，由于 FilterChainProxy 是 Spring Security 使用的核心，它可以处理一些必须要做的事情。 例如：
    • 清除 SecurityContext 以避免内存泄漏。
    • 应用Spring Security的 HttpFirewall 来保护应用程序免受某些类型的攻击。
  • 其次，它在确定何时应该调用 SecurityFilterChain 方面提供了更大的灵活性。在Servlet容器中，Filter 实例仅基于URL被调用。 然而，FilterChainProxy 可以通过使用 RequestMatcher 接口，根据 HttpServletRequest 中的任何内容确定调用。

图的右边部分是存在多个SecurityFilterChain， FilterChainProxy 的匹配策略则是匹配第一个满足的 SecurityFilterChain。

比如，请求的URL是 /api/messages/，它首先与 /api/** 的 SecurityFilterChain 0 模式匹配，所以只有 SecurityFilterChain0 被调用；虽然它也与 SecurityFilterChain n 匹配。

如果请求的URL是 /messages/，它与 /api/** 的 SecurityFilterChain 0 模式不匹配，所以 FilterChainProxy 继续尝试每个 SecurityFilterChain。如果没有其他 SecurityFilterChain 实例相匹配，则调用 SecurityFilterChain n。

SecurityFilter

SecurityFilter：是指通过SecurityFilterChain 插入 FilterChainProxy 中的 Filter。 这些 Filter 可以用于许多不同的目的，如 认证、 授权、 漏洞保护等。Filter 是按照特定的顺序执行的，以保证它们在正确的时间被调用。

例如，执行认证的 Filter 应该在执行授权的 Filter 之前被调用。如果想要知道 Spring Security 的 Filter 的顺序，可以查看 FilterOrderRegistration 源码。

❝

如果想查看你应用中注册了哪些SecurityFilter 的话可以将org.springframework.security的日志级别调到info，这样在你应用启动的时候就会在控制台打印出当前应用注册的所有SecurityFilter 。效果如下：

❞ 
2023-06-14T08:55:22.321-03:00  INFO 76975 --- [           main] o.s.s.web.DefaultSecurityFilterChain     : Will secure any request with [
org.springframework.security.web.session.DisableEncodeUrlFilter@404db674,
org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@50f097b5,
org.springframework.security.web.context.SecurityContextHolderFilter@6fc6deb7,
org.springframework.security.web.header.HeaderWriterFilter@6f76c2cc,
org.springframework.security.web.csrf.CsrfFilter@c29fe36,
org.springframework.security.web.authentication.logout.LogoutFilter@ef60710,
org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@7c2dfa2,
org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter@4397a639,
org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter@7add838c,
org.springframework.security.web.authentication.www.BasicAuthenticationFilter@5cc9d3d0,
org.springframework.security.web.savedrequest.RequestCacheAwareFilter@7da39774,
org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@32b0876c,
org.springframework.security.web.authentication.AnonymousAuthenticationFilter@3662bdff,
org.springframework.security.web.access.ExceptionTranslationFilter@77681ce4,
org.springframework.security.web.access.intercept.AuthorizationFilter@169268a7]

至此，Spring Security官方架构图中涉及的组件就基本介绍完了，大家先对整体架构和执行流程有一个了解，只有先了解了整体架构，才方便接下来我们去理解Spring Security是如何去实现认证和授权的。

常用Spring Security开启的SecurityFilter

  • CsrfFilter：防止Csrf攻击的SecurityFilter
  • AuthorizationFilter：授权SecurityFilter
  • ExceptionTranslationFilter：处理认证和授权异常的SecurityFilter

异常处理

Spring Security中有一个ExceptionTranslationFilter ，ExceptionTranslationFilter 作为 Security Filter 之一被插入到 FilterChainProxy 中。

ExceptionTranslationFilter可以处理AuthenticationException或AccessDeniedException，其逻辑大概是这样：

try {
 filterChain.doFilter(request, response);
} catch (AccessDeniedException | AuthenticationException ex) {
 if (!authenticated || ex instanceof AuthenticationException) {
  startAuthentication();
 } else {
  accessDenied();
 }
}
❝

这段代码的逻辑大致就是，拦截AccessDeniedException 或 AuthenticationException，如果不是这两个异常则不处理。

❞

ExceptionTranslationFilter流程如下：

SpringSecurity认证和授权流程详解

因此如果我们想自己处理AuthenticationException或者AccessDeniedException，分别实现AuthenticationEntryPoint或者AccessDeniedHandler 即可

@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        log.error("AccessDeniedException 请求URI：{}", request.getRequestURI(), accessDeniedException);
        response.setCharacterEncoding("UTF-8");
        HashMap<String, String> result = new HashMap();
        result.put("code", "401");
        result.put("message", "权限不足");
        // 处理没有权限的错误错误
        response.getWriter().write(JsonUtil.toString(result));
    }
}
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        log.error("AccessDeniedException 请求URI：{}", request.getRequestURI(), authException);
        response.setCharacterEncoding("UTF-8");
        // 处理认证失败的错误
        HashMap<String, String> result = new HashMap();
        result.put("code", "500");
        result.put("message", "用户名或密码错误");
        // 处理没有权限的错误错误
        response.getWriter().write(JsonUtil.toString(result));
    }
}
@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain apiFilterChain(HttpSecurity httpSecurity,
                                              AuthenticationEntryPoint authenticationEntryPoint,
                                              AccessDeniedHandler accessDeniedHandler) throws Exception {
        // 配置异常处理
        httpSecurity.exceptionHandling().accessDeniedHandler(accessDeniedHandler);
        httpSecurity.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);
        return httpSecurity.build();
    }
 }

上面是Spring Security对于认证和鉴权异常的处理机制，但是如果我们自定义了一个Filter。如果这个Filter抛出异常，Spring的全局异常处理机制是无法处理的（原因自行搜索）。所以我们还需要自己做一个Filter异常的处理流程。

首先，我们自定义一个Filter，要在FilterChain中的位置比较靠前，没有其他逻辑就是拦截后面filter抛出的异常，然后转发到指定Controller去处理，然后再用全局异常去处理Filter抛出的异常。

@Component
public class ExceptionFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try{
            filterChain.doFilter(request, response);
        }catch (Exception e){
            // 将异常信息写入请求
            request.setAttribute("filterException", e);
            // 重定向到处理异常的controller
            request.getRequestDispatcher("/exception").forward(request, response);
        }
    }
}
@RestController
public class ExceptionController {

    @RequestMapping("/exception")
    public void handleException(HttpServletRequest request) throws Exception {
        Object attribute = request.getAttribute("filterException");
        if (ObjectUtil.isNotEmpty(attribute) && attribute instanceof Exception e){
            throw e;
        }
    }
}
@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain apiFilterChain(HttpSecurity httpSecurity,
                                              ExceptionFilter exceptionFilter) throws Exception {
        // 配置异常处理过滤器 
        // 这里我们配置在ExceptionTranslationFilter之前 让ExceptionTranslationFilter先处理AuthenticationException或者AccessDeniedException
     // 剩下的其他Exception再交由我们自定义的ExceptionFilter处理
        httpSecurity.addFilterBefore(exceptionFilter, ExceptionTranslationFilter.class);
        return httpSecurity.build();
    }
 }

认证

上面我们已经把Spring Security整体流程讲完了，接下来我们就看一下具体认证的流程是怎样的。Spring Security有提供一套基于标准页面的流程，但是不适用于基于前后端分离的开发模式。地址给大家贴这，有需要的可自行去看看：认证 :: Spring Security Reference (springdoc.cn)

接下来介绍基于前后端分离的流程：

SpringSecurity认证和授权流程详解
  1. 先配置AuthenticationManager（认证管理器），其中最常用的AuthenticationManager实现是ProviderManager
@Configuration
public class SecurityConfig {

   /**
     * 配置AuthenticationManager（认证管理器）
     * @return
     */
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationProvider authenticationProvider){
       // ProviderManager 是 AuthenticationManager 最常用的实现
        return new ProviderManager(authenticationProvider);
    }
}
  1. 配置AuthenticationProvider，这里我们的认证方案是使用数据库存储的密码和登录请求的密码进行匹配验证，因此我们选择DaoAuthenticationProvider 。DaoAuthenticationProvider 是一个 AuthenticationProvider 的实现，它使用 UserDetailsService 和 PasswordEncoder 来验证一个用户名和密码。
@Configuration
public class SecurityConfig {

   /**
     * 配置PasswordEncoder（密码编码器）
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    /**
     * 配置AuthenticationProvider
     * @return
     */
    @Bean
    public AuthenticationProvider authenticationProvider(UserDetailsService userDetailsService, 
                                   PasswordEncoder passwordEncoder){
        DaoAuthenticationProvider daoAuthenticationProvider = new DaoAuthenticationProvider();
        daoAuthenticationProvider.setUserDetailsService(userDetailsService);
        daoAuthenticationProvider.setPasswordEncoder(passwordEncoder);
        return daoAuthenticationProvider;
    }
}
  1. 配置UserDetails 和UserDetailsService
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;
import java.util.List;

@Setter
@EqualsAndHashCode
@ToString
public class SecurityUserDetail implements UserDetails {

    @Getter
    private Long userId;

    private String userName;

    private String password;

    private List<GrantedAuthority> authorities;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return this.authorities;
    }

    @Override
    public String getPassword() {
        return this.password;
    }

    @Override
    public String getUsername() {
        return this.userName;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

}

import lombok.RequiredArgsConstructor;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class AuthUserDetailsService implements UserDetailsService {

    private final UserService userService ;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user= userService .getValidUser(username);
        Assert.notEmpty(user, "用户名或密码错误");
        SecurityUserDetail userDetail = new SecurityUserDetail();
        userDetail.setUserId(user.getId());
        userDetail.setUserName(user.getUserName());
        userDetail.setPassword(user.getPassword());
        return userDetail;
    }
}

  1. LoginController提供登录接口，伪代码如下：
@Slf4j
@RestController
@RequiredArgsConstructor
public class LoginController{

    private final AuthenticationManager authenticationManager;

    public Response<LoginVO> login(LoginAO loginAo) {
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginAo.getKey(), loginAo.getPassword());
        Authentication authenticate = authenticationManager.authenticate(authenticationToken);
        Assert.notEmpty(authenticate, "用户名或密码错误");
        if (authenticate.getPrincipal() instanceof SecurityUserDetail userDetail){
            User user = User.builder().id(userDetail.getUserId()).userName(userDetail.getUsername()).build();
            String token = JwtUtil.generateToken(user);
            // 设置上下文
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(user, null, null);
            // 设置子线程支持从父线程获取用户上下文 注意使用ForkJoinPool无法生效
            // SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_INHERITABLETHREADLOCAL);
            SecurityContextHolder.getContext().setAuthentication(authentication);
            return Response.success(LoginVO.builder().token(token).build());
        }else {
            log.error("登录异常，从上下文获取用户信息失败，authenticate:{}", JsonUtil.toString(authenticate));
            return Response.fail(null);
        }
    }
}

授权

本文这里分享两种主流的Spring Security授权方式，一种是基于注解的方式，一种是基于配置的方式。

基于注解的授权校验

基于注解的方式校验授权，是通过Spring aop实现的，其流程如下：

SpringSecurity认证和授权流程详解

首先，我们要开启注解鉴权的功能

@Configuration
/**
 * 开启基于注解的方式控制权限
 */
@EnableMethodSecurity
public class SecurityConfig {

}

然后在需要鉴权的方法上添加权限注解

@RestController
public class UserController{

  private final UserService userService;

    @PreAuthorize("hasAuthority('sys:user:page')")
    public Response<IPage<UserVO>> page(QueryUserPageParam param) {
        return Response.success(userService.page(param));
    }
}

Spring Security的常用权限注解有：

  • @PreAuthorize：前置校验权限，在方法执行之前校验权限，支持Spel表达式
  • @PostAuthorize：后置权限校验，在方法执行结束以后进行校验，可以对返回结果进行校验，支持Spel表达式
  • @PreFilter：对方法参数进行过滤
  • @PostFilter：对方法结果进行过滤

具体每个权限注解的使用方式可以自行去官网学习，这里就不具体介绍了。

下面就以最常用的@PreAuthorize注解为例，介绍一下Spring Security基于注解鉴权的流程与原理：

  1. AuthorizationManagerBeforeMethodInterceptor （授权管理前置方法拦截器），会将权限注解与AuthorizationManager （授权管理器）进行关联及初始化

    SpringSecurity认证和授权流程详解

  2. AuthorizationManagerBeforeMethodInterceptor拦截器拦截到请求后，会根据权限注解@PostAuthorize调用匹配的PreAuthorizeAuthorizationManager#check 方法，并从SecurityContextHolder上下文中获取Authentication对象，将Supplier<Authentication> 和 MethodInvocation作为参数传递给PreAuthorizeAuthorizationManager#check 方法。

SpringSecurity认证和授权流程详解
SpringSecurity认证和授权流程详解
SpringSecurity认证和授权流程详解

  1. AuthorizationManager授权管理器使用 MethodSecurityExpressionHandler 解析@PostAuthorize注解的 SpEL 表达式，并从包含 Supplier<Authentication> 和 MethodInvocation 的 MethodSecurityExpressionRoot 构建相应的 EvaluationContext。

    SpringSecurity认证和授权流程详解

  2. 然后从 Supplier 读取Authentication，并检查其权限集合中是否有 sys:user:page。

    SpringSecurity认证和授权流程详解

  3. 如果校验通过，将继续调用业务方法。如果校验不通过，会发布一个 AuthorizationDeniedEvent，并抛出一个 AccessDeniedException，ExceptionTranslationFilter 会捕获并处理。

基于配置的授权校验

基于配置的授权校验是通过AuthorizationFilter 实现的，首先我们需要配置授权校验规则：

@Configuration
public class SecurityConfig {

  /**
     * 不需要校验权限的资源
     */
    public static final String[] PERMIT_URL = new String[]{
            // knife4j 资源
            "/doc.html",
            "/favicon.ico",
            "/swagger-resources",
            "/v3/**",
            "/webjars/**",
            // 监控接口
            "/actuator/**",
            // 登录接口
           "/login",
            // 注册接口
           "/register",
    };

    @Bean
    public SecurityFilterChain apiFilterChain(HttpSecurity httpSecurity,
                                              TokenFilter tokenFilter,
                                              AuthenticationEntryPoint authenticationEntryPoint,
                                              ExceptionFilter exceptionFilter,
                                              AccessDeniedHandler accessDeniedHandler) throws Exception {
        // 配置token校验过滤器
        httpSecurity.addFilterBefore(tokenFilter, AuthorizationFilter.class);
        // 配置异常处理过滤器
        httpSecurity.addFilterBefore(exceptionFilter, ExceptionTranslationFilter.class);
        // 配置异常处理
        httpSecurity.exceptionHandling().accessDeniedHandler(accessDeniedHandler);
        httpSecurity.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);
        // 配置授权拦截规则
        httpSecurity.authorizeHttpRequests()
             // 配置放行的规则 这样配置只能在AuthorizationManager#check方法时返回true 如果不经过AuthorizationManager则不生效（比如自定义Filter）
             // 可以通过自定义WebSecurityCustomizer 来达到SecurityFilterChain中的Filter忽略处理 参考下方自定义WebSecurityCustomizer 
             .antMatchers(PERMIT_URL).permitAll()
                .antMatchers("/sys/user/page").hasAuthority("sys:user:page")
                .anyRequest().authenticated();
        // 配置组件 基于JWT认证 因此禁用csrf
        httpSecurity.csrf().disable();
        // 基于JWT认证 因此禁用session
        httpSecurity.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        // 禁用缓存
        httpSecurity.headers().cacheControl().disable();
        // 允许跨域
        httpSecurity.cors();
        return httpSecurity.build();
    }

    /**
    自定义WebSecurityCustomizer忽略指定路径 但是Spring Security不建议这么做 建议通过antMatchers(PERMIT_URL).permitAll()实现 
    如果想使用此方式 只需要将其注册为Spring Bean即可
    */
    // @Bean
    public WebSecurityCustomizer webSecurityCustomizer(){
        // 配置放行规则
        return customizer -> customizer.ignoring().antMatchers(PERMIT_URL);
    }
}

这里咱们还是以前置校验是否拥有某个权限为例：

// 配置授权拦截规则 校验
httpSecurity.authorizeHttpRequests()
                .antMatchers("/sys/user/page").hasAuthority("sys:user:page")
                .anyRequest().authenticated();
SpringSecurity认证和授权流程详解
SpringSecurity认证和授权流程详解

这里初始化设置了AuthorityAuthorizationManager 作为AuthorizationManager 的实现，不同的权限校验功能可能对应的AuthorizationManager实现会不一样，比如anyRequest().authenticated() 对应的AuthorizationManager 实现则是AuthenticatedAuthorizationManager

SpringSecurity认证和授权流程详解

当AuthorizationFilter 执行的时候，会根据配置的授权规则找到对应的AuthorizationManager 实现，然后执行check 方法，并从SecurityContextHolder上下文中获取Authentication对象，将Authentication 和 request作为参数传递给AuthorizationManager#check 方法。 这里根据上面的规则hasAuthority() 对应的AuthorizationManager 实现就是AuthorityAuthorizationManager 。

SpringSecurity认证和授权流程详解
SpringSecurity认证和授权流程详解
SpringSecurity认证和授权流程详解

然后AuthorityAuthorizationManager 会根据SecurityContextHolder的Authentication 中获取所有权限和配置需要的权限进行对比，如果用户上下文SecurityContextHolder中存储的权限集合包含配置需要的权限则返回true通过，反之则返回false。

注意事项

  1. 需要特别说明的是，Spring Security存储角色和权限都是使用的GrantedAuthority 对象，因此Spring Security规定角色需要加上统一前缀方便与权限区分开
❝

这个统一前缀默认为ROLE_ ，无论是基于配置还是基于注解的授权校验都是同样的规则。

❞
SpringSecurity认证和授权流程详解

当然你也可以自定义这个前缀，只需要将自定义的GrantedAuthorityDefaults 对象注册进Spring容器即可。

@Configuration
public class SecurityConfig {

    /**
     * 配置Role前缀
     * @return
     */
    @Bean
    static GrantedAuthorityDefaults grantedAuthorityDefaults() {
        return new GrantedAuthorityDefaults("ROLE_");
    }
}
SpringSecurity认证和授权流程详解
  1. 细心的朋友可能已经发现了，无论是基于注解还是基于配置的授权校验，都是从用户上下文SecurityContextHolder中获取当前用户拥有的角色和权限，然后再和需要的权限去比较是否拥有权限。所以我们需要在授权校验之前需要往用户上下文SecurityContextHolder中设置当前用户所拥有的权限。这里就需要用到自定义Filter了。

自定义Filter

如果Spring Security中的SecurityFilter 不能满足你的业务需求，需要自定义SecurityFilter 。比如我们需要自定义一个Filter用于解析请求的Token，然后从Token中获取用户信息和权限。自定义SecurityFilter有两种方式：

  1. 自定义SecurityFilter 实现jakarta.servlet.Filter，在doFilter方法中实现自己的业务逻辑，参考案例：
public class TokenFilter implements Filter {

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

        String token= request.getHeader("Authorization");
        boolean hasAccess = checkToken(token);
        if (hasAccess) {
            filterChain.doFilter(request, response);
            return;
        }
        // 注意AuthenticationException或AccessDeniedException会被ExceptionTranslationFilter处理 如果是其他异常需要自己处理 Springboot全局异常无法处理
        throw new AuthenticationException("权限不足");
    }

}

然后将该SecurityFilter注册进SecurityFilterChain

@Configuration
public class SecurityConfig {

 @Bean
 SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
     http.addFilterBefore(new TokenFilter(), AuthorizationFilter.class);
     return http.build();
 }
}
❝

注意，如果想把jakarta.servlet.Filter的实现注册为Spring Bean，这可能会导致 filter 被调用两次，一次由容器调用，一次由 Spring Security 调用，而且顺序不同。可以通过声明 FilterRegistrationBean Bean 并将其 enabled 属性设置为false来告诉 Spring Boot不要向容器注册它。配置如下：

❞ 
@Bean
public FilterRegistrationBean<TokenFilter> tenantFilterRegistration(TokenFilter filter) {
    FilterRegistrationBean<TokenFilter> registration = new FilterRegistrationBean<>(filter);
    registration.setEnabled(false);
    return registration;
}
  1. 自定义SecurityFilter继承OncePerRequestFilter，这样能保证每个请求只会调用一次的filter（「推荐方式」），然后将该SecurityFilter注册进SecurityFilterChain
@Component
public class TokenFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String requestURI = request.getRequestURI();
        // 如果时不需要授权的URI直接放行
        if (!AntPathUtil.match(requestURI, SecurityConfig.PERMIT_URL)){
          String token = request.getHeader("Authorization");
          if (StrUtil.isBlank(token)){
            // 注意AuthenticationException或AccessDeniedException会被ExceptionTranslationFilter处理 如果是其他异常需要自己处理 Springboot全局异常无法处理
            // AuthenticationCredentialsNotFoundException 是 AuthenticationException的子类
              throw new AuthenticationCredentialsNotFoundException("请先登录");
          }
          // 这里是伪代码 逻辑就是通过token解析出用户信息 然后查询出用户所有角色和权限
          User user = parse(token);
          List<GrantedAuthority> authorities = listUserAllPermissions(user.getId());
          PreAuthenticatedAuthenticationToken authenticationToken = new PreAuthenticatedAuthenticationToken(user, null, authorities);
          // 设置子线程支持从父线程获取用户上下文 注意使用ForkJoinPool无法生效 如果是线程池可能导致数据错误 谨慎使用
          SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_INHERITABLETHREADLOCAL);
          // 设置上下文
          SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        }
        // 放行
        filterChain.doFilter(request, response);
    }
}
public class AntPathUtil {

    private AntPathUtil(){}

    public static final AntPathMatcher MATCHER = createMatcher();

    public static boolean match(String path, String... pattern){
        if (ArrayUtil.isEmpty(pattern)){
            return true;
        }
        if (StrUtil.isBlank(path)){
            return false;
        }
        return Arrays.stream(pattern).filter(p -> MATCHER.match(p, path)).findAny().isPresent();
    }

    private static AntPathMatcher createMatcher(){
        AntPathMatcher antPathMatcher = new AntPathMatcher();
        antPathMatcher.setCaseSensitive(false);
        return antPathMatcher;
    }
}

然后将该SecurityFilter注册进SecurityFilterChain

@Configuration
public class SecurityConfig {
 @Bean
 SecurityFilterChain filterChain(HttpSecurity http, TokenFilter tokenFilter) throws Exception {
     http.addFilterBefore(tokenFilter, AuthorizationFilter.class);
     return http.build();
 }
}

总结

最后总结Spring Security的认证和授权的流程如下：

SpringSecurity认证和授权流程详解

梳理一下上面的流程：

  1. 首先，用户携带用户名密码通过LoginController进行登录（认证流程），如果登录成功则返回token（推荐使用JWT作为token）
  2. 后续其他请求，携带通过登录获取得到的token，然后先被TokenFilter解析token获取用户信息，并将用户信息写入SecurityContextHolder
  3. 然后进行授权流程
  4. AuthorizationManager 通过从SecurityContextHolder获取到当前用户的authentication（权限集合），然后与需要的权限进行对比，从而校验当前用户是否有权限使用当前业务功能

本文使用 markdown.com.cn 排版文章来源地址https://www.toymoban.com/news/detail-844133.html

到了这里，关于SpringSecurity认证和授权流程详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Gateway+Springsecurity+OAuth2.0+JWT 实现分布式统一认证授权！

    Gateway+Springsecurity+OAuth2.0+JWT 实现分布式统一认证授权！

    目录 1. OAuth2.0授权服务 2. 资源服务 3. Gateway网关 4. 测试   在SpringSecurity+OAuth2.0 搭建认证中心和资源服务中心-CSDN博客 ​​​​​​ 基础上整合网关和JWT实现分布式统一认证授权。   大致流程如下： 1、客户端发出请求给网关获取令牌 2、网关收到请求，直接转发给授权服务

    2024年01月24日
    浏览(38)
  • SpringSecurity认证流程(超级详细)

    SpringSecurity认证流程(超级详细)

    最近开发项目的时候遇到了和SpringSecurity相关的一些问题，但是之前并没有去了解过SpringSecurity，导致改系统安全权限验证的时候就比较吃力了，目前项目开发大多都直接用脚手架直接开发，系统安全权限验证已经形成了，所以并不是自己写的，自己理解起来会更慢一些，所以

    2024年02月07日
    浏览(39)
  • SpringSecurity实现前后端分离登录授权详解

    SpringSecurity实现前后端分离登录授权详解

    在介绍完SpringSecurity实现前后端分离认证之后，然后就是SpringSecurity授权，在阅读本文章之前可以先了解一下作者的上一篇文章SpringSecurity认证SpringSecurity实现前后端分离登录token认证详解_山河亦问安的博客-CSDN博客。 目录 1. 授权 1.1 权限系统的作用 1.2 授权基本流程 1.3 授权实

    2024年02月08日
    浏览(32)
  • SpringSecurity完整认证流程（包含自定义页面和自定义登录逻辑）

    SpringSecurity完整认证流程（包含自定义页面和自定义登录逻辑）

    认证基本流程图： 1. 用户发起表单登录请求后，首先进入UsernamePasswordAuthenticationFilter ​ 在 UsernamePasswordAuthenticationFilter 中根据用户输入的用户名、密码构建了 UsernamePasswordAuthenticationToken，并将其交给 AuthenticationManager 来进行认证处理。 ​ AuthenticationManager 本身不包含认证逻辑

    2024年01月16日
    浏览(29)

  • spring security认证授权流程

    认证和授权是任何安全体系中的两个主要功能，而在现代Web开发中，Spring Security是最受欢迎和广泛使用的安全框架之一。在本篇文章中，我们将全面介绍Spring Security的认证和授权机制，并提供详细的步骤和示例代码。  一、认证（Authentication） 认证的主要目的是验证用户的身

    2024年02月15日
    浏览(25)
  • SpringSecurity实现前后端分离登录token认证详解

    SpringSecurity实现前后端分离登录token认证详解

    目录 1. SpringSecurity概述 1.1 权限框架 1.1.1 Apache Shiro 1.1.2 SpringSecurity 1.1.3 权限框架的选择 1.2 授权和认证 1.3 SpringSecurity的功能 2.SpringSecurity 实战 2.1 引入SpringSecurity 2.2 认证 2.2.1 登录校验流程  2.2.2 SpringSecurity完整流程  2.2.3 认证流程详解 2.3 思路分析 2.4 代码实战 2.4.1  自定义

    2024年02月08日
    浏览(32)
  • SpringSecurity的安全认证的详解说明(附完整代码)

    SpringSecurity的安全认证的详解说明(附完整代码)

    SpringSecurity 登录认证和请求过滤器以及安全配置详解说明 系统环境：win10 Maven环境：apache-maven-3.8.6 JDK版本：1.8 SpringBoot版本：2.7.8 根据用户名和密码登录，登录成功后返回 Token 数据，将 token放到请求头中 ，每次请求后台携带 token 数据 携带token请求后台 ，后台认证成功，过滤

    2024年02月08日
    浏览(24)
  • 支付宝小程序获取用户授权并进行认证登录流程（前端）

    支付宝小程序获取用户授权并进行认证登录流程（前端）

    1.1申请获取用户信息能力     登录功能做之前要先沟通好客户的需求，支付宝小程序获取用户授权调用相应的接口之前要先获得对应的能力。如果需要获取身份证号、手机号、姓名，则需要登录支付宝开放平台，登录企业账号后，在控制台–能力管理–添加“获取会员信

    2024年02月11日
    浏览(36)
  • OAuth 2.0 授权认证详解

    OAuth 2.0 授权认证详解

    1.1 OAuth 2.0 应用场景 OAuth 2.0 标准目前被广泛应用在第三方登录场景中，以下是虚拟出来的角色，阐述 OAuth2 能帮我们干什么，引用阮一峰这篇理解OAuth 2.0中的例子： 有一个\\\"云冲印\\\"的网站，可以将用户储存在Google的照片，冲印出来。用户为了使用该服务，必须让\\\"云冲印\\\"读取

    2024年02月04日
    浏览(23)
  • 【Django学习】（十五）API接口文档平台_项目流程分析_日志器_认证_授权

    【Django学习】（十五）API接口文档平台_项目流程分析_日志器_认证_授权

    使用API接口文档不经可以很好的的维护接口数据，还给测试人员的接口测试工作带来了便利； 我们可以在全局配置文件中添加路由路径生成接口文档 1.1在全局配置文件里指定用于支持coreapi的Schema 1.2在全局路由表中添加路径   页面效果： 2.1 一定要先在配置表中注册drf_yas

    2024年02月15日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包