如果你正在开发多系统集成的企业应用，或者维护一个包含多个子站点的平台，那么单点登录（SSO）一定是你绕不开的技术话题。而 JWT（JSON Web Token）作为现代认证方案的核心组件，其重要性不言而喻。但很多开发者对 JWT 的理解停留在“生成 token、验证 token”的层面，真正在单点登录场景下部署时，却频频踩坑。

这篇文章不会重复那些随处可见的 JWT 概念介绍，而是聚焦于一个核心问题：在真实的单点登录系统中，JWT 的认证流程到底应该如何设计，才能兼顾安全、性能和可维护性？我们将从单点登录的业务场景出发，拆解 JWT 在其中的关键作用，并通过完整的代码示例展示从登录到鉴权的全流程。无论你是正在选型的技术负责人，还是需要落地实现的开发工程师，都能从中获得可直接复用的实践方案。

1. 这篇文章真正要解决的问题

单点登录的本质是一次登录，多处通行。想象一下，你的公司有 OA 系统、CRM 系统、财务系统，如果每个系统都需要单独登录，员工每天要重复输入多次账号密码，体验极差。单点登录解决了这个问题，但随之而来的是认证架构的复杂性。

JWT 在单点登录中扮演着安全凭证的角色。它不像传统的 Session 方案需要在服务端存储登录状态，而是通过加密的 Token 自包含用户信息。这种无状态特性非常适合分布式系统，但也带来了新的挑战：

• Token 安全性：如何防止 Token 被窃取后滥用？
• 权限动态更新：用户权限变更后，如何让已签发的 Token 及时失效？
• 跨域认证：多个不同域名的系统间如何安全传递 Token？
• 性能与存储：如何在减少服务端存储压力的同时保证认证效率？

本文将围绕这些实际问题，给出基于 JWT 的单点登录完整解决方案。如果你面临以下场景，这篇文章会特别有用：

• 正在从单体应用向微服务架构迁移，需要统一的认证方案
• 现有系统认证混乱，希望引入标准的单点登录机制
• 对 JWT 有基础了解，但在实际项目中遇到具体技术问题

2. 基础概念与核心原理

2.1 单点登录（SSO）的本质

单点登录不是一项具体的技术，而是一种认证架构模式。其核心思想是集中认证，分布式授权。所有子系统共享同一个认证中心，用户只需在认证中心登录一次，即可访问所有相互信任的系统。

传统 Session 方案的问题在于：

• 每个子系统都需要维护自己的 Session 存储
• 跨域 Session 共享实现复杂
• 服务端存储压力随用户量线性增长

而基于 Token 的 SSO 方案通过无状态的认证令牌解决了这些问题。

2.2 JWT 的结构与工作原理

JWT 由三部分组成，用点号分隔：Header.Payload.Signature

Header（头部）指定令牌类型和签名算法：

{ "alg": "HS256", "typ": "JWT" }

Payload（负载）包含声明（用户信息和其他元数据）：

{ "sub": "1234567890", "name": "John Doe", "iat": 1516239022, "exp": 1516242622 }

Signature（签名）用于验证令牌完整性：

// 伪代码示例 signature = HMACSHA256( base64UrlEncode(header) + "." + base64UrlEncode(payload), secret )

JWT 的关键特性：

• 自包含：所有必要信息都在 Token 中，减少数据库查询
• 可验证：通过签名确保内容未被篡改
• 无状态：服务端不需要存储会话信息

2.3 JWT 在 SSO 中的角色定位

在单点登录架构中，JWT 通常作为访问令牌（Access Token）使用。认证中心负责签发 JWT，各个子系统通过验证 JWT 签名来确认用户身份。这种设计实现了认证与业务的解耦。

3. 环境准备与前置条件

3.1 技术栈选择

本文示例基于以下技术栈，但核心思路适用于任何语言：

• 认证中心：Spring Boot 2.7+ 作为 SSO 服务器
• 子系统：Spring Boot 作为业务系统示例
• JWT 库：jjwt 0.11.5+（Java JWT 实现）
• 数据库：MySQL 8.0+ 用于用户存储（可选，演示用）

3.2 项目结构规划

建议采用多模块 Maven 项目：

sso-demo/ ├── sso-server/ # 认证中心 ├── sso-client-a/ # 子系统A ├── sso-client-b/ # 子系统B └── common-jwt/ # JWT 工具类共享模块

3.3 依赖配置

认证中心 pom.xml 关键依赖：

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.11.5</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>0.11.5</version> <scope>runtime</scope> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>0.11.5</version> <scope>runtime</scope> </dependency> </dependencies>

4. 核心流程拆解

4.1 单点登录的完整认证流程

基于 JWT 的单点登录包含以下关键步骤：

1. 未登录访问：用户访问子系统A，被重定向到认证中心
2. 统一认证：用户在认证中心登录，生成 JWT
3. 令牌传递：认证中心重定向回子系统A，携带 JWT
4. 令牌验证：子系统A验证 JWT 签名和有效期
5. 跨系统访问：用户访问子系统B，携带 JWT 直接认证

4.2 JWT 的生命周期管理

每个 JWT 都有明确的生命周期：

• 生成：用户成功登录后，认证中心签发
• 传递：通过 URL 参数、Cookie 或 Header 在系统间传递
• 验证：业务系统验证签名、有效期和业务规则
• 刷新：接近过期时通过刷新令牌获取新 Token
• 失效：过期或被加入黑名单后失效

5. 完整示例与代码实现

5.1 JWT 工具类封装

首先创建通用的 JWT 工具类，供认证中心和子系统共用：

// 文件路径：common-jwt/src/main/java/com/example/sso/jwt/JwtUtil.java @Component public class JwtUtil { private static final String SECRET_KEY = "your-256-bit-secret-change-in-production"; private static final long EXPIRATION_TIME = 3600000; // 1小时 /** * 生成 JWT */ public String generateToken(UserDetails userDetails) { Map<String, Object> claims = new HashMap<>(); claims.put("username", userDetails.getUsername()); claims.put("roles", userDetails.getAuthorities()); return Jwts.builder() .setClaims(claims) .setSubject(userDetails.getUsername()) .setIssuedAt(new Date(System.currentTimeMillis())) .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME)) .signWith(SignatureAlgorithm.HS256, SECRET_KEY) .compact(); } /** * 验证 JWT 并解析用户信息 */ public UserDetails parseToken(String token) { try { Claims claims = Jwts.parser() .setSigningKey(SECRET_KEY) .parseClaimsJws(token) .getBody(); String username = claims.getSubject(); List<String> roles = (List<String>) claims.get("roles"); return new User(username, "", roles.stream() .map(SimpleGrantedAuthority::new) .collect(Collectors.toList())); } catch (Exception e) { throw new RuntimeException("JWT 验证失败", e); } } /** * 验证 Token 是否有效 */ public boolean validateToken(String token) { try { Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token); return true; } catch (Exception e) { return false; } } }

5.2 认证中心登录接口

认证中心负责用户认证和 JWT 签发：

// 文件路径：sso-server/src/main/java/com/example/sso/controller/AuthController.java @RestController @RequestMapping("/auth") public class AuthController { @Autowired private JwtUtil jwtUtil; @Autowired private UserService userService; /** * 用户登录接口 */ @PostMapping("/login") public ResponseEntity<LoginResponse> login(@RequestBody LoginRequest request) { // 1. 验证用户名密码 UserDetails userDetails = userService.authenticate(request.getUsername(), request.getPassword()); // 2. 生成 JWT String token = jwtUtil.generateToken(userDetails); // 3. 返回登录结果 LoginResponse response = new LoginResponse(); response.setToken(token); response.setExpiresIn(3600); response.setTokenType("Bearer"); return ResponseEntity.ok(response); } /** * JWT 验证接口（供子系统调用） */ @PostMapping("/validate") public ResponseEntity<ValidationResponse> validateToken(@RequestParam String token) { boolean isValid = jwtUtil.validateToken(token); ValidationResponse response = new ValidationResponse(); response.setValid(isValid); if (isValid) { response.setUserDetails(jwtUtil.parseToken(token)); } return ResponseEntity.ok(response); } } // 登录请求DTO @Data class LoginRequest { private String username; private String password; } // 登录响应DTO @Data class LoginResponse { private String token; private String tokenType; private Integer expiresIn; } // 验证响应DTO @Data class ValidationResponse { private boolean valid; private UserDetails userDetails; }

5.3 子系统 JWT 拦截器

子系统需要拦截请求并验证 JWT：

// 文件路径：sso-client-a/src/main/java/com/example/client/config/JwtInterceptor.java @Component public class JwtInterceptor implements HandlerInterceptor { @Autowired private JwtUtil jwtUtil; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 1. 从请求中获取 Token String token = getTokenFromRequest(request); if (token == null) { // 重定向到认证中心登录页 redirectToSsoLogin(request, response); return false; } // 2. 验证 Token 有效性 if (!jwtUtil.validateToken(token)) { // Token 无效，重新登录 redirectToSsoLogin(request, response); return false; } // 3. 将用户信息设置到请求上下文中 UserDetails userDetails = jwtUtil.parseToken(token); request.setAttribute("currentUser", userDetails); return true; } private String getTokenFromRequest(HttpServletRequest request) { // 从 Header 获取 String authHeader = request.getHeader("Authorization"); if (authHeader != null && authHeader.startsWith("Bearer ")) { return authHeader.substring(7); } // 从 URL 参数获取（适用于重定向场景） String tokenParam = request.getParameter("token"); if (tokenParam != null) { return tokenParam; } // 从 Cookie 获取 Cookie[] cookies = request.getCookies(); if (cookies != null) { for (Cookie cookie : cookies) { if ("jwt_token".equals(cookie.getName())) { return cookie.getValue(); } } } return null; } private void redirectToSsoLogin(HttpServletRequest request, HttpServletResponse response) throws IOException { String redirectUrl = request.getRequestURL().toString(); String ssoLoginUrl = "http://sso-server:8080/auth/login?redirect=" + URLEncoder.encode(redirectUrl, "UTF-8"); response.sendRedirect(ssoLoginUrl); } }

5.4 拦截器配置

注册拦截器到 Spring MVC：

// 文件路径：sso-client-a/src/main/java/com/example/client/config/WebMvcConfig.java @Configuration public class WebMvcConfig implements WebMvcConfigurer { @Autowired private JwtInterceptor jwtInterceptor; @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(jwtInterceptor) .addPathPatterns("/**") .excludePathPatterns("/auth/callback", "/static/**", "/error"); } }

6. 运行结果与效果验证

6.1 启动服务验证

1. 启动认证中心：

cd sso-server mvn spring-boot:run

2. 启动子系统A：

cd sso-client-a mvn spring-boot:run -Dserver.port=8081

3. 访问子系统： 在浏览器访问http://localhost:8081/dashboard，应该被重定向到认证中心登录页。

6.2 登录流程验证

1. 提交登录表单：

curl -X POST http://localhost:8080/auth/login \ -H "Content-Type: application/json" \ -d '{"username":"admin","password":"password"}'

预期响应：

{ "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", "tokenType": "Bearer", "expiresIn": 3600 }

2. 使用 Token 访问受保护接口：

curl -X GET http://localhost:8081/api/user/profile \ -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

预期响应用户信息，证明 JWT 验证成功。

6.3 跨系统访问验证

1. 启动子系统B：

cd sso-client-b mvn spring-boot:run -Dserver.port=8082

2. 使用同一 Token 访问子系统B：

curl -X GET http://localhost:8082/api/orders \ -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

应该能正常获取订单数据，证明单点登录生效。

7. 常见问题与排查思路

7.1 典型错误示例

错误：在 Filter 中直接重定向

// 错误写法 - 在 Filter 中重定向会导致问题 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) { if (!validateToken(token)) { ((HttpServletResponse) response).sendRedirect("/login"); // 可能引发异常 return; } chain.doFilter(request, response); }

正确：使用异常处理重定向

// 正确写法 - 通过异常统一处理 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) { try { if (!validateToken(token)) { throw new AuthenticationException("Token 验证失败"); } chain.doFilter(request, response); } catch (AuthenticationException e) { // 统一异常处理中处理重定向 handleAuthenticationFailure(request, response, e); } }

8. 最佳实践与工程建议

8.1 安全增强措施

1. 使用非对称加密算法生产环境建议使用 RS256 等非对称加密：

// 使用 RSA 非对称加密 private static final PrivateKey privateKey = // 从证书加载私钥 private static final PublicKey publicKey = // 从证书加载公钥 public String generateToken(UserDetails userDetails) { return Jwts.builder() .setClaims(claims) .signWith(SignatureAlgorithm.RS256, privateKey) // 私钥签名 .compact(); } public boolean validateToken(String token) { return Jwts.parser() .setSigningKey(publicKey) // 公钥验证 .parseClaimsJws(token); }

2. 实现 Token 刷新机制避免频繁重新登录：

// 刷新 Token 接口 @PostMapping("/refresh") public ResponseEntity<LoginResponse> refreshToken(@RequestParam String refreshToken) { // 验证刷新令牌有效性 if (!refreshTokenService.validate(refreshToken)) { throw new RuntimeException("刷新令牌无效"); } // 生成新的访问令牌 String newAccessToken = jwtUtil.generateToken(...); return ResponseEntity.ok(new LoginResponse(newAccessToken)); }

8.2 性能优化建议

1. 减少 JWT 体积只存储必要信息，避免过度负载：

// 好的实践 - 只存用户ID和角色 claims.put("userId", user.getId()); claims.put("roles", user.getRoleCodes()); // 不是完整角色对象 // 避免的做法 - 存储过多信息 claims.put("user", user); // 整个用户对象序列化

2. 实现本地验证缓存减少重复的签名验证开销：

@Component public class JwtCacheService { private final Cache<String, UserDetails> tokenCache = Caffeine.newBuilder() .expireAfterWrite(10, TimeUnit.MINUTES) .maximumSize(10000) .build(); public UserDetails getCachedUser(String token) { return tokenCache.getIfPresent(token); } public void cacheUser(String token, UserDetails user) { tokenCache.put(token, user); } }

8.3 生产环境配置

1. 密钥管理绝对不要将密钥硬编码在代码中：

# application-prod.properties jwt.secret=${JWT_SECRET_KEY:default-secret-change-in-production} jwt.expiration=3600

2. 监控与日志添加详细的认证日志：

@Slf4j @Component public class JwtUtil { public boolean validateToken(String token) { try { Jwts.parser().setSigningKey(secret).parseClaimsJws(token); log.info("JWT验证成功: {}", extractUsername(token)); return true; } catch (ExpiredJwtException e) { log.warn("JWT已过期: {}", e.getClaims().getSubject()); return false; } catch (Exception e) { log.error("JWT验证失败: {}", e.getMessage()); return false; } } }

9. 总结与后续学习方向

本文详细拆解了 JWT 在单点登录系统中的完整认证流程。关键要点总结：

1. 架构清晰：认证中心负责签发，子系统负责验证，职责分离
2. 安全优先：使用合适的签名算法，管理好密钥安全
3. 性能平衡：在无状态和缓存之间找到平衡点
4. 异常完备：完善的错误处理和日志记录

在实际项目中，你还需要进一步考虑：

扩展学习方向：

• OAuth 2.0 集成：如何将 JWT SSO 与第三方登录整合
• 微服务架构：在 Spring Cloud Gateway 中统一处理 JWT 认证
• 权限细化：基于 JWT 声明实现更精细的权限控制
• 安全加固：防范 JWT 重放攻击、注入攻击等安全威胁

实践建议：

• 先从简单的内部系统开始实践，逐步扩展到生产环境
• 建立完善的 Token 监控和告警机制
• 定期进行安全审计和密钥轮换

JWT 单点登录是一个看似简单实则充满细节的技术主题。希望本文的实践方案能帮助你在实际项目中少走弯路，构建安全可靠的认证系统。建议收藏本文，在具体实施过程中参考对应的代码示例和排查指南。