Spring Boot 3 JWT Authentication with Spring Security 6: RBAC, Refresh Tokens & Blacklist
This tutorial builds a production-ready JWT authentication system using Spring Boot 3 and Spring Security 6, covering RBAC database design, token issuance and validation, method-level permission annotations, refresh-token rotation, and Redis-based logout blacklisting with complete code examples.
Why Session Authentication Fails in Frontend-Backend Separation
The author took over a backend admin system that used session.setAttribute("user", user). After the frontend migrated to Vue with independent deployment (port 5173 vs backend 8080), four problems appeared:
Local debug requires re-login on every refresh — Cross-origin (8080 vs 5173) prevents JSESSIONID cookie from being sent.
Production login drops on two servers — Session stored in single-server memory; load balancer routes to another instance.
Mini-program/App cannot integrate — They lack cookie mechanism entirely.
APIs called without permission — Only UI buttons hidden; backend endpoints unprotected.
Conclusion: After frontend-backend separation, authentication must shift from "server stores state" to "client carries credentials".
Session vs JWT Stateless Comparison
State Storage: Traditional Session — Server memory / Redis; JWT Stateless — Client (token self-contained).
Cross-Origin: Traditional Session — Requires Cookie + CORS + SameSite; JWT Stateless — Authorization header, naturally cross-origin.
Multi-Client: Traditional Session — Browser-centric; JWT Stateless — Browser / App / Mini-program / Third-party.
Horizontal Scaling: Traditional Session — Needs session sharing or sticky routing; JWT Stateless — Native support, any instance can verify.
Logout: Traditional Session — Delete session, immediate effect; JWT Stateless — Token self-contained, requires extra blacklist.
Performance: Traditional Session — May query session store each request; JWT Stateless — Single signature verification.
⚠️ Don't mythologize JWT: It's a "stateless credential", not a Session replacement. If you need instant kick-off or force password-change invalidation , you must add server-side state (see Section 12 blacklist).
Overall Request Flow
In one sentence: Issue token at login, every subsequent request carries token, server filter restores token into "current user" in SecurityContext, then permission annotations decide allow/deny.
JWT Structure: Three-Part String
Example JWT:
eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJhZG1pbiIsInVzZXJJZCI6MSwiYXV0aG9yaXRpZXMiOlsic3lzdGVtOnVzZXI6bGlzdCJdLCJpYXQiOjE3MjcyNjA4MDAsImV4cCI6MTcyNzM0NzIwMH0.8Z3kQ2lR6vU8xJ1pT0nM4bK9wL2sH5fD7gY6cA3eB1oHeader: {"alg":"HS256","typ":"JWT"} — Declares signing algorithm.
Payload: sub / userId / authorities / iat / exp — Carries user info ( Base64, not encrypted ).
Signature: HMAC(Header+Payload, secret) — Prevents tampering; server recomputes with secret.
Payload is only Base64 encoded, not encrypted — browser atob() decodes it. Never put passwords, ID numbers, or secrets in JWT.
Signature only guarantees "not modified", not "not stolen" — therefore HTTPS is mandatory and token TTL must be short.
Environment Setup
Spring Boot 3.2+ (Spring Security 6.x), JDK 17+.
⚠️ Security 6 removes WebSecurityConfigurerAdapter entirely; antMatchers also gone. Many 5.x tutorials will fail to compile.
Maven Dependencies
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<!-- JWT: api compile, impl/jackson runtime -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId>
<version>0.12.6</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId>
<version>0.12.6</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId>
<version>0.12.6</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>application.yml
server:
port: 8080
spring:
datasource:
url: jdbc:mysql://localhost:3306/security_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username: root
password: root
jpa:
hibernate:
ddl-auto: update # demo only; production use Flyway/Liquibase
show-sql: true
open-in-view: false
jwt:
# HS256 requires secret >= 32 bytes (256 bit), shorter throws WeakKeyException
secret: java-workshop-jwt-secret-key-must-be-256-bits-at-least
expiration: 7200000 # access token: 2 hours
header: Authorization
prefix: "Bearer "Database: Standard RBAC Five Tables
sys_user -- user
sys_role -- role
sys_menu -- menu (permission identifier perms)
sys_user_role -- user-role
sys_role_menu -- role-menuDDL and initial data provided (MySQL, InnoDB, utf8mb4). Passwords stored as BCrypt (cost 10).
Entity Example (SysUser)
@Data
@Entity
@Table(name = "sys_user")
public class SysUser {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String password;
private String nickname;
private Integer status;
@Transient
private List<String> roles = new ArrayList<>(); // role codes: ROLE_ADMIN
@Transient
private Set<String> permissions = new HashSet<>(); // permission identifiers: system:user:list
}Repository with Single Queries (Avoid N+1)
public interface SysUserRepository extends JpaRepository<SysUser, Long> {
@Query("select u from SysUser u where u.username = :username")
Optional<SysUser> findByUsername(@Param("username") String username);
@Query(value = "select concat('ROLE_', r.role_code) from sys_role r " +
"join sys_user_role ur on ur.role_id = r.id where ur.user_id = :userId",
nativeQuery = true)
List<String> findRoleCodesByUserId(@Param("userId") Long userId);
@Query(value = "select m.perms from sys_menu m " +
"join sys_role_menu rm on rm.menu_id = m.id " +
"join sys_user_role ur on ur.role_id = rm.role_id " +
"where ur.user_id = :userId and m.perms is not null",
nativeQuery = true)
Set<String> findPermsByUserId(@Param("userId") Long userId);
}JWT Utility: Issue, Parse, Validate
@Component
public class JwtTokenProvider {
private final SecretKey key;
private final long expiration;
public JwtTokenProvider(@Value("${jwt.secret}") String secret,
@Value("${jwt.expiration}") long expiration) {
// ⚠️ HS256 requires key >= 32 bytes, else Keys.hmacShaKeyFor throws
this.key = Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8));
this.expiration = expiration;
}
/** Issue token: embed userId + permissions so filter avoids DB hit */
public String createToken(LoginUser loginUser) {
Map<String, Object> claims = new HashMap<>();
claims.put("userId", loginUser.getUserId());
claims.put("nickname", loginUser.getNickname());
claims.put("authorities", new ArrayList<>(loginUser.getPermissions()));
Date now = new Date();
return Jwts.builder()
.claims(claims) // custom claims (0.12.x new style)
.subject(loginUser.getUsername())
.issuedAt(now)
.expiration(new Date(now.getTime() + expiration))
.signWith(key) // 0.12.x: algorithm inferred from key
.compact();
}
/** Parse and validate signature + expiration */
public Claims parseToken(String token) {
return Jwts.parser()
.verifyWith(key) // 0.12.x: verifyWith replaces setSigningKey
.build()
.parseSignedClaims(token) // 0.12.x: parseSignedClaims replaces parseClaimsJws
.getPayload();
}
/** Restore Authentication from token */
public Authentication getAuthentication(String token) {
Claims claims = parseToken(token);
String username = claims.getSubject();
Long userId = claims.get("userId", Long.class);
@SuppressWarnings("unchecked")
List<String> permissions = claims.get("authorities", List.class);
List<GrantedAuthority> authorities = permissions == null
? List.of()
: permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
LoginUser principal = new LoginUser(userId, username,
claims.get("nickname", String.class), authorities);
return new UsernamePasswordAuthenticationToken(principal, null, authorities);
}
/** Only check "is this token itself valid" */
public boolean validateToken(String token) {
try {
parseToken(token);
return true;
} catch (JwtException | IllegalArgumentException e) {
return false; // signature error, expired, malformed → invalid
}
}
}⚠️ jjwt 0.12.x API major changes (most common copy-paste failure point): Jwts.parserBuilder() →
Jwts.parser().setSigningKey(key)→
.verifyWith(key).parseClaimsJws(token).getBody()→
.parseSignedClaims(token).getPayload().setClaims(map)→
.claims(map)SignatureAlgorithm.HS256(manual) → Inferred from key length
Spring Security Main Configuration
@Configuration
@EnableWebSecurity
@EnableMethodSecurity // 6.x: enables @PreAuthorize/@PostAuthorize (replaces @EnableGlobalMethodSecurity)
@RequiredArgsConstructor
public class SecurityConfig {
private final JwtAuthenticationFilter jwtAuthenticationFilter;
private final JwtAuthenticationEntryPoint authenticationEntryPoint;
private final JwtAccessDeniedHandler accessDeniedHandler;
/** Password encoder: BCrypt, strength 10 (balance performance/security) */
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/** AuthenticationManager: login triggers DaoAuthenticationProvider → UserDetailsService → password compare */
@Bean
public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
return config.getAuthenticationManager();
}
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
// Frontend-backend separation + stateless: CSRF targets Cookie/Session, not applicable here
.csrf(AbstractHttpConfigurer::disable)
// CORS: must configure explicitly, else preflight (OPTIONS) intercepted
.cors(cors -> cors.configurationSource(corsConfigurationSource()))
// Never create HttpSession
.sessionManagement(sm -> sm.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
// Context exists only for current request, completely prevents Session write
.securityContext(sc -> sc.securityContextRepository(
new RequestAttributeSecurityContextRepository()))
// Disable default form login / Basic popup
.formLogin(AbstractHttpConfigurer::disable)
.httpBasic(AbstractHttpConfigurer::disable)
// URL-level authorization: coarse allow, fine-grained via annotations
.authorizeHttpRequests(auth -> auth
.requestMatchers(HttpMethod.OPTIONS, "/**").permitAll() // preflight allow
.requestMatchers("/auth/**", "/public/**").permitAll()
.requestMatchers("/doc.html", "/webjars/**", "/v3/api-docs/**", "/swagger-ui/**").permitAll()
.anyRequest().authenticated()
)
// Unified JSON responses for unauthenticated / unauthorized
.exceptionHandling(e -> e
.authenticationEntryPoint(authenticationEntryPoint) // 401: no token or token expired
.accessDeniedHandler(accessDeniedHandler) // 403: authenticated but insufficient permission
)
.logout(AbstractHttpConfigurer::disable) // logout uses custom /auth/logout
// ⚠️ MUST insert before UsernamePasswordAuthenticationFilter
.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
return http.build();
}
@Bean
public CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration config = new CorsConfiguration();
config.setAllowedOriginPatterns(List.of("*"));
config.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS"));
config.setAllowedHeaders(List.of("*"));
config.setExposedHeaders(List.of("Authorization"));
config.setAllowCredentials(true);
config.setMaxAge(3600L);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", config);
return source;
}
}⚠️ Why JWT filter must precede UsernamePasswordAuthenticationFilter?
AuthorizationFilter(last gate) reads SecurityContext; if our filter hasn't run yet, context is empty → immediate 401. Wrong order manifests as "Token is correct but all endpoints return 401".
LoginUser & UserDetailsService
@Getter
public class LoginUser implements UserDetails {
private final Long userId;
private final String username;
private final String nickname;
private final Collection<? extends GrantedAuthority> authorities;
public LoginUser(Long userId, String username, String nickname,
Collection<? extends GrantedAuthority> authorities) {
this.userId = userId;
this.username = username;
this.nickname = nickname;
this.authorities = authorities;
}
@Override public Collection<? extends GrantedAuthority> getAuthorities() { return authorities; }
@Override public String getPassword() { return ""; } // token restore doesn't need password
@Override public String getUsername() { return 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; }
/** Convenience for permission annotations */
public boolean hasPermission(String perm) {
return authorities.stream().anyMatch(a -> a.getAuthority().equals(perm));
}
}Login scenario needs a password-carrying implementation; Spring's built-in User is assembled:
@Service
@RequiredArgsConstructor
public class UserDetailsServiceImpl implements UserDetailsService {
private final SysUserRepository userRepository;
@Override
@Transactional(readOnly = true)
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
SysUser user = userRepository.findByUsername(username)
.orElseThrow(() -> new UsernameNotFoundException("User not found: " + username));
if (Integer.valueOf(0).equals(user.getStatus())) {
throw new DisabledException("Account disabled");
}
// Fetch roles + permissions in one go
List<String> roleCodes = userRepository.findRoleCodesByUserId(user.getId());
Set<String> perms = userRepository.findPermsByUserId(user.getId());
List<GrantedAuthority> authorities = new ArrayList<>();
roleCodes.forEach(r -> authorities.add(new SimpleGrantedAuthority(r)));
perms.forEach(p -> authorities.add(new SimpleGrantedAuthority(p)));
return User.withUsername(user.getUsername())
.password(user.getPassword()) // already BCrypt in DB
.disabled(Integer.valueOf(0).equals(user.getStatus()))
.authorities(authorities)
.build();
}
}Design choice: roles and permissions both placed in same authorities collection. Benefit: @PreAuthorize("hasRole('ADMIN')") and custom permission checks share same data. Note: roles must carry ROLE_ prefix; hasRole('ADMIN') equals hasAuthority('ROLE_ADMIN').
JWT Filter: Restore Token to "Current User"
@Component
@RequiredArgsConstructor
@Slf4j
public class JwtAuthenticationFilter extends OncePerRequestFilter {
private final JwtTokenProvider jwtTokenProvider;
private final UserDetailsServiceImpl userDetailsService;
@Override
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response,
FilterChain chain) throws ServletException, IOException {
String token = resolveToken(request);
if (token != null && SecurityContextHolder.getContext().getAuthentication() == null) {
try {
if (jwtTokenProvider.validateToken(token)) {
Authentication auth = jwtTokenProvider.getAuthentication(token);
// Optional: re-verify account status (prevent valid token but user disabled)
UserDetails details = userDetailsService.loadUserByUsername(auth.getName());
if (details.isEnabled()) {
UsernamePasswordAuthenticationToken authentication =
new UsernamePasswordAuthenticationToken(details, null, details.getAuthorities());
authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
SecurityContext context = SecurityContextHolder.createEmptyContext();
context.setAuthentication(authentication);
SecurityContextHolder.setContext(context);
}
}
} catch (Exception e) {
log.warn("JWT validation failed: {}", e.getMessage());
// ⚠️ Swallow exception, let 401 handler respond; don't write response here
SecurityContextHolder.clearContext();
}
}
chain.doFilter(request, response);
}
private String resolveToken(HttpServletRequest request) {
String header = request.getHeader("Authorization");
if (header != null && header.startsWith("Bearer ")) {
return header.substring(7);
}
return null;
}
}⚠️ Three details:
Must null-check getAuthentication() == null, else overwrites existing auth (e.g., Basic or internal calls).
Swallow exceptions and clearContext() , delegate to AuthenticationEntryPoint for 401; don't write response body in filter.
OncePerRequestFilter guarantees single execution per request (forward scenarios won't re-parse).
Unified Exception Responses (401 / 403)
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response,
AuthenticationException e) throws IOException {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.setContentType("application/json;charset=UTF-8");
response.getWriter().write("{\"code\":401,\"msg\":\"未认证或 Token 已失效,请重新登录\"}");
}
}
@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response,
AccessDeniedException e) throws IOException {
response.setStatus(HttpServletResponse.SC_FORBIDDEN);
response.setContentType("application/json;charset=UTF-8");
response.getWriter().write("{\"code\":403,\"msg\":\"没有权限访问该资源\"}");
}
}Login Endpoint
@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {
private final AuthenticationManager authenticationManager;
private final JwtTokenProvider jwtTokenProvider;
private final UserDetailsServiceImpl userDetailsService;
@PostMapping("/login")
public R<Map<String, Object>> login(@Valid @RequestBody LoginRequest request) {
// 1. Trigger authentication: internally uses UserDetailsService + BCrypt compare, fails → BadCredentialsException
Authentication authentication = authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword()));
// 2. Reload to get userId (login needs id in token)
SysUser user = userDetailsService.getByUsername(request.getUsername());
LoginUser loginUser = new LoginUser(
user.getId(), user.getUsername(), user.getNickname(), authentication.getAuthorities());
// 3. Issue token
String token = jwtTokenProvider.createToken(loginUser);
Map<String, Object> data = new HashMap<>();
data.put("token", token);
data.put("tokenType", "Bearer");
data.put("expiresIn", 7200);
data.put("username", user.getUsername());
data.put("permissions", loginUser.getAuthorities().stream()
.map(GrantedAuthority::getAuthority).toList());
return R.ok(data);
}
@PostMapping("/logout")
public R<Void> logout() {
SecurityContextHolder.clearContext();
// Advanced: add current token to Redis blacklist (see Section 12)
return R.ok();
}
}@Data
public class LoginRequest {
@NotBlank(message = "Username cannot be empty")
private String username;
@NotBlank(message = "Password cannot be empty")
private String password;
}Global Login Failure Handling
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
@ExceptionHandler(BadCredentialsException.class)
public R<Void> handleBadCredentials(BadCredentialsException e) {
return R.fail(401, "用户名或密码错误"); // ⚠️ Don't distinguish "user not exist" vs "wrong password"
}
@ExceptionHandler({DisabledException.class, LockedException.class})
public R<Void> handleDisabled(Exception e) {
return R.fail(403, "账号已被停用,请联系管理员");
}
@ExceptionHandler(AccessDeniedException.class)
public R<Void> handleAccessDenied(AccessDeniedException e) {
return R.fail(403, "没有权限访问该资源");
}
}Permission Annotations: The Core
11.1 Three Usage Patterns
@RestController
@RequestMapping("/system/user")
@RequiredArgsConstructor
public class SysUserController {
private final SysUserService userService;
// ① Role check: hasRole auto-adds ROLE_ prefix
@PreAuthorize("hasRole('ADMIN')")
@GetMapping("/list")
public R<List<SysUser>> list() { return R.ok(userService.list()); }
// ② Permission identifier check (Ruoyi style): @ss is bean name in container
@PreAuthorize("@ss.hasPermi('system:user:add')")
@PostMapping
public R<Void> add(@RequestBody SysUser user) { userService.save(user); return R.ok(); }
// ③ Data-level check: only modify own profile, admin excepted
@PreAuthorize("hasRole('ADMIN') or #id == principal.userId")
@PutMapping("/{id}")
public R<Void> update(@PathVariable Long id, @RequestBody SysUser user) {
userService.updateById(user);
return R.ok();
}
}11.2 Custom Permission Bean
@Component("ss") // ⚠️ Bean name = @ss in SpEL
@RequiredArgsConstructor
public class PermissionService {
/** Check single permission identifier */
public boolean hasPermi(String permission) {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
if (auth == null || !auth.isAuthenticated()) return false;
// Super admin pass (adjust per business)
if (auth.getAuthorities().stream().anyMatch(a -> "ROLE_ADMIN".equals(a.getAuthority()))) {
return true;
}
return auth.getAuthorities().stream()
.anyMatch(a -> permission.equals(a.getAuthority()));
}
/** Any of multiple permissions */
public boolean hasAnyPermi(String... permissions) {
return Arrays.stream(permissions).anyMatch(this::hasPermi);
}
/** Check role */
public boolean hasRole(String role) {
return hasPermi("ROLE_" + role);
}
}11.3 Optional: Own Annotation Wrapper
Writing strings repeatedly causes typos. Can create meta-annotation:
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@PreAuthorize("@ss.hasPermi('' + @permExpr.value())") // Not recommended, see below
public @interface RequiresPermissions { String value(); }⚠️ Pitfall: @PreAuthorize SpEL cannot directly read custom annotation attributes . To achieve @RequiresPermissions("system:user:add") syntax sugar, need custom MethodSecurityExpressionHandler or AOP aspect:
@Aspect
@Component
@RequiredArgsConstructor
public class RequiresPermissionsAspect {
private final PermissionService permissionService;
@Before("@annotation(rp)")
public void check(RequiresPermissions rp) {
if (!permissionService.hasPermi(rp.value())) {
throw new AccessDeniedException("No permission: " + rp.value());
}
}
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresPermissions { String value(); }Then business code becomes clean:
@RequiresPermissions("system:user:delete")
@DeleteMapping("/{id}")
public R<Void> remove(@PathVariable Long id) { ... }Recommendation: Small projects: @PreAuthorize("@ss.hasPermi('...')") suffices, zero extra code. Many permission identifiers, fear typos: use custom annotation + aspect, also enables permission-point scanning/export.
11.4 Access Current Logged-in User
// Way 1: Utility (usable anywhere)
public static LoginUser currentUser() {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
if (auth == null || !(auth.getPrincipal() instanceof LoginUser)) return null;
return (LoginUser) auth.getPrincipal();
}
// Way 2: Parameter injection (recommended, better testability)
@GetMapping("/profile")
public R<Profile> profile(@AuthenticationPrincipal LoginUser user) {
return R.ok(profileService.get(user.getUserId()));
}Advanced: Refresh Token & Logout Blacklist
JWT's biggest weakness: once issued, cannot be recalled . Two patches:
12.1 Dual Token Silent Refresh
// access: 2h, in memory; refresh: 7d, stored in Redis
@PostMapping("/refresh")
public R<Map<String, String>> refresh(@RequestHeader("Refresh-Token") String refreshToken) {
Claims claims = jwtTokenProvider.parseToken(refreshToken);
String redisKey = "refresh:" + claims.getSubject();
if (!refreshToken.equals(stringRedisTemplate.opsForValue().get(redisKey))) {
return R.fail(401, "Refresh Token invalid, please login again");
}
LoginUser user = buildLoginUser(claims.getSubject());
return R.ok(Map.of("token", jwtTokenProvider.createToken(user)));
}Frontend Axios response interceptor: on 401 → use refresh token to exchange new → replay original request, user unaware.
12.2 Logout / Force Offline: Redis Blacklist
@PostMapping("/logout")
public R<Void> logout(HttpServletRequest request) {
String token = jwtTokenProvider.resolveToken(request);
Claims claims = jwtTokenProvider.parseToken(token);
long ttl = claims.getExpiration().getTime() - System.currentTimeMillis();
if (ttl > 0) {
// Store only short digest of token, key = "blacklist:" + md5(token)
redisTemplate.opsForValue().set(
"blacklist:" + DigestUtils.md5DigestAsHex(token.getBytes()),
"1", ttl, TimeUnit.MILLISECONDS);
}
SecurityContextHolder.clearContext();
return R.ok();
}Add one step in filter:
if (Boolean.TRUE.equals(redisTemplate.hasKey(
"blacklist:" + DigestUtils.md5DigestAsHex(token.getBytes()))) {
SecurityContextHolder.clearContext(); // logged out, treat as unauthenticated
chain.doFilter(request, response);
return;
}Frontend Integration (Vue3 + Axios)
// request.ts
const service = axios.create({ baseURL: '/api', timeout: 10000 })
service.interceptors.request.use(config => {
const token = useUserStore().token
if (token) config.headers.Authorization = `Bearer ${token}` // ⚠️ space after Bearer
return config
})
service.interceptors.response.use(
res => res.data,
error => {
const { status, data } = error.response ?? {}
if (status === 401) { userStore.logout(); router.push('/login') }
if (status === 403) { ElMessage.error('没有权限访问该资源') }
return Promise.reject(error)
}
)Menu/button-level control (backend returns permission list, frontend show/hide — only UX, not security ):
export const hasPermi = (perm: string) => useUserStore().permissions.includes(perm)
// <el-button v-if="hasPermi('system:user:add')">Add</el-button>⚠️ Again: frontend button hiding is only UX; real defense is always backend permission annotations.
Full Verification
# 1. Login to get token
curl -X POST http://localhost:8080/auth/login
-H "Content-Type: application/json"
-d '{"username":"admin","password":"123456"}'
# → {"code":200,"data":{"token":"eyJhbGciOiJIUzI1NiJ9...","permissions":["ROLE_ADMIN","system:user:list"]}}
# 2. Access protected endpoint with token
TOKEN=eyJhbGciOiJIUzI1NiJ9...
curl http://localhost:8080/system/user/list -H "Authorization: Bearer $TOKEN"
# → 200 + user list
# 3. Without token
curl http://localhost:8080/system/user/list
# → 401 {"code":401,"msg":"未认证或 Token 已失效,请重新登录"}
# 4. zhangsan (normal user, only system:user:list) calls delete
curl -X DELETE http://localhost:8080/system/user/2 -H "Authorization: Bearer $USER_TOKEN"
# → 403 {"code":403,"msg":"没有权限访问该资源"}
# 5. Tamper token last char
curl http://localhost:8080/system/user/list -H "Authorization: Bearer ${TOKEN}x"
# → 401 (signature verification failed)
# 6. Preflight (CORS)
curl -X OPTIONS http://localhost:8080/system/user/list
-H "Origin: http://localhost:5173" -H "Access-Control-Request-Method: GET" -i
# → 204 with Access-Control-Allow-OriginCode Checklist: SecurityConfig / JwtTokenProvider / JwtAuthenticationFilter / UserDetailsServiceImpl / PermissionService / AuthController — six classes complete the flow; rest is business logic.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
