了解什么是JWT
目录
JWT
是什么
有什么用
Jwt的使用
依赖
工具类
过滤器
控制器
配置
测试类
案列
JWT
是什么
JWT是指JSON Web Token，它是一种用于在网络应用间安全传递信息的开放标准（RFC 7519）。JWT通过使用私钥对JSON数据进行签名或者使用公钥对数据进行验证来确保数据的完整性和安全性。它通常被用于身份验证和授权机制，使得用户在不需要再次进行登录的情况下可以访问受保护的资源。
JWT由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。头部包含了关于签名算法的信息，载荷包含了要传递的数据，签名用于验证JWT的来源和完整性。使用JWT可以方便地在应用间传递信息，并且无需在服务器端存储会话状态，这使得JWT非常适用于分布式系统。
头部（Header）：头部通常由两部分组成，加密算法和类型信息。加密算法指定了如何对JWT进行签名，常用的算法有HMAC、RSA和ECDSA等。类型信息通常是"JWT"。
载荷（Payload）：载荷是JWT的主要部分，包含了需要传递的用户信息、权限、角色等数据。载荷是一个JSON对象，可以自定义存储所需的信息。常用的标准声明有iss（签发者）、sub（主题）、exp（过期时间）等。
签名（Signature）：签名是对头部和载荷进行加密生成的结果。签名使用头部中指定的加密算法和密钥，确保JWT的完整性和真实性。服务器端在接收到JWT后，可以使用相同的密钥对JWT进行解密和验证。
有什么用
身份验证（Authentication）：JWT可以被用作用户身份验证的方式。用户登录认证成功后，服务器会生成一个JWT，并将其返回给客户端。客户端随后在每个请求中将JWT作为身份凭证发送给服务器。服务器可以通过验证JWT的有效性来确定用户的身份以及授权他们访问受保护的资源。
授权（Authorization）：除了身份验证之外，JWT还可以包含用户的权限信息。在生成JWT时，服务器可以将用户的权限信息加入到JWT的载荷中。这样一来，客户端在发送请求时，不仅可以验证用户的身份，还可以
0.9.1 3.4.0 根据JWT中的权限信息来判断用户是否有权访问请求的资源。
信息交换（Information Exchange）：由于JWT是基于标准的JSON格式，因此它可以轻松地在不同平台和系统之间进行信息交换。这使得JWT成为一种在分布式系统中安全传递信息的有效方式。
无状态（Stateless）：由于JWT包含了所有必要的信息，服务器不需要在后端存储会话状态。这意味着服务器更容易扩展，也更容易与其他微服务集成。
总而言之，JWT提供了一种安全、可靠的方式来传递信息并验证其来源和完整性。它在身份验证、授权和信息交换等场景下非常有用，并且有助于构建可扩展的分布式系统。
Jwt的使用
依赖
在后端项目中导入依赖:
在properties配置标签中
0.9.1
3.4.0 在dependencies配置标签中
io.jsonwebtoken
jjwt
${jwt.version}
com.auth0
java-jwt
${java.jwt.version}
工具类
在后台创建工具类 : CorsFilter
package com.xiaoxu.ssm.util;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 配置tomcat允许跨域访问
*
* @author Administrator
*
*/
public class CorsFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
HttpServletRequest req = (HttpServletRequest) servletRequest;
// Access-Control-Allow-Origin就是我们需要设置的域名
// Access-Control-Allow-Headers跨域允许包含的头。
// Access-Control-Allow-Methods是允许的请求方式
httpResponse.setHeader("Access-Control-Allow-Origin", "*");// *,任何域名
httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE");
//允许客户端发一个新的请求头jwt
httpResponse.setHeader("Access-Control-Allow-Headers","responseType,Origin,X-Requested-With, Content-Type, Accept, jwt");
//允许客户端处理一个新的响应头jwt
httpResponse.setHeader("Access-Control-Expose-Headers", "jwt,Content-Disposition");
//httpResponse.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
//httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE");
// axios的ajax会发两次请求，第一次提交方式为：option，直接返回即可
if ("OPTIONS".equals(req.getMethod())) {
return;
}
filterChain.doFilter(servletRequest, servletResponse);
}
@Override
public void destroy() {
}
}过滤器
在后台创建过滤器 : JwtFilter & JwtUtils
JwtFilter :
package com.xiaoxu.ssm.jwt;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import io.jsonwebtoken.Claims;
/**
* * JWT验证过滤器，配置顺序 ：CorsFilter-->JwtFilter-->struts2中央控制器
*
* @author Administrator
*
*/
public class JwtFilter implements Filter {
// 排除的URL，一般为登陆的URL(请改成自己登陆的URL)
private static String EXCLUDE = "^/user/userLogin?.*$";
private static Pattern PATTERN = Pattern.compile(EXCLUDE);
private boolean OFF = false;// true关闭jwt令牌验证功能
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse resp = (HttpServletResponse) response;
//获取当前请求路径。只有登录的请求路径不进行校验之外，其他的URL请求路径必须进行JWT令牌校验
//http://localhost:8080/ssh2/bookAction_queryBookPager.action
//req.getServletPath()==/bookAction_queryBookPager.action
String path = req.getServletPath();
if (OFF || isExcludeUrl(path)) {// 登陆直接放行
chain.doFilter(request, response);
return;
}
// 从客户端请求头中获得令牌并验证
//token=头.载荷.签名
String jwt = req.getHeader(JwtUtils.JWT_HEADER_KEY);
Claims claims = this.validateJwtToken(jwt);
//在这里请各位大哥大姐从JWT令牌中提取payload中的声明部分
//从声明部分中获取私有声明
//获取私有声明中的User对象 -> Modules
Boolean flag=false;
if (null == claims) {
// resp.setCharacterEncoding("UTF-8");
resp.sendError(403, "JWT令牌已过期或已失效");
return;
} else {
//1.获取已经解析后的payload（私有声明）
//2.从私有声明中当前用户所对应的权限集合List或者List
//3.循环权限(Module[id,url])
// OK,放行请求 chain.doFilter(request, response);
// NO,发送错误信息的JSON
// ObjectMapper mapper=new ObjectMapper()
// mapper.writeValue(response.getOutputStream(),json)
String newJwt = JwtUtils.copyJwt(jwt, JwtUtils.JWT_WEB_TTL);
resp.setHeader(JwtUtils.JWT_HEADER_KEY, newJwt);
chain.doFilter(request, response);
}
}
/**
* 验证jwt令牌，验证通过返回声明(包括公有和私有)，返回null则表示验证失败
*/
private Claims validateJwtToken(String jwt) {
Claims claims = null;
try {
if (null != jwt) {
//该解析方法会验证：1）是否过期 2）签名是否成功
claims = JwtUtils.parseJwt(jwt);
}
} catch (Exception e) {
e.printStackTrace();
}
return claims;
}
/**
* 是否为排除的URL
*
* @param path
* @return
*/
private boolean isExcludeUrl(String path) {
Matcher matcher = PATTERN.matcher(path);
return matcher.matches();
}
// public static void main(String[] args) {
// String path = "/sys/userAction_doLogin.action?username=zs&password=123";
// Matcher matcher = PATTERN.matcher(path);
// boolean b = matcher.matches();
// System.out.println(b);
// }
} JwtUtils :
package com.xiaoxu.ssm.jwt;
import java.util.Date;
import java.util.Map;
import java.util.UUID;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
/**
* JWT验证过滤器：配置顺序 CorsFilte->JwtUtilsr-->StrutsPrepareAndExecuteFilter
*
*/
public class JwtUtils {
/**
* JWT_WEB_TTL：WEBAPP应用中token的有效时间,默认30分钟
*/
public static final long JWT_WEB_TTL = 30 * 60 * 1000;
/**
* 将jwt令牌保存到header中的key
*/
public static final String JWT_HEADER_KEY = "jwt";
// 指定签名的时候使用的签名算法，也就是header那部分，jwt已经将这部分内容封装好了。
private static final SignatureAlgorithm SIGNATURE_ALGORITHM = SignatureAlgorithm.HS256;
private static final String JWT_SECRET = "f356cdce935c42328ad2001d7e9552a3";// JWT密匙
private static final SecretKey JWT_KEY;// 使用JWT密匙生成的加密key
static {
byte[] encodedKey = Base64.decodeBase64(JWT_SECRET);
JWT_KEY = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
}
private JwtUtils() {
}
/**
* 解密jwt，获得所有声明(包括标准和私有声明)
*
* @param jwt
* @return
* @throws Exception
*/
public static Claims parseJwt(String jwt) {
Claims claims = Jwts.parser()
.setSigningKey(JWT_KEY)
.parseClaimsJws(jwt)
.getBody();
return claims;
}
/**
* 创建JWT令牌，签发时间为当前时间
*
* @param claims
* 创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
* @param ttlMillis
* JWT的有效时间(单位毫秒)，当前时间+有效时间=过期时间
* @return jwt令牌
*/
public static String createJwt(Map claims,
long ttlMillis) {
// 生成JWT的时间，即签发时间 2021-10-30 10:02:00 -> 30 10:32:00
long nowMillis = System.currentTimeMillis();
//链式语法：
// 下面就是在为payload添加各种标准声明和私有声明了
// 这里其实就是new一个JwtBuilder，设置jwt的body
JwtBuilder builder = Jwts.builder()
// 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
.setClaims(claims)
// 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
// 可以在未登陆前作为身份标识使用
.setId(UUID.randomUUID().toString().replace("-", ""))
// iss(Issuser)签发者，写死
.setIssuer("zking")
// iat: jwt的签发时间
.setIssuedAt(new Date(nowMillis))
// 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
// .setSubject("{}")
// 设置签名使用的签名算法和签名使用的秘钥
.signWith(SIGNATURE_ALGORITHM, JWT_KEY)
// 设置JWT的过期时间
.setExpiration(new Date(nowMillis + ttlMillis));
return builder.compact();
}
/**
* 复制jwt，并重新设置签发时间(为当前时间)和失效时间
*
* @param jwt
* 被复制的jwt令牌
* @param ttlMillis
* jwt的有效时间(单位毫秒)，当前时间+有效时间=过期时间
* @return
*/
public static String copyJwt(String jwt, Long ttlMillis) {
//解密JWT，获取所有的声明（私有和标准）
//old
Claims claims = parseJwt(jwt);
// 生成JWT的时间，即签发时间
long nowMillis = System.currentTimeMillis();
// 下面就是在为payload添加各种标准声明和私有声明了
// 这里其实就是new一个JwtBuilder，设置jwt的body
JwtBuilder builder = Jwts.builder()
// 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
.setClaims(claims)
// 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
// 可以在未登陆前作为身份标识使用
//.setId(UUID.randomUUID().toString().replace("-", ""))
// iss(Issuser)签发者，写死
// .setIssuer("zking")
// iat: jwt的签发时间
.setIssuedAt(new Date(nowMillis))
// 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
// .setSubject("{}")
// 设置签名使用的签名算法和签名使用的秘钥
.signWith(SIGNATURE_ALGORITHM, JWT_KEY)
// 设置JWT的过期时间
.setExpiration(new Date(nowMillis + ttlMillis));
return builder.compact();
}
}
控制器
在后端的用户登入去请求地址时，编写控制器中的代码 UserController
@RequestMapping("/userLogin")
@ResponseBody
public JsonResponseBody userLogin(UserVo userVo, HttpServletResponse response){
if(userVo.getUsername().equals("admin")&&userVo.getPassword().equals("123")){
//私有要求claim
Map json=new HashMap();
json.put("username", userVo.getUsername());
//生成JWT，并设置到response响应头中
String jwt=JwtUtils.createJwt(json, JwtUtils.JWT_WEB_TTL);
response.setHeader(JwtUtils.JWT_HEADER_KEY, jwt);
return new JsonResponseBody<>("用户登陆成功！",true,0,null);
}else{
return new JsonResponseBody<>("用户名或密码错误！",false,0,null);
}
} 配置
在后台项目中 ( Web.xml ) 进行对以上编写的类及过滤器进行配置
corsFilter
com.CloudJun.ssm.util.CorsFilter
corsFilter
/*
jwtFilter
com.CloudJun.ssm.jwt.JwtFilter
jwtFilter
/*
测试类
在对JWT进行测试，创建一个测试类，编写以下方法
在测试类需要加以下代码
private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");案列
export default {
// type(事件类型)： 其值为setEduName
// payload：官方给它还取了一个高大上的名字：载荷，其实就是一个保存要传递参数的容器
setEduName: (state, payload) => {
state.eduName = payload.eduName;
},
setJwt:(state,payload)=>{
state.jwt=payload.jwt;
}
}在store文件下添加：state.js添加属性：
export default {
eduName: '默认值',
jwt:''
}设置和获取
export default {
// type(事件类型)： 其值为setEduName
// payload：官方给它还取了一个高大上的名字：载荷，其实就是一个保存要传递参数的容器
setEduName: (state, payload) => {
state.eduName = payload.eduName;
},
setJwt:(state,payload)=>{
state.jwt=payload.jwt;
}
}export default {
getEduName: (state) => {
return state.eduName;
},
getJwt: (state) => {
return state.jwt;
}
}接着在配置spa项目的全局配置https.js里面配置：
// 请求拦截器
axios.interceptors.request.use(function(config) {
let jwt = window.mm.$store.getters.getJwt;
if(jwt){
config.headers['jwt'] = jwt;
}
return config;
}, function(error) {
return Promise.reject(error);
});
// 响应拦截器
axios.interceptors.response.use(function(response) {
//将响应头中的jwt字符串放入state.js中
let jwt = response.headers['jwt'];
if (jwt) {
window.mm.$store.commit('setJwt', {
jwt: jwt
});
}
return response;
}, function(error) {
return Promise.reject(error);
});