IT俱乐部 Java Spring Security+JWT如何实现前后端分离权限控制

Spring Security+JWT如何实现前后端分离权限控制

发布: 2025年 4月 28日 79阅读

Spring Security+JWT实现前后端分离权限控制实战

在前后端分离项目中，传统的基于 Session 的认证方式已不再适用。取而代之的是更加轻量、高效的 JWT（JSON Web Token）方式来实现无状态认证。

一、为什么要用 JWT？

前后端分离架构的挑战：

  • 无法使用 Session 管理登录状态（前端和后端分离、跨域）
  • 需要一种「无状态认证机制」

JWT 的优势：

  • 无需在服务端存储会话信息（Token 自包含）
  • 结构清晰，支持权限声明（claims）
  • 可扩展性强，可用于 OAuth、SSO 等场景

二、JWT 基本结构

一个 JWT Token 一般分为三段：

1
Header.Payload.Signature

例如：

1
eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyIiwiaWF0IjoxNjg3NjQ5fQ.K4KgD1sE0JQzA1K6k-FaSd56fQ

每部分作用：

部分 内容
Header 签名算法，如 HS256
Payload 载荷（如用户名、角色、过期时间）
Signature 签名（防止篡改）

三、集成 JWT 的 Spring Security 权限控制思路

整体流程如下：

前端登录 -> 后端验证用户 -> 生成 JWT -> 返回给前端 -> 前端每次请求携带 Token -> 后端解析验证并授权

四、核心模块代码实战

1. 引入依赖（Spring Boot 3.x 示例）

1
org.springframework.bootspring-boot-starter-securityio.jsonwebtokenjjwt-api0.11.5io.jsonwebtokenjjwt-impl0.11.5runtimeio.jsonwebtokenjjwt-jackson0.11.5runtime

2. JWT 工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Component
public class JwtUtil {
    private final String SECRET = "MyJwtSecretKey123"; // 建议放到配置文件中
    private final long EXPIRATION = 1000 * 60 * 60; // 1小时
 
    public String generateToken(String username) {
        return Jwts.builder()
            .setSubject(username)
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
            .signWith(SignatureAlgorithm.HS256, SECRET)
            .compact();
    }
 
    public String getUsernameFromToken(String token) {
        return Jwts.parser().setSigningKey(SECRET)
            .parseClaimsJws(token).getBody().getSubject();
    }
 
    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

3. 自定义登录接口生成 Token

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@RestController
public class AuthController {
 
    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Autowired
    private JwtUtil jwtUtil;
 
    @PostMapping("/login")
    public ResponseEntity> login(@RequestBody LoginRequest loginRequest) {
        try {
            Authentication auth = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword())
            );
            String token = jwtUtil.generateToken(loginRequest.getUsername());
            return ResponseEntity.ok(Collections.singletonMap("token", token));
        } catch (AuthenticationException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("用户名或密码错误");
        }
    }
}

4. JWT 认证过滤器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Component
public class JwtAuthFilter extends OncePerRequestFilter {
 
    @Autowired
    private JwtUtil jwtUtil;
 
    @Autowired
    private UserDetailsService userDetailsService;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        String authHeader = request.getHeader("Authorization");
 
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            String username = jwtUtil.getUsernameFromToken(token);
 
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
 
                if (jwtUtil.validateToken(token)) {
                    UsernamePasswordAuthenticationToken authToken =
                        new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
 
                    authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authToken);
                }
            }
        }
 
        chain.doFilter(request, response);
    }
}

5. 配置 SecurityFilterChain

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Configuration
@EnableMethodSecurity
public class SecurityConfig {
 
    @Autowired
    private JwtAuthFilter jwtAuthFilter;
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/login").permitAll()
                .anyRequest().authenticated()
            )
            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class)
            .build();
    }
 
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
}

五、前端如何配合使用？

  1. 登录后保存返回的 token
  2. 所有后续请求在 header 中添加：
1
Authorization: Bearer

六、权限控制示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@RestController
public class UserController {
 
    @PreAuthorize("hasRole('ADMIN')")
    @GetMapping("/admin/data")
    public String adminData() {
        return "管理员数据";
    }
 
    @PreAuthorize("hasAnyRole('USER','ADMIN')")
    @GetMapping("/user/data")
    public String userData() {
        return "用户数据";
    }
}

总结

JWT 与 Spring Security 的结合，可以帮助你构建一个无状态、安全、高效的前后端分离权限系统。它简化了登录状态的管理流程，提高了系统的伸缩性与并发处理能力。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持IT俱乐部。

本文收集自网络，不代表IT俱乐部立场，转载请注明出处。https://www.2it.club/code/java/15088.html
44赞
标签:
上一篇
下一篇

相关推荐

联系我们

联系我们

在线咨询: QQ交谈

邮箱: 1120393934@qq.com

工作时间：周一至周五，9:00-17:30，节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部