Spring Security结合JWT实现用户登录与动态权限

示例使用以下依赖和软件版本

名称	版本
`JDK`	17
`MySQL`	8.0.31
`spring-boot`	3.4.5
`spring-security`	6.4.5
`spring-boot-starter-security`	3.4.5
`mybatis-plus`	3.5.9
`jjwt`	0.9.1

1. 数据库设计#

由于我们将采用RBAC（Role-Based Access Control，基于角色的访问控制）来进行用户的权限管理，因此我们需要构建用户-角色-权限模型，即用户被分配一个或多个角色，每个角色关联一组权限。但是为了简便起见，此处我们直接用资源替换权限。

因此，数据库设计如下图所示：

接着，我们向数据库中插入一系列数据，便于后续测试使用

user表，密码均为password

role表：

user_role表：

menu表：

role_menu表：

同时通过MyBatis-Plus 代码生成器，构建出基础项目结构

2. JWT配置#

2.1 配置工具类#

由于我们将采用JWT进行用户的身份认证，因此我们需要构建一个JWT工具类来进行分发和校验

1
public class JwtUtil {
2
    // JWT密钥
3
    private static final String SECRET_KEY = "secret-key";
4

5
    // 1天过期时间
6
    private static final long EXPIRATION_TIME = TimeUnit.DAYS.toMillis(1);
7

8
    // 生成 JWT
9
    public static String generateToken(String username, List<String> roles) {
10
        return Jwts.builder()
11
                .setSubject(username)
12
                .claim("roles", roles)
13
                .setIssuedAt(new Date())
14
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
15
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
16
                .compact();
17
    }
18

19
    // 解析 JWT
20
    public static Claims getClaimsFromToken(String token) {
21
        return Jwts.parser()
22
                .setSigningKey(SECRET_KEY)
23
                .parseClaimsJws(token)
24
                .getBody();
25
    }
26

27
    // 获取用户名
28
    public static String getUsernameFromToken(String token) {
29
        return getClaimsFromToken(token).getSubject();
30
    }
31

32
    // 获取角色
33
    public static List<String> getRolesFromToken(String token) {
34
        return getClaimsFromToken(token).get("roles", List.class);
35
    }
36

37
    // 验证令牌
38
    public static boolean validateToken(String token) {
39
        try {
40
            // 检查令牌是否存在
41
            Date expiration = getClaimsFromToken(token).getExpiration();
42
            // 检查令牌是否过期
43
            return !expiration.before(new Date());
44
        } catch (Exception e) {
45
            return false;
46
        }
47
    }
48
}

2.2 JWT 认证过滤器#

对于绝大部分请求，我们都需要经过JWT校验，确保用户访问合法。JWT 认证过滤器继承 OncePerRequestFilter，确保每个请求只过滤一次。

该过滤器主要承担以下职责：

从请求头 Authorization 中提取 JWT并验证 token 有效性
从 Claims 中提取用户信息和权限，将其构造一个 UsernamePasswordAuthenticationToken 对象，并设置为已认证
将构建好的 Authentication 对象存入 SecurityContextHolder.getContext().setAuthentication(authentication)。
如果 token 无效或缺失，直接放行，后续的授权过滤器会处理未认证/无权限的情况。

1
@Component
2
public class JwtAuthenticationFilter extends OncePerRequestFilter {
3
    @Override
4
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
5
        String authHeader = request.getHeader("Authorization");
6

7
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
8
            filterChain.doFilter(request, response);
9
            return;
10
        }
11

12
        // 去掉 "Bearer "
13
        String token = authHeader.substring(7);
14

15
        try {
16
            // 验证JWT令牌
17
            if (JwtUtil.validateToken(token)) {
18
                // 从JWT中获取用户名和权限
19
                String username = JwtUtil.getUsernameFromToken(token);
20
                List<String> authorities = JwtUtil.getRolesFromToken(token);
21

22
                // 转换权限字符串为 GrantedAuthority
23
                List<GrantedAuthority> grantedAuthorities = authorities.stream()
24
                        .map(SimpleGrantedAuthority::new)
25
                        .collect(Collectors.toList());
26

27
                // 构建已认证的 Authentication 对象
28
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(username, null, grantedAuthorities);
29
                SecurityContextHolder.getContext().setAuthentication(authentication);
30
            }
31
        } catch (JwtException e) {
32
            // 如果JWT验证失败，清除SecurityContext
33
            SecurityContextHolder.clearContext();
34
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Invalid JWT token");
35
            return;
36
        }
37
        filterChain.doFilter(request, response); // 继续过滤器链
38
    }
39
}

3. 动态权限源配置#

由于我们需要实现基于URL的动态权限配置，因此，我们需要实现 AuthorizationManager<RequestAuthorizationContext> 接口，重写核心方法 AuthorizationDecision check(Supplier<Authentication> authentication, RequestAuthorizationContext context)，来让程序知道当前请求需要什么权限。

在该方法中，我们主要会进行以下工作：

获取当前请求的 URL
根据请求的 URL ，查询需要哪些权限才能访问该资源
从SecurityContextHolder中或获取到用户的身份信息
将用户拥有的权限与需求的权限进行比较，判断是否允许访问

1
@Component
2
@AllArgsConstructor
3
public class DynamicAuthorizationManager implements AuthorizationManager<RequestAuthorizationContext> {
4

5
    private final RoleMenuMapper roleMenuMapper;
6

7
    @Override
8
    public AuthorizationDecision check(Supplier<Authentication> authentication, RequestAuthorizationContext context) {
9
        // 获取请求URL
10
        String url = context.getRequest().getRequestURI();
11

12
        // 查询所有角色与菜单的关联关系
13
        List<String> roleNames = roleMenuMapper.getRoleNamesByMenuPattern(url);
14

15
        // 如果没有匹配的角色，则默认返回拒绝授权
16
        if (roleNames.isEmpty()) {
17
            return new AuthorizationDecision(false);
18
        }
19

20
        // 查询当前用户的角色
21
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
22
        if (Objects.isNull(auth) || !auth.isAuthenticated()) {
23
            // 如果用户未认证，拒绝授权
24
            return new AuthorizationDecision(false);
25
        }
26

27
        // 检查用户角色是否在允许的角色列表中
28
        boolean hasRole = auth.getAuthorities().stream()
29
                .map(GrantedAuthority::getAuthority)
30
                .anyMatch(roleNames::contains);
31

32
        // 返回授权决策
33
        return new AuthorizationDecision(hasRole);
34
    }
35
}

对应的SQL多表联查语句：

1
    <select id="getRoleNamesByMenuPattern" resultType="java.lang.String">
2
        SELECT DISTINCT r.name
3
        FROM role_menu rm
4
        JOIN role r ON rm.role_id = r.id
5
        JOIN menu m ON rm.menu_id = m.id
6
        WHERE m.pattern LIKE CONCAT('%', #{pattern}, '%')
7
    </select>

TIP
由于频繁查询数据库会很影响性能，且权限对应状态相对固定，因此我们可以引入缓存进行优化，此处不过多赘述

4. 用户数据源配置#

由于我们的用户信息均存储在数据库中，因此我们需要建立起用户数据与认证机制的桥梁。在 Spring Security 中，UserDetailsService 接口扮演了这一角色，它是用户认证过程的核心，主要作用是在认证过程中检索用户特定的数据。

该接口需要实现UserDetails loadUserByUsername(String username)这一核心方法，用于加载用户的认证信息，主要有：

用户名 (Username)： 用户的唯一标识符。
密码 (Password)： 用户的编码后的密码。Spring Security 会将这个编码后的密码与用户登录时提供的编码后的密码进行比较。
权限/角色 (Authorities/Roles)： 分配给用户的权限或角色（例如 “ROLE_ADMIN”, “ROLE_USER”）。这些权限用于后续的授权决策。
账户状态 (Account Status)： 指示账户是否启用、是否过期、是否被锁定，或者凭据是否过期。

1
@Component
2
@AllArgsConstructor
3
public class UserDetailsService implements org.springframework.security.core.userdetails.UserDetailsService {
4
    private final IUserRoleService userRoleService;
5
    private final IRoleService roleService;
6
    private final UserMapper userMapper;
7

8
    @Override
9
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
10
        // 根据用户名查询用户信息
11
        User user = userMapper.selectOne(
12
                new LambdaQueryWrapper<>(User.class)
13
                        .eq(User::getUsername, username)
14
                        .eq(User::getEnabled, true)
15
        );
16

17
        if (Objects.isNull(user)) {
18
            throw new UsernameNotFoundException("User not found: " + username);
19
        }
20

21
        // 查询用户角色id
22
        List<Integer> roleIds = userRoleService.list(
23
                new LambdaQueryWrapper<>(UserRole.class)
24
                        .eq(UserRole::getUserId, user.getId())
25
        ).stream().map(UserRole::getRoleId).toList();
26

27
        // 根据角色id查询角色信息
28
        List<Role> roles = roleIds.isEmpty() ? List.of() : roleService.list(
29
                new LambdaQueryWrapper<>(Role.class)
30
                        .in(Role::getId, roleIds)
31
        );
32

33
        // 将角色信息转换为GrantedAuthority
34
        List<SimpleGrantedAuthority> authorities = roles.stream()
35
                .map(role -> new SimpleGrantedAuthority(role.getName()))
36
                .toList();
37

38
        // 返回UserDetails对象
39
        return org.springframework.security.core.userdetails.User.builder()
40
                .username(user.getUsername())
41
                .password(user.getPassword())
42
                .disabled(!user.getEnabled())
43
                .authorities(authorities)
44
                .build();
45
    }
46
}

5. 配置Spring Security#

在完成了上述所有的准备工作之后，我们需要将这些实现的接口配置到Spring Security中去，使得Spring Security能够正确加载我们自定义的配置

5.1 创建配置类#

创建Spring Security 配置的入口，并添加@Configuration注解标记为配置类，以及@EnableWebSecurity注解启用 Spring Security 的 Web 安全功能

1
@Configuration
2
@EnableWebSecurity
3
public class SecurityConfig {
4

5
    // 根据实际情况注入
6
    private final UserDetailsService userDetailsService;
7
    private final JwtAuthenticationFilter jwtAuthenticationFilter;
8
    private final DynamicAuthorizationManager authorizationManager;
9

10
    public SecurityConfig(
11
            UserDetailsService userDetailsService,
12
            JwtAuthenticationFilter jwtAuthenticationFilter,
13
            DynamicAuthorizationManager authorizationManager) {
14
        this.userDetailsService = userDetailsService;
15
        this.jwtAuthenticationFilter = jwtAuthenticationFilter;
16
        this.authorizationManager = authorizationManager;
17
    }
18
}

5.2 配置认证管理器#

在配置类中添加以下内容，启用我们自定义的userDetailsService以及passwordEncoder，此处我们使用BCryptPasswordEncoder进行密码加密，可以根据实际需求进行更换

1
/**
2
 * * 配置认证管理器
3
 *
4
 * @param http HttpSecurity
5
 * @return AuthenticationManager
6
 */
7
@Bean
8
public AuthenticationManager authenticationManager(HttpSecurity http) throws Exception {
9
    AuthenticationManagerBuilder authenticationManagerBuilder =
10
            http.getSharedObject(AuthenticationManagerBuilder.class);
11

12
    authenticationManagerBuilder
13
            .userDetailsService(userDetailsService)
14
            .passwordEncoder(passwordEncoder());
15

16
    return authenticationManagerBuilder.build();
17
}
18

19
/**
20
 * * 密码编码器
21
 * * 使用 BCryptPasswordEncoder 进行密码加密
22
 *
23
 * @return PasswordEncoder
24
 */
25
@Bean
26
public PasswordEncoder passwordEncoder() {
27
    return new BCryptPasswordEncoder();
28
}

5.3 配置安全过滤链#

具体配置参考代码注释

1
  @Value("${demo.security.ignore-path}")
2
    private String[] ignorePath;
3

4
  /**
5
     * * 配置安全过滤链
6
     *
7
     * @param http HttpSecurity
8
     * @return SecurityFilterChain
9
     */
10
    @Bean
11
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
12
        http
13
                // 禁用 CSRF 保护
14
                .csrf(AbstractHttpConfigurer::disable)
15
                // 禁用默认的表单登录和基本认证
16
                .formLogin(AbstractHttpConfigurer::disable)
17
                .httpBasic(AbstractHttpConfigurer::disable)
18
                // 禁用默认的注销功能
19
                .logout(AbstractHttpConfigurer::disable)
20
                // 配置会话管理
21
                .sessionManagement(session -> session
22
                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS))
23
                // 添加自定义的 JWT 认证过滤器
24
                .addFilterBefore(jwtAuthenticationFilter,
25
                                 UsernamePasswordAuthenticationFilter.class)
26
                // 配置请求授权
27
                .authorizeHttpRequests(auth -> auth
28
                        // 部分接口无需授权访问
29
                        .requestMatchers(ignorePath).permitAll()
30
                        // 其余接口需要通过权限校验
31
                        .anyRequest().access(authorizationManager)
32
                );
33

34
        return http.build();
35
    }

在application.yml中配置忽略路径，如下所示：

1
demo:
2
  security:
3
    ignore-path:
4
      /user/login,
5
      /user/ping

6. 用户登录接口#

由于用户登录流程较为简单，只需用到AuthenticationManager即可简化校验流程，此处不过多赘述

1
private final AuthenticationManager authenticationManager;
2

3
@Override
4
public Result<String> login(User user) {
5
    // 执行认证
6
    UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(
7
        user.getUsername(), user.getPassword());
8
    Authentication authentication = authenticationManager.authenticate(token);
9

10
    // 如果认证成功，设置用户信息到SecurityContext
11
    SecurityContextHolder.getContext().setAuthentication(authentication);
12

13
    // 查询用户权限
14
    List<String> authorities = authentication.getAuthorities().stream()
15
        .map(GrantedAuthority::getAuthority)
16
        .toList();
17

18
    // 生成 JWT 令牌
19
    String jwt = JwtUtil.generateToken(user.getUsername(), authorities);
20

21
    return Result.success(jwt);
22
}

7. 验证测试#

在UserController中创建以下接口进行测试，其中/login和/ping接口已添加至白名单中，不过经过权限校验。/hello接口需要ROLE_ADMIN或ROLE_GUEST权限，/info权限需要ROLE_ADMIN权限

1
@PostMapping("/login")
2
public Result<String> login(@RequestBody User user) {
3
    return userService.login(user);
4
}
5

6
@GetMapping("/ping")
7
public String ping() {
8
    return "Pong";
9
}
10

11
@GetMapping("/hello")
12
public String hello() {
13
    return "Hello, World!";
14
}
15

16
@GetMapping("/info")
17
public Result<Authentication> getUserInfo() {
18
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
19

20
    if (authentication == null || !authentication.isAuthenticated()) {
21
        return Result.fail("User not authenticated");
22
    }
23

24
    return Result.success(authentication);
25
}