好的，关于 Spring Boot JWT
Token 的前后端分离问题，我可以为您提供一些帮助。
JWT（JSON Web
Token）是一种基于 JSON 的开放标准（RFC 7519），用于在网络上安全传输声明。在前后端分离的应用中，通常会使用 JWT 来实现用户认证和授权。
下面是一个简单的示例，演示了如何在 Spring Boot 应用中使用 JWT 和前后端分离的方式进行用户认证。
首先，您需要在后端应用中添加 JWT 相关的依赖。可以使用以下 Maven 依赖：
```xml
<dependency>
<groupId>io.jsonweb
token</groupId>
<ar
tifac
tId>jjwt</ar
tifac
tId>
<version>0.9.1</version>
</dependency>
```
接下来，您需要编写一个 JWT 工具类，用于生
成和验证 JWT。
```java
import io.jsonweb
token.Claims;
import io.jsonweb
token.Jwts;
import io.jsonweb
token.SignatureAlgorithm;
import io.jsonweb
token.security.Keys;
import org.springframework.beans.factory.annota
tion.Value;
import org.springframework.stereotype.Component;
import javax.crypto.SecretKey;
import java.u
til.Date;
import java.u
til.HashMap;
import java.u
til.Map;
@Component
public class JwtU
tils {
@Value("${jwt.secret}")
private String secret;
@Value("${jwt.expira
tion}")
private Long expira
tion;
private sta
tic final String CLAIM_KEY_USERNAME = "sub";
private sta
tic final String CLAIM_KEY_CREATED = "iat";
private SecretKey generateKey() {
return Keys.hmacShaKeyFor(secret.getBytes());
}
public String generate
Token(String username) {
Map<String, Object> claims = new HashMap<>();
claims.put(CLAIM_KEY_USERNAME, username);
claims.put(CLAIM_KEY_CREATED, new Date());
return Jwts.builder()
.setClaims(claims)
.setExpira
tion(new Date(System.current
TimeMillis() + expira
tion * 1000))
.signWith(generateKey(), SignatureAlgorithm.HS512)
.compact();
}
public Claims getClaimsFrom
Token(String
token) {
return Jwts.parserBuilder()
.setSigningKey(generateKey())
.build()
.parseClaimsJws(
token)
.getBody();
}
public boolean is
TokenExpired(String
token) {
Claims claims = getClaimsFrom
Token(
token);
Date expira
tion = claims.getExpira
tion();
return expira
tion.before(new Date());
}
public boolean validate
Token(String
token, String username) {
Claims claims = getClaimsFrom
Token(
token);
String subject = claims.getSubject();
Date expira
tion = claims.getExpira
tion();
return subject.equals(username) && !expira
tion.before(new Date());
}
}
```
在这个工具类中，我们使用了 io.jsonweb
token 库来实现 JWT 的生
成和验证。在生
成 JWT 时，我们使用了一个密钥（secret）来签名 JWT。在验证 JWT 时，我们还检查了 JWT 中保存的用户名和过期时间是否正确。
接下来，您需要在 Spring Boot 应用中添加一个 JWT 认证过滤器，用于在请求到达后端之前验证 JWT。
```java
import org.springframework.beans.factory.annota
tion.Autowired;
import org.springframework.security.authen
tica
tion.UsernamePasswordAuthen
tica
tion
Token;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletExcep
tion;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOExcep
tion;
public class JwtAuthen
tica
tionFilter extends OncePerRequestFilter {
@Autowired
private JwtU
tils jwtU
tils;
@Autowired
private UserDetailsService userDetailsService;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletExcep
tion, IOExcep
tion {
String
header = request.get
Header("Authoriza
tion");
if (
header != null &&
header.startsWith("Bearer ")) {
String
token =
header.substring(7);
String username = jwtU
tils.getClaimsFrom
Token(
token).getSubject();
if (username != null && SecurityContextHolder.getContext().getAuthen
tica
tion() == null) {
UserDetails userDetails = userDetailsService.loadUserByUsername(username);
if (jwtU
tils.validate
Token(
token, username)) {
UsernamePasswordAuthen
tica
tion
Token authen
tica
tion = new UsernamePasswordAuthen
tica
tion
Token(userDetails, null, userDetails.getAuthori
ties());
SecurityContextHolder.getContext().setAuthen
tica
tion(authen
tica
tion);
}
}
}
chain.doFilter(request, response);
}
}
```
在这个过滤器中，我们从请求头中获取 JWT，然后使用之前编写的 JwtU
tils 工具类来验证 JWT。如果 JWT 验证
成功，则将用户信息添加到 Spring Security 的认证上下文中。
最后，在 Spring Boot 应用中添加一个登录接口，用于生
成 JWT。
```java
import org.springframework.beans.factory.annota
tion.Autowired;
import org.springframework.context.annota
tion.Bean;
import org.springframework.http.ResponseEn
tity;
import org.springframework.security.authen
tica
tion.Authen
tica
tionManager;
import org.springframework.security.authen
tica
tion.UsernamePasswordAuthen
tica
tion
Token;
import org.springframework.security.core.Authen
tica
tionExcep
tion;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annota
tion.*;
import java.u
til.HashMap;
import java.u
til.Map;
@RestController
@RequestMapping("/auth")
public class AuthController {
@Autowired
private Authen
tica
tionManager authen
tica
tionManager;
@Autowired
private JwtU
tils jwtU
tils;
@Autowired
private UserDetailsService userDetailsService;
@PostMapping("/login")
public ResponseEn
tity<?> login(@RequestBody LoginRequest loginRequest) throws Authen
tica
tionExcep
tion {
authen
tica
tionManager.authen
ticate(new UsernamePasswordAuthen
tica
tion
Token(loginRequest.getUsername(), loginRequest.getPassword()));
UserDetails userDetails = userDetailsService.loadUserByUsername(loginRequest.getUsername());
String
token = jwtU
tils.generate
Token(userDetails.getUsername());
Map<String, Object> response = new HashMap<>();
response.put("
token",
token);
return ResponseEn
tity.ok(response);
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
```
在这个登录接口中，我们首先使用 Spring Security 的 Authen
tica
tionManager 来验证用户信息。如果验证
成功，则使用 JwtU
tils 工具类生
成 JWT，并将 JWT 返回给前端应用。
以上就是一个简单的 Spring Boot JWT
Token 的前后端分离示例。希望对您有所帮助！
最低0.47元/天 解锁文章
658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
