Spring Boot整合JWT：揭秘权限验证新篇章
在互联网时代，安全始终是开发人员关注的焦点。随着用户量的增加和业务复杂性的提升，传统的Session认证方式逐渐暴露出诸多弊端。为了解决这些问题，JWT（JSON Web Token）应运而生。本文将深入探讨如何将JWT与Spring Boot进行整合，实现高效的权限验证。
一、JWT简介
JWT，全称为JSON Web Token，是一种基于JSON的开放标准（RFC 7519）。它允许在不使用密码的情况下，在各方之间安全地传输信息。JWT的诞生，解决了传统Session认证方式的一些问题，如：
1. 性能问题：JWT不需要服务器保存用户的会话信息，减少了服务器的存储压力。
2. 安全问题：JWT通过签名验证，保证了信息的安全性。
3. 跨域问题：JWT可以携带用户身份信息，方便实现跨域访问。
二、Spring Boot整合JWT
1. 引入依赖
首先，在项目的pom.xml文件中引入以下依赖：
```xml
```
2. 创建JWT工具类
```java
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
import java.util.Map;
public class JwtUtil {
private static final String SECRET_KEY = "mysecretkey";
/**
* 生成JWT
* @param map 存储在JWT中的信息
* @param exp 过期时间（毫秒）
* @return JWT
*/
public static String generateToken(Map
return Jwts.builder()
.setClaims(map)
.setExpiration(new Date(System.currentTimeMillis() + exp))
.signWith(SignatureAlgorithm.HS256, SECRET_KEY)
.compact();
}
/**
* 解析JWT
* @param token JWT
* @return 用户信息
*/
public static Claims parseToken(String token) {
return Jwts.parser()
.setSigningKey(SECRET_KEY)
.parseClaimsJws(token)
.getBody();
}
/**
* 判断JWT是否过期
* @param token JWT
* @return 是否过期
*/
public static boolean isTokenExpired(String token) {
Claims claims = parseToken(token);
return claims.getExpiration().before(new Date());
}
// 其他方法...
}
```
3. 自定义UserDetailsService
```java
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
@Service
public class MyUserDetailsService implements UserDetailsService {
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
// 根据用户名查询用户信息，并封装成UserDetails对象
// 此处简化处理，直接返回一个User对象
return User.withUsername(username)
.password("123456")
.roles("admin")
.build();
}
}
```
4. 创建JWT认证过滤器
```java
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class JwtAuthenticationFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
// 获取请求头中的JWT
String token = request.getHeader("Authorization");
if (token != null && token.startsWith("Bearer ")) {
token = token.substring(7);
}
// 判断JWT是否有效
if (token != null && !JwtUtil.isTokenExpired(token)) {
Claims claims = JwtUtil.parseToken(token);
// 将用户信息设置到SecurityContextHolder中
SecurityContextHolder.getContext().setAuthentication(new MyAuthenticationToken(claims));
}
chain.doFilter(request, response);
}
// MyAuthenticationToken类...
}
```
5. 配置Spring Security
```java
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
// 注入自定义的UserDetailsService
auth.userDetailsService(myUserDetailsService());
}
@Override
protected void configure(HttpSecurity http) throws Exception {
// 配置拦截规则
http
.csrf().disable()
.authorizeRequests()
.antMatchers("/api/**").authenticated() // 需要认证的接口
.anyRequest().permitAll() // 其他接口不需要认证
.and()
// 添加JWT认证过滤器
.addFilter(new JwtAuthenticationFilter());
}
// myUserDetailsService方法...
}
```
6. 测试JWT认证
通过上述步骤，我们已经将JWT与Spring Boot进行了整合。现在，我们可以编写一个测试类，来验证JWT认证功能。
```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class JwtDemoApplication {
public static void main(String[] args) {
SpringApplication.run(JwtDemoApplication.class, args);
}
@GetMapping("/api/user")
public String getUserInfo() {
return "User Info";
}
}
```
运行以上代码，并使用Postman发送GET请求到http://localhost:8080/api/user，即可看到返回的结果。
总结
本文深入分析了Spring Boot整合JWT的过程，并提供了详细的步骤和示例代码。通过使用JWT，我们可以实现高效、安全的权限验证。在实际项目中，根据需求进行适当调整和扩展，可以让我们的系统更加稳定和安全。
