springboot集成Jwt，实现验证！
1，什么是JWT
JWt简称为 JSON web Token 也就是通过josn形式作为web应用中的令牌，用于各方之间安全的将信息作为json对象传输，在数据传输过程中，还可以完成数据加密，签名等相关处理。
2，JWT能做什么
1，授权：（最常用）
正式JWt最常见的方案，一旦用户登录，每个后续请求将包括JWt，从而允许用户访问该令牌允许的路由，服务和资源，单点登录就是当今广泛使用的JWT的一项功能，因为它开销很小并且可以允许跨域使用
2，信息交换
ＪＯＳＮ ＷＥＢ ＴＯＫＥＮ 是在各方之间安全的传输信息的好方法，因为可以对
ＪＷＴ进行签名（例如使用公钥，私钥时）所以可以确保是你允许的人在对你发送信息。
３，为什么是ＪＷＴ
3.1 基于传统的Session认证
1.认证方式
我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证。
2.认证流程
３，ｓｅｓｓｉｏｎ暴露的问题：
1.每个用户经过我们的应用认证之后，我们的应用都要在服务端做一次记录，以方便用户下次请求的鉴别，通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大
2.用户认证之后，服务端做认证记录，如果认证的记录被保存在内存中的话，这意味着用户下次请求还必须要请求在这台服务器上,这样才能拿到授权的资源，这样在分布式的应用上，相应的限制了负载均衡器的能力。这也意味着限制了应用的扩展能力。
3.因为是基于cookie来进行用户识别的, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。
4.在前后端分离系统中就更加痛苦:如下图所示 也就是说前后端分离在应用解耦后增加了部署的复杂性。通常用户一次请求就要转发多次。如果用session 每次携带sessionid
到服务 器，服务器还要查询用户信息。同时如果用户很多。这些信息存储在服务器内存中，给服务器增加负担。还有就是CSRF（跨站伪造请求攻 击）攻击，session是基于cookie进行用户识别的,
cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。还有就是
sessionid就是一个特征值，表达的信息不够丰富。不容易扩展。而且如果你后端应用是多节点部署。那么就需要实现session共享机制。 不方便集群应用。
４，基于ＪＷＴ认证流程及流程图
简单理解为：当用户使用用户名和密码进行登录，后台服务器会对当前的用户生成一个令牌（ＪＷＴ
），有了这个令牌，就是有了权限，有了一些权限之后，就可以访问一些被授权的地面。
1.认证流程
首先，前端通过Web表单将自己的用户名和密码发送到后端的接口。这一过程一般是一个HTTP
POST请求。建议的方式是通过SSL加密的传输（https协议），从而避免敏感信息被嗅探。后端核对用户名和密码成功后，将用户的id等其他信息作为JWT
Payload（负载），将其与头部分别进行Base64编码拼接后签名，形成一个JWT(Token)。形成的JWT就是一个形同lll.zzz.xxx的字符串。
token head.payload.singurater后端将JWT字符串作为登录成功的返回结果返回给前端。前端可以将返回的结果保存在localStorage或sessionStorage上，退出登录时前端删除保存的JWT即可。
前端在每次请求时将JWT放入HTTP Header中的Authorization位。(解决XSS和XSRF问题) HEADER
后端检查是否存在，如存在验证JWT的有效性。例如，检查签名是否正确；检查Token是否过期；检查Token的接收方是否是自己（可选）。
验证通过后后端使用JWT中包含的用户信息进行其他逻辑操作，返回相应结果
。
2.jwt优势
简洁(Compact): 可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快
自包含(Self-contained)：负载中包含了所有用户所需要的信息，避免了多次查询数据库
因为Token是以JSON加密的形式保存在客户端的，所以JWT是跨语言的，原则上任何web形式都支持。
不需要在服务端保存会话信息，特别适用于分布式微服务。
４，ＪＷＴ的结构
*token string ====> header.payload.singnature token*
1.令牌组成
- 1.标头(Header)
- 2.有效载荷(Payload)
- 3.签名(Signature)
- 因此，JWT通常如下所示:xxxxx.yyyyy.zzzzz Header.Payload.Signature
2.Header
标头通常由两部分组成：令牌的类型（即JWT）和所使用的签名算法，例如HMAC SHA256或RSA。它会使用 Base64 编码组成
JWT 结构的第一部分。
- 注意:Base64是一种编码，也就是说，它是可以被翻译回原来的样子来的。它并不是一种加密过程。
{
"alg": "HS256",
"typ": "JWT"
}
3.Payload
- 令牌的第二部分是有效负载，其中包含声明。声明是有关实体（通常是用户）和其他数据的声明。同样的，它会使用 Base64 编码组成 JWT 结构的第二部分
{
"sub": "1234567890",
"name": "John Doe",
"admin": true
}
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) 负载中包含了所有用户所需要的信息，避免了多次查询数据库 以下图片 包含了ｊｗｔ的三部分，
1.标头(Header)- 2.有效载荷(Payload)
- 3.签名(Signature)
５，ｊａｖａ中使用ｊｗｔ
１，导入依赖
<!--引入jwt-->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.4.0</version>
</dependency>
２，生成ｔｏｋｅｎ令牌
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;
public class JwtTest {
public static void main(String[] args) {
//创建一个map
Map<String ,Object> map =new HashMap<>();
//创建一个日历来指定令牌过期的时间
Calendar instance=Calendar.getInstance();
//指定时间为20分钟
instance.add(Calendar.SECOND,20);
//生成令牌
String token=JWT.create()
.withHeader(map) //jwt的第一部分 header
.withClaim("userId",31) // 令牌的第二个部分payload
.withClaim("userName","孙悟空")
.withExpiresAt(instance.getTime())//指定令牌过期时间
.sign(Algorithm.HMAC256("!sidfjoa"));//!sidfjoa是设置的密钥是jwt的第三部分
／／也是签名
System.out.println(token);
}
}
３，根据令牌和签名解析数据
package com.zzuli.springbot.jwt;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
public class CheckJwt {
public static void main(String[] args) {
//首先生成验证对象
JWTVerifier jwtVerifier =JWT.require(Algorithm.HMAC256("!sidfjoa")).build();//参数即使自己设置的签名
//使用验证对象来 验证我们的token
DecodedJWT verify = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6IuWtmeaCn-epuiIsImV4cCI6MTYyMTg0ODU5MCwidXNlcklkIjozMX0.UuHMXr4plDVK01zPLKFDl6ErYfsShkhuKptTdyeDs1M");
//通过得到的verity可以拿到 存在payload的数据,接收类型一一对应
System.out.println(verify.getClaims().get("userId").asInt());
System.out.println(verify.getClaims().get("userName").asString());
//拿到过期时间
System.out.println("过期时间是"+verify.getExpiresAt());
}
}
４，常见的ｊｗｔ异常
SignatureVerificationException: 签名不一致异常
TokenExpiredException: 令牌过期异常
AlgorithmMismatchException: 算法不匹配异常
InvalidClaimException:
６，封装工具类（获取token，验证token） 创建一个工具类ＪＷＴＵｔｉｌ
package com.zzuli.springbot.jwt.utils;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import java.util.Calendar;
import java.util.Map;
public class JWTUtils {
// 创建和解析token的时候都需要用到 sigalnature 所以我们拿出来作为公共的部分
private static final String SIGN="!jiao@#$n";
/*
* 创建一个生成的token的方法 head.payload.sigalnature
* */
public static String getToken(Map<String,String> map){
//创建一个map
//创建一个日历来指定令牌过期的时间
Calendar instance=Calendar.getInstance();
//指定时间为7天过期
instance.add(Calendar.DATE,7);
//创建jwt builder
JWTCreator.Builder builder =JWT.create();
//创建payLoad,使用lamada表达式进行遍历赋值
map.forEach((k,v)->{
builder.withClaim(k,v);
});
String token=builder.withExpiresAt(instance.getTime())
.sign(Algorithm.HMAC256(SIGN));//token 的签名部分
return token;
}
/*
* 创建一个验证token的方法,如果没有验证通过就会抛出异常，如果没有抛出异常说明，验证通过。
* */
public static void vertifyToken(String token){
JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);//参数即使自己设置的签名
}
/*
* 获取token信息的方法
*
* */
public static DecodedJWT getTokenInfo(String token){
return JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
}
}
７，Ｓｐｒｉｎｇｂｏｏｔ集成ＪＷＴ（token是存在请求头中的）
１，搭建ｓｐｒｉｎｇｂｏｏｔ＋Ｍｙｂａｔｉｓ＋ＪＷＴ环境
２，导入依赖
<!--引入jwt-->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.4.0</version>
</dependency>
<!--引入mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.3</version>
</dependency>
<!--引入lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
<!--引入druid-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.19</version>
</dependency>
<!--引入mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency>
3，导入依赖之后，创建一个springboot连接数据库的项目，使用逆向工程
其他步骤省略了，逆向工程不懂得可以翻看我的以前的博客。
连接数据库
#关闭缓存
spring.thymeleaf.cache=false
#连接数据库
#设置连接数据的配置
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#指定开启日志
logging.level.com.zzuli.springbot.mapper=debug
在数据库的一个mapper文件中新增一个查询用户的方法
package com.zzuli.springbot.mapper;
import com.zzuli.springbot.model.User;
public interface UserMapper {
int deleteByPrimaryKey(Integer id);
int insert(User record);
int insertSelective(User record);
User selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(User record);
int updateByPrimaryKey(User record);
//自己重写的一个方法
User selectUser(User user);
}
创建一个服务的接口
package com.zzuli.springbot.service;
import com.zzuli.springbot.model.User;
public interface UserService {
// 创建一个方法用来查询一个用户是否在数据库中有信息
User login(User user);
}
创建一个服务接口的实现类
package com.zzuli.springbot.service.impl;
import com.zzuli.springbot.mapper.UserMapper;
import com.zzuli.springbot.model.User;
import com.zzuli.springbot.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
//表明这个类是一个服务层，并且交给ioc来控制
//开启事务
@Transactional
@Service
public class UserServiceImpl implements UserService {
//为引用数据赋值
@Resource
private UserMapper userMapper;
@Override
//如果当前环境有事务，就加入到当前事务；如果没有事务，就以非事务的方式执行
@Transactional(propagation = Propagation.SUPPORTS)
public User login(User user) {
//根据接收的用户名和密码来查询数据库
User user1 = userMapper.selectUser(user);
if (user1 != null) {
return user1;
}
throw new RuntimeException("登录失败");
}
}
创建一个控制器的方法，并且声明打印日志注解
package com.zzuli.springbot.web;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.zzuli.springbot.jwt.utils.JWTUtils;
import com.zzuli.springbot.model.User;
import com.zzuli.springbot.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
//表明这是一个处理器类,这个类中的所有方法的返回值都是json对象那
@RestController
//加一个日志文件
@Slf4j
public class UserController {
//使用直接给引用属性赋值
@Resource
private UserService userService;
//创建一个map集合
Map<String,String> map= new HashMap<>();
@RequestMapping("/user/login")
public Map<String,Object> test1(User user){
//使用日志打印密码和用户名能否接收到
log.info("用户名是:"+user.getName());
log.info("密码是:"+user.getPassword());
//创建一个map集合
Map<String,Object> map= new HashMap<>();
try {
User userDB=userService.login(user);
//创建一个map集合用来生辰JWT令牌
Map<String,String> payload=new HashMap<>();
payload.put("id",String.valueOf(userDB.getId()));
payload.put("name",userDB.getName());
//调用创建的生成JWT令牌的工具类
String token =JWTUtils.getToken(payload);
map.put("status",true);
map.put("msg","登录成功");
//响应token将生成的token带回给前端
map.put("token",token);
} catch (Exception e) {
map.put("status",false);
map.put("msg", e.getMessage());
}
return map;
}
//当用户发送请求的时候，我们使用这个处理器来验证用户是否有token
//请求方式只能为post方式
@RequestMapping("/user/test")
public Map<String,Object> test(HttpServletRequest request){
///创建一个map集合用来返回信息
Map<String,Object> map=new HashMap<>();
//通过请求对象，拿到请求对象中的请求头中的token
String token=request.getHeader("token");
//通过token获得信心
DecodedJWT vertify=JWTUtils.getTokenInfo(token);
//打印到日志中
log.info("用户id{}",vertify.getClaim("id").asString());
//处理业务逻辑
map.put("status",true);
map.put("msg","请求成功");
return map;
//打印传过来的token
// log.info("当前token为:"+token);
//
// //使用工具类来验证令牌,并且返回token的信息
// try {
// JWTUtils.vertifyToken(token);
// map.put("status",true);
// map.put("msg","请求成功");
//
// }catch (SignatureVerificationException e){
// e.printStackTrace();
// map.put("msg","无效签名异常");
//
// }catch (TokenExpiredException e){
// e.printStackTrace();
// map.put("msg","token过期");
//
// }catch (AlgorithmMismatchException e){
// e.printStackTrace();
// map.put("msg","token算法不一致");
//
// } catch (Exception e) {
// e.printStackTrace();
// }
}
}
创建一个类实现HandlerInterceptor创接口，HandlerInterceptor是SpringMVC中为拦截器提供的接口，用来进行拦截发送的请求
package com.zzuli.springbot.interceptors;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zzuli.springbot.jwt.utils.JWTUtils;
import org.apache.ibatis.ognl.ObjectElementsAccessor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
public class JWTInterceptors implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//由于token一般是放在请求头中，所以我们直接获取请求头中的消息,
//换句话说就是获取请求头中的令牌
String token=request.getHeader("token");
//创建一个map集合，最后将这个map集合手动转化为一个json格式
Map<String, Object> map=new HashMap<>();
//使用封装好的工具类来验证令牌
try {
JWTUtils.vertifyToken(token);
//放行请求
return true;
} catch (SignatureVerificationException e){
e.printStackTrace();
map.put("msg","无效签名异常");
}catch (TokenExpiredException e){
e.printStackTrace();
map.put("msg","token过期");
}catch (AlgorithmMismatchException e){
e.printStackTrace();
map.put("msg","token算法不一致");
} catch (Exception e) {
e.printStackTrace();
}
//设置状态
map.put("msg",false);
//将map手动转化为 json格式
String json=new ObjectMapper().writeValueAsString(map);
response.setContentType("application/json;charset=UTF-8");
//将json数据写入到通道
response.getWriter().println(json);
return false;
}
}
创建一个配置类，将拦截器的方法，实现拦截器的配置，并且使用这个拦截器拦截一些路径
package com.zzuli.springbot.jwtconfig;
import com.zzuli.springbot.interceptors.JWTInterceptors;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
//表明这个类是一个配置类，继承WebMvcConfigurer
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
//增加一个拦截的方法
registry.addInterceptor(new JWTInterceptors())
//增加一个拦截路径，拦截所有路径 使用 /** 表示
.addPathPatterns("/user/test")
//排除用户相关的路径
.excludePathPatterns("/user/login");
}
}
将以上逻辑代码写完之后，使用postman进行实测，开启springboot服务
user/login 拦截器设置的是没有拦截
生成一个token之后复制下来，进行使用token通过拦截器拦截的路径
user/test
故意制造一个错误，看是否验证通过
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
