基于springSecurity整合jwt拦截器部署
前言
前后端分离项目中，如果直接把 API 接口对外开放，我们知道这样风险是很大的，所以在上一篇中我们引入了 Spring Security ，但是我们在登陆后缺少了请求凭证部分。
什么是jwt?
JWT是 Json Web Token 的缩写。它是基于 RFC 7519 标准定义的一种可以安全传输的 小巧 和 自包含 的JSON对象。由于数据是使用数字签名的，所以是可信任的和安全的。JWT可以使用HMAC算法对secret进行加密或者使用RSA的公钥私钥对来进行签名。
jwt的结构是什么？
token string ====> header.payload.singnature token
# 1.令牌组成
- 1.标头(Header)
- 2.有效载荷(Payload)
- 3.签名(Signature)
- 因此，JWT通常如下所示:xxxxx.yyyyy.zzzzz Header.Payload.Signaturetoken string ====> header.payload.singnature token
# 1.令牌组成
- 1.标头(Header)
- 2.有效载荷(Payload)
- 3.签名(Signature)
- 因此，JWT通常如下所示:xxxxx.yyyyy.zzzzz Header.Payload.Signature
{
"alg": "HS256",
"typ": "JWT"
}# 3.Payload
- 令牌的第二部分是有效负载，其中包含声明。声明是有关实体
- （通常是用户）和其他数据的声明。同样的，它会使用
Base64 编码组成 JWT 结构的第二部分# 4.Signature
- 前面两部分都是使用 Base64 进行编码的，即前端可以解开知
道里面的信息。Signature 需要使用编码后的 header 和 payload
以及我们提供的一个密钥，然后使用 header 中指定的签名算法
（HS256）进行签名。签名的作用是保证 JWT 没有被篡改过
- 如:
HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload),secret);
# 签名目的
- 最后一步签名的过程，实际上是对头部以及负载内容进行签名，
防止内容被窜改。如果有人对头部以及负载的内容解码之后进行修
改，再进行编码，最后加上之前的签名组合形成新的JWT的话，
那么服务器端会判断出新的头部和负载形成的签名和JWT附带上
的签名是不一样的。如果要对新的头部和负载进行签名，在不知
道服务器加密时用的密钥的话，得出来的签名也是不一样的。
# 信息安全问题
- 在这里大家一定会问一个问题：Base64是一种编码，
是可逆的，那么我的信息不就被暴露了吗？
- 是的。所以，在JWT中，不应该在负载里面加入任何敏感的
数据。在上面的例子中，我们传输的是用户的User ID。这个值
实际上不是什么敏 感内容，一般情况下被知道也是安全的。但
是像密码这样的内容就不能被放在JWT中了。如果将用户的密
码放在了JWT中，那么怀有恶意的第 三方通过Base64解码就能
很快地知道你的密码了。因此JWT适合用于向Web应用传递一些
非敏感信息。JWT还经常用于设计用户认证和授权系 统，甚至
实现Web应用的单点登录。
# 5.放在一起
- 输出是三个由点分隔的Base64-URL字符串，可以在HTML和
HTTP环境中轻松传递这些字符串，与基于XML的标准（例如SAML）
相比，它更紧凑。
- 简洁(Compact)
可以通过URL, POST 参数或者在 HTTP header 发送，因为
数据量小，传输速度快
- 自包含(Self-contained)
负载中包含了所有用户所需要的信息，避免了多次查询数据库
项目整合，引入依赖：
# 0.搭建springboot+mybatis+jwt环境
- 引入依赖
- 编写配置
com.auth0
java-jwt
3.4.0
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.1.3
org.projectlombok
lombok
1.18.12
com.alibaba
druid
1.1.19
mysql
mysql-connector-java
5.1.38
编写配置文件
server.port=8989
spring.application.name=jwt
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/jwt?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456
mybatis.type-aliases-package=com.xxx.entity
mybatis.mapper-locations=classpath:mapper/*.xml
logging.level.com.xxxx.dao=debug
开发数据库，在项目中编写实体类
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`name` varchar(80) DEFAULT NULL COMMENT '用户名',
`password` varchar(40) DEFAULT NULL COMMENT '用户密码',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;@Data
@Accessors(chain=true)
public class User {
private String id;
private String name;
private String password;
}开发mapperxml文件和mapper接口
@Mapper
public interface UserDAO {
User login(User user);
}
开发服务层：
public interface UserService {
User login(User user);//登录接口
}@Service
@Transactional
public class UserServiceImpl implements UserService {
@Autowired
private UserDAO userDAO;
@Override
@Transactional(propagation = Propagation.SUPPORTS)
public User login(User user) {
User userDB = userDAO.login(user);
if(userDB!=null){
return userDB;
}
throw new RuntimeException("登录失败~~");
}
}最后开发controller
@RestController
@Slf4j
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/user/login")
public Map login(User user) {
Map result = new HashMap<>();
log.info("用户名: [{}]", user.getName());
log.info("密码: [{}]", user.getPassword());
try {
User userDB = userService.login(user);
Map map = new HashMap<>();//用来存放payload
map.put("id",userDB.getId());
map.put("username", userDB.getName());
String token = JWTUtils.getToken(map);
result.put("state",true);
result.put("msg","登录成功!!!");
result.put("token",token); //成功返回token信息
} catch (Exception e) {
e.printStackTrace();
result.put("state","false");
result.put("msg",e.getMessage());
}
return result;
}
}
接下来就是我们开发部署拦截器的内容了
自己手写生成jwt的工具类
public class JWTUtils {
private static String SECRET = "token!Q@W#E$R";
/**
* 生产token
*/
public static String getToken(Map map) {
JWTCreator.Builder builder = JWT.create();
//payload
map.forEach((k, v) -> {
builder.withClaim(k, v);
});
Calendar instance = Calendar.getInstance();
instance.add(Calendar.DATE, 7); //默认7天过期
builder.withExpiresAt(instance.getTime());//指定令牌的过期时间
String token = builder.sign(Algorithm.HMAC256(SECRET));//签名
return token;
}
/**
* 验证token
*/
public static DecodedJWT verify(String token) {
//如果有任何验证异常，此处都会抛出异常
DecodedJWT decodedJWT = JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
return decodedJWT;
}
} 开发controller登录验证是否正确
@RestController
@Slf4j
public class UserController {
@Resource
private UserService userService;
@GetMapping("/user/login")
public Map login(User user) {
log.info("用户名：{}", user.getName());
log.info("password: {}", user.getPassword());
Map map = new HashMap<>();
try {
User userDB = userService.login(user);
Map payload = new HashMap<>();
payload.put("id", userDB.getId());
payload.put("name", userDB.getName());
String token = JWTUtils.getToken(payload);
map.put("state", true);
map.put("msg", "登录成功");
map.put("token", token);
return map;
} catch (Exception e) {
e.printStackTrace();
map.put("state", false);
map.put("msg", e.getMessage());
map.put("token", "");
}
return map;
}
@PostMapping("/user/test")
public Map test(HttpServletRequest request) {
String token = request.getHeader("token");
DecodedJWT verify = JWTUtils.verify(token);
String id = verify.getClaim("id").asString();
String name = verify.getClaim("name").asString();
log.info("用户id：{}", id);
log.info("用户名: {}", name);
//TODO 业务逻辑
Map map = new HashMap<>();
map.put("state", true);
map.put("msg", "请求成功");
return map;
}
}
拦截器的代码根据自己的需求书写，拦截你不想让客户直接访问的地址，这里拦截器的使用和详细解释我就暂时不介绍了，大家可以参考我以前的书写的拦截器的详细使用
@Slf4j
public class JWTInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {
//获取请求头中的令牌
String token = request.getHeader("token");
log.info("当前token为：{}", token);
Map map = new HashMap<>();
try {
JWTUtils.verify(token);
return true;
} catch (SignatureVerificationException e) {
e.printStackTrace();
map.put("msg", "签名不一致");
} catch (TokenExpiredException e) {
e.printStackTrace();
map.put("msg", "令牌过期");
} catch (AlgorithmMismatchException e) {
e.printStackTrace();
map.put("msg", "算法不匹配");
} catch (InvalidClaimException e) {
e.printStackTrace();
map.put("msg", "失效的payload");
} catch (Exception e) {
e.printStackTrace();
map.put("msg", "token无效");
}
map.put("state", false);
//响应到前台: 将map转为json
String json = new ObjectMapper().writeValueAsString(map);
response.setContentType("application/json;charset=UTF-8");
response.getWriter().println(json);
return false;
}
}
接下来是拦截器的配置类，我们根据自己的需求填写
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new JWTInterceptor())
.addPathPatterns("/user/test")
.excludePathPatterns("/user/login")
;
}
}当所有的类，工具写好之后就可以来检验是否正确了。
这里我们利用postman工具帮我们发送post请求，当路径没有向服务器传送参数请求的时候，模拟登录失败的情景。认证失败是不会生成token的
将上一次请求生成的token存放到header中检验是否登录成功，这里如果不将token放入请求头中是不会访问成功的，因为无法从请求头拿到自己的token是无法完成请求的，
将token放入请求头
然后从新发送post请求，发现就会访问成功
spring boot整合springsecurity，jwt的部署就到这里了，我们这里不仅仅已经验证jwt的token对访问的权限，而且已经将拦截器的部署整合。那拦截器的部署就到这里啦。