jwt使用

目录

一、jwt出现的原因及工作原理

1.JWT是什么

        JSON Web Token(JWT),它是目前最流行的跨域身份验证解决方案

2.为什么使用JWT

        JWT的精髓在于："去中心化"，数据是保存在客户端的 

3.JWT的工作原理

4.JWT的运行机制/原理 **** 

二、 jwt与vuex配合在SPA项目中的应用 

1.jwt实现 

三、 jwt工具类介绍，三种场景

1.JWT组成 

2.jwt工具类

一、jwt出现的原因及工作原理

1.JWT是什么

JSON Web Token(JWT),它是目前最流行的跨域身份验证解决方案

2.为什么使用JWT

JWT的精髓在于："去中心化"，数据是保存在客户端的 

3.JWT的工作原理

1.是在服务器身份验证之后，将生成一个JSON对象并将其发送回用户，示例如下：  {"UserName": "Chongchong","Role": "Admin","Expire": "2018-08-08 20:15:56"}

2.之后，当用户于服务器通信时，客户在请求中发回JSON对象

3.为了防止用户篡改数据，服务器将在生成对象时添加签名，并对发回的数据进行验证

传统开发对资源的访问限制利用session完整图解     

 4.JWT的运行机制/原理  ****

1.第一个发送登录请求，必然会携带用户信息uname和pwd

2.通过用户信息uname和pwd登录成功，会将用户信息通过jwt工具类生成一个加密的字符串

3.加密字符串会以 response header响应头的形式 响应到前端

4.前端服务器会有 响应拦截器拦截，截取到响应头中承载的jwt串，又会放到Vuex中

5.当发生第二次请求，前端服务器中有一个请求拦截器，会将Vuex中的jwt串放入 request header请求头中

6.当请求通过跨域的方式到达后台服务器，后台服务器中又有一个过滤器，会截取到 request header 请求头中的jwt串

7.jwt工具类会对jwt串进行解析，解析成用户信息，最终进行校验

                                                jwt所解决的问题及机制  

二、 jwt与vuex配合在SPA项目中的应用 

1.jwt实现 

JwtFilter.java

1.  
   package com.zking.vue.util;
2.  
    
3.  
   import java.io.IOException;
4.  
   import java.util.regex.Matcher;
5.  
   import java.util.regex.Pattern;
6.  
    
7.  
   import javax.servlet.Filter;
8.  
   import javax.servlet.FilterChain;
9.  
   import javax.servlet.FilterConfig;
10.  
    import javax.servlet.ServletException;
11.  
    import javax.servlet.ServletRequest;
12.  
    import javax.servlet.ServletResponse;
13.  
    import javax.servlet.http.HttpServletRequest;
14.  
    import javax.servlet.http.HttpServletResponse;
15.  
     
16.  
    import io.jsonwebtoken.Claims;
17.  
     
18.  
    /**
19.  
    * * JWT验证过滤器，配置顺序 ：CorsFilte-->JwtFilter-->struts2中央控制器
20.  
    *
21.  
    * @author Administrator
22.  
    *
23.  
    */
24.  
    public class JwtFilter implements Filter {
25.  
     
26.  
    // 排除的URL，一般为登陆的URL(请改成自己登陆的URL)
27.  
    private static String EXCLUDE = "^/vue/userAction_login\\.action?.*$";
28.  
     
29.  
    private static Pattern PATTERN = Pattern.compile(EXCLUDE);
30.  
     
31.  
    private boolean OFF = false;// true关闭jwt令牌验证功能
32.  
     
33.  
    @Override
34.  
    public void init(FilterConfig filterConfig) throws ServletException {
35.  
    }
36.  
     
37.  
    @Override
38.  
    public void destroy() {
39.  
    }
40.  
     
41.  
    @Override
42.  
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
43.  
    throws IOException, ServletException {
44.  
    HttpServletRequest req = (HttpServletRequest) request;
45.  
    HttpServletResponse resp = (HttpServletResponse) response;
46.  
    String path = req.getServletPath();
47.  
    if (OFF || isExcludeUrl(path)) {// 登陆直接放行
48.  
    chain.doFilter(request, response);
49.  
    return;
50.  
    }
51.  
     
52.  
    // 从客户端请求头中获得令牌并验证
53.  
    String jwt = req.getHeader(JwtUtils.JWT_HEADER_KEY);
54.  
    Claims claims = this.validateJwtToken(jwt);
55.  
    if (null == claims) {
56.  
    // resp.setCharacterEncoding("UTF-8");
57.  
    resp.sendError(403, "JWT令牌已过期或已失效");
58.  
    return;
59.  
    } else {
60.  
    String newJwt = JwtUtils.copyJwt(jwt, JwtUtils.JWT_WEB_TTL);
61.  
    resp.setHeader(JwtUtils.JWT_HEADER_KEY, newJwt);
62.  
    chain.doFilter(request, response);
63.  
    }
64.  
    }
65.  
     
66.  
    /**
67.  
    * 验证jwt令牌，验证通过返回声明(包括公有和私有)，返回null则表示验证失败
68.  
    */
69.  
    private Claims validateJwtToken(String jwt) {
70.  
    Claims claims = null;
71.  
    try {
72.  
    if (null != jwt) {
73.  
    claims = JwtUtils.parseJwt(jwt);
74.  
    }
75.  
    } catch (Exception e) {
76.  
    e.printStackTrace();
77.  
    }
78.  
    return claims;
79.  
    }
80.  
     
81.  
    /**
82.  
    * 是否为排除的URL
83.  
    *
84.  
    * @param path
85.  
    * @return
86.  
    */
87.  
    private boolean isExcludeUrl(String path) {
88.  
    Matcher matcher = PATTERN.matcher(path);
89.  
    return matcher.matches();
90.  
    }
91.  
     
92.  
    // public static void main(String[] args) {
93.  
    // String path = "/sys/userAction_doLogin.action?username=zs&password=123";
94.  
    // Matcher matcher = PATTERN.matcher(path);
95.  
    // boolean b = matcher.matches();
96.  
    // System.out.println(b);
97.  
    // }
98.  
     
99.  
     
100.  
     }

重启启动一下项目： 

我们退出重新登录一下：它还是会报个403的错，是因为别人给你开了校验

因为我们的jwt还没有开始写 

后台的UserAction.java

1.  
   package com.zking.vue.web;
2.  
    
3.  
   import java.util.HashMap;
4.  
   import java.util.Map;
5.  
    
6.  
   import com.fasterxml.jackson.databind.ObjectMapper;
7.  
   import com.opensymphony.xwork2.ModelDriven;
8.  
   import com.zking.base.web.BaseAction;
9.  
   import com.zking.vue.biz.UserBiz;
10.  
    import com.zking.vue.entity.User;
11.  
    import com.zking.vue.util.JsonData;
12.  
    import com.zking.vue.util.JwtUtils;
13.  
    import com.zking.vue.util.PageBean;
14.  
    import com.zking.vue.util.ResponseUtil;
15.  
    import com.zking.vue.util.StringUtils;
16.  
     
17.  
    public class UserAction extends BaseAction implements ModelDriven<User>{
18.  
     
19.  
    private UserBiz userBiz;
20.  
    private User user = new User();
21.  
     
22.  
    public UserBiz getUserBiz() {
23.  
    return userBiz;
24.  
    }
25.  
     
26.  
    public void setUserBiz(UserBiz userBiz) {
27.  
    this.userBiz = userBiz;
28.  
    }
29.  
     
30.  
    public String login() {
31.  
    ObjectMapper om = new ObjectMapper();
32.  
    JsonData jsonData = null;
33.  
    try {
34.  
    if(StringUtils.isBlank(user.getUname()) || StringUtils.isBlank(user.getPwd())) {
35.  
    jsonData = new JsonData(0, "用户或者密码为空", user);
36.  
    }else {
37.  
    User u = this.userBiz.login(user);
38.  
    Map<String, Object> claims = new HashMap<String, Object>();
39.  
    claims.put("uname",user.getUname());
40.  
    claims.put("pwd", user.getPwd());
41.  
    String jwt = JwtUtils.createJwt(claims, JwtUtils.JWT_WEB_TTL);
42.  
    response.setHeader(JwtUtils.JWT_HEADER_KEY, jwt);
43.  
    jsonData = new JsonData(1, "登录成功", u);
44.  
    }
45.  
    } catch (Exception e) {
46.  
    e.printStackTrace();
47.  
    jsonData = new JsonData(0, "用户或者密码错误", user);
48.  
    }finally {
49.  
    try {
50.  
    ResponseUtil.write(response, om.writeValueAsString(jsonData));
51.  
    } catch (Exception e) {
52.  
    e.printStackTrace();
53.  
    }
54.  
    }
55.  
     
56.  
    return null;
57.  
    }
58.  
     
59.  
    public String getAsyncData() {
60.  
    ObjectMapper om = new ObjectMapper();
61.  
    try {
62.  
    Thread.sleep(6000);
63.  
    ResponseUtil.write(response, om.writeValueAsString("http://www.javaxl.com"));
64.  
    } catch (Exception e) {
65.  
    e.printStackTrace();
66.  
    }
67.  
    return null;
68.  
    }
69.  
     
70.  
    @Override
71.  
    public User getModel() {
72.  
    return user;
73.  
    }
74.  
    }

前端 state.js

1.  
   export default{
2.  
   resName:'烤肉餐馆',
3.  
   jwt:''
4.  
   }

mutations.js

1.  
   export default{
2.  
   //设置值
3.  
   setResName:(state,payload) => {
4.  
   // state对象就对应了state.js中的对象
5.  
   // payload载荷 对应的 传递的 json对象参数{name:zs,age:14}
6.  
   state.resName = payload.resName;
7.  
   },
8.  
   setJwt:(state,payload) => {
9.  
   state.jwt = payload.jwt;
10.  
    }
11.  
    }

main.js

1.  
   // The Vue build version to load with the `import` command
2.  
   // (runtime-only or standalone) has been set in webpack.base.conf with an alias.
3.  
   import Vue from 'vue'
4.  
   // process.env.MOCK 为 false ，那么require('@/mock') 不执行的；process.env.MOCK在生产环境下为false
5.  
   // process.env.MOCK && require('@/mock') //开发环境下才会引入mockjs
6.  
   // 引入elementUI
7.  
   import ElementUI from 'element-ui' // 新添加 1
8.  
   import 'element-ui/lib/theme-chalk/index.css' // 新添加 2 ，避免后期打包样式不同，要放在import App from './App'; 之前
9.  
   import App from './App'
10.  
    // 1.引入vue的路由依赖 已有
11.  
    import router from './router'
12.  
    import axios from '@/api/http'  //#vue项目对axios的全局配置    
13.  
    // import axios from 'axios'  
14.  
    import VueAxios from 'vue-axios'
15.  
    import store from './store'
16.  
     
17.  
    Vue.use(VueAxios,axios)
18.  
    Vue.use(ElementUI)   // 新添加 3 使用ElemenUI
19.  
    Vue.config.productionTip = false
20.  
     
21.  
    /* eslint-disable no-new */
22.  
    window.vm = new Vue({
23.  
    el: '#app',
24.  
    // 5.挂载 已有
25.  
    router,
26.  
    store,
27.  
    data(){
28.  
    return {
29.  
    // 在vue根实例中定义变量，这个变量就是vue实例，它总线
30.  
    // props this.$emit
31.  
    Bus:new Vue({
32.  
     
33.  
    })
34.  
    }
35.  
    },
36.  
    components: { App },
37.  
    template: '<App/>'
38.  
    })

getters.js

1.  
   export default{
2.  
   //拿值
3.  
   getResName:(state) => {
4.  
   return state.resName;
5.  
   },
6.  
   getJwt:(state) => {
7.  
   return state.jwt;
8.  
   }
9.  
   }

 http.js

1.  
   /**
2.  
   * vue项目对axios的全局配置
3.  
   */
4.  
   import axios from 'axios'
5.  
   import qs from 'qs'
6.  
    
7.  
   //引入action模块，并添加至axios的类属性urls上
8.  
   import action from '@/api/action'
9.  
   axios.urls = action
10.  
     
11.  
    // axios默认配置
12.  
    axios.defaults.timeout = 10000; // 超时时间
13.  
    // axios.defaults.baseURL = 'http://localhost:8080/j2ee15'; // 默认地址
14.  
    axios.defaults.baseURL = action.SERVER;
15.  
     
16.  
    //整理数据
17.  
    // 只适用于 POST,PUT,PATCH，transformRequest` 允许在向服务器发送前，修改请求数据
18.  
    axios.defaults.transformRequest = function(data) {
19.  
    data = qs.stringify(data);
20.  
    return data;
21.  
    };
22.  
     
23.  
     
24.  
    // 请求拦截器
25.  
    axios.interceptors.request.use(function(config) {
26.  
    var jwt = window.vm.$store.getters.getJwt;
27.  
    config.headers['jwt'] = jwt;
28.  
    return config;
29.  
    }, function(error) {
30.  
    return Promise.reject(error);
31.  
    });
32.  
     
33.  
    // 响应拦截器
34.  
    axios.interceptors.response.use(function(response) {
35.  
    // debugger;
36.  
    var jwt = response.headers['jwt'];
37.  
    if(jwt){
38.  
    window.vm.$store.commit('setJwt',{jwt:jwt});
39.  
    }
40.  
    return response;
41.  
    }, function(error) {
42.  
    return Promise.reject(error);
43.  
    });
44.  
     
45.  
    // // 路由请求拦截
46.  
    // // http request 拦截器
47.  
    // axios.interceptors.request.use(
48.  
    // config => {
49.  
    // //config.data = JSON.stringify(config.data);
50.  
    // //config.headers['Content-Type'] = 'application/json;charset=UTF-8';
51.  
    // //config.headers['Token'] = 'abcxyz';
52.  
    // //判断是否存在ticket，如果存在的话，则每个http header都加上ticket
53.  
    // // if (cookie.get("token")) {
54.  
    // // //用户每次操作，都将cookie设置成2小时
55.  
    // // cookie.set("token", cookie.get("token"), 1 / 12)
56.  
    // // cookie.set("name", cookie.get("name"), 1 / 12)
57.  
    // // config.headers.token = cookie.get("token");
58.  
    // // config.headers.name = cookie.get("name");
59.  
    // // }
60.  
    // return config;
61.  
    // },
62.  
    // error => {
63.  
    // return Promise.reject(error.response);
64.  
    // });
65.  
     
66.  
    // // 路由响应拦截
67.  
    // // http response 拦截器
68.  
    // axios.interceptors.response.use(
69.  
    // response => {
70.  
    // if (response.data.resultCode == "404") {
71.  
    // console.log("response.data.resultCode是404")
72.  
    // // 返回 错误代码-1 清除ticket信息并跳转到登录页面
73.  
    // // cookie.del("ticket")
74.  
    // // window.location.href='http://login.com'
75.  
    // return
76.  
    // } else {
77.  
    // return response;
78.  
    // }
79.  
    // },
80.  
    // error => {
81.  
    // return Promise.reject(error.response) // 返回接口返回的错误信息
82.  
    // });
83.  
     
84.  
     
85.  
     
86.  
    export default axios;

再去刷新一下，我们的数据就出来了，如图所示：

三、 jwt工具类介绍，三种场景

1.JWT组成 

一个JWT实际上就是一个字符串，它由三部分组成：头部（Header）、载荷（Payload）与签名（signature）

JWT结果原理图：                JWT的数据结构图

JWT实际结构：eyJhbGciOiJIUzI1NiJ9.
                eyJzdWIiOiJ7fSIsImlzcyI6InpraW5nIiwiZXhwIjoxNTYyODUwMjM3LCJpYXQiOjE1NjI4NDg0MzcsImp0aSI6ImM5OWEyMzRmMDc4NzQyZWE4YjlmYThlYmYzY2VhNjBlIiwidXNlcm5hbWUiOiJ6c3MifQ.
                WUfqhFTeGzUZCpCfz5eeEpBXBZ8-lYg1htp-t7wD3I4

它是一个很长的字符串，中间用点（.）分隔成三个部分。注意，JWT 内部是没有换行的，这里只是为了便于展示，将它写成了几行。
   写成一行，就是下面的样子：Header.Payload.Signature

2.jwt工具类

 后台的JwtUtils.java

1.  
   package com.zking.vue.util;
2.  
    
3.  
   import java.util.Date;
4.  
   import java.util.Map;
5.  
   import java.util.UUID;
6.  
    
7.  
   import javax.crypto.SecretKey;
8.  
   import javax.crypto.spec.SecretKeySpec;
9.  
    
10.  
    import org.apache.commons.codec.binary.Base64;
11.  
     
12.  
    import io.jsonwebtoken.Claims;
13.  
    import io.jsonwebtoken.JwtBuilder;
14.  
    import io.jsonwebtoken.Jwts;
15.  
    import io.jsonwebtoken.SignatureAlgorithm;
16.  
     
17.  
    /**
18.  
    * JWT验证过滤器：配置顺序 CorsFilte->JwtUtilsr-->StrutsPrepareAndExecuteFilter
19.  
    *
20.  
    */
21.  
    public class JwtUtils {
22.  
    /**
23.  
    * JWT_WEB_TTL：WEBAPP应用中token的有效时间,默认30分钟
24.  
    */
25.  
    public static final long JWT_WEB_TTL = 30 * 60 * 1000;
26.  
     
27.  
    /**
28.  
    * 将jwt令牌保存到header中的key
29.  
    */
30.  
    public static final String JWT_HEADER_KEY = "jwt";
31.  
     
32.  
    // 指定签名的时候使用的签名算法，也就是header那部分，jjwt已经将这部分内容封装好了。
33.  
    private static final SignatureAlgorithm SIGNATURE_ALGORITHM = SignatureAlgorithm.HS256;
34.  
    private static final String JWT_SECRET = "f356cdce935c42328ad2001d7e9552a3";// JWT密匙
35.  
    private static final SecretKey JWT_KEY;// 使用JWT密匙生成的加密key
36.  
     
37.  
    static {
38.  
    byte[] encodedKey = Base64.decodeBase64(JWT_SECRET);
39.  
    JWT_KEY = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
40.  
    }
41.  
     
42.  
    private JwtUtils() {
43.  
    }
44.  
     
45.  
    /**
46.  
    * 解密jwt，获得所有声明(包括标准和私有声明)
47.  
    *
48.  
    * @param jwt
49.  
    * @return
50.  
    * @throws Exception
51.  
    */
52.  
    public static Claims parseJwt(String jwt) {
53.  
    Claims claims = Jwts.parser().setSigningKey(JWT_KEY).parseClaimsJws(jwt).getBody();
54.  
    return claims;
55.  
    }
56.  
     
57.  
    /**
58.  
    * 创建JWT令牌，签发时间为当前时间
59.  
    *
60.  
    * @param claims
61.  
    * 创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
62.  
    * @param ttlMillis
63.  
    * JWT的有效时间(单位毫秒)，当前时间 有效时间=过期时间
64.  
    * @return jwt令牌
65.  
    */
66.  
    public static String createJwt(Map<String, Object> claims, long ttlMillis) {
67.  
    // 生成JWT的时间，即签发时间
68.  
    long nowMillis = System.currentTimeMillis();
69.  
     
70.  
    // 下面就是在为payload添加各种标准声明和私有声明了
71.  
    // 这里其实就是new一个JwtBuilder，设置jwt的body
72.  
    JwtBuilder builder = Jwts.builder()
73.  
    // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
74.  
    .setClaims(claims)
75.  
    // 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
76.  
    // 可以在未登陆前作为身份标识使用
77.  
    .setId(UUID.randomUUID().toString().replace("-", ""))
78.  
    // iss(Issuser)签发者，写死
79.  
    // .setIssuer("zking")
80.  
    // iat: jwt的签发时间
81.  
    .setIssuedAt(new Date(nowMillis))
82.  
    // 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
83.  
    // .setSubject("{}")
84.  
    // 设置签名使用的签名算法和签名使用的秘钥
85.  
    .signWith(SIGNATURE_ALGORITHM, JWT_KEY)
86.  
    // 设置JWT的过期时间
87.  
    .setExpiration(new Date(nowMillis ttlMillis));
88.  
     
89.  
    return builder.compact();
90.  
    }
91.  
     
92.  
    /**
93.  
    * 复制jwt，并重新设置签发时间(为当前时间)和失效时间
94.  
    *
95.  
    * @param jwt
96.  
    * 被复制的jwt令牌
97.  
    * @param ttlMillis
98.  
    * jwt的有效时间(单位毫秒)，当前时间 有效时间=过期时间
99.  
    * @return
100.  
     */
101.  
     public static String copyJwt(String jwt, Long ttlMillis) {
102.  
     Claims claims = parseJwt(jwt);
103.  
      
104.  
     // 生成JWT的时间，即签发时间
105.  
     long nowMillis = System.currentTimeMillis();
106.  
      
107.  
     // 下面就是在为payload添加各种标准声明和私有声明了
108.  
     // 这里其实就是new一个JwtBuilder，设置jwt的body
109.  
     JwtBuilder builder = Jwts.builder()
110.  
     // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
111.  
     .setClaims(claims)
112.  
     // 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
113.  
     // 可以在未登陆前作为身份标识使用
114.  
     //.setId(UUID.randomUUID().toString().replace("-", ""))
115.  
     // iss(Issuser)签发者，写死
116.  
     // .setIssuer("zking")
117.  
     // iat: jwt的签发时间
118.  
     .setIssuedAt(new Date(nowMillis))
119.  
     // 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
120.  
     // .setSubject("{}")
121.  
     // 设置签名使用的签名算法和签名使用的秘钥
122.  
     .signWith(SIGNATURE_ALGORITHM, JWT_KEY)
123.  
     // 设置JWT的过期时间
124.  
     .setExpiration(new Date(nowMillis ttlMillis));
125.  
     return builder.compact();
126.  
     }
127.  
     }

JwtDemo.java

1.  
   package com.zking.vue.test;
2.  
    
3.  
   import java.text.SimpleDateFormat;
4.  
   import java.util.Date;
5.  
   import java.util.HashMap;
6.  
   import java.util.Map;
7.  
    
8.  
   import org.junit.Test;
9.  
    
10.  
    import com.zking.vue.util.JwtUtils;
11.  
     
12.  
    import io.jsonwebtoken.Claims;
13.  
     
14.  
    public class JwtDemo {
15.  
     
16.  
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
17.  
     
18.  
    // 应用场景一：就是用户信息加密，解密的场景
19.  
    @Test
20.  
    public void test1() {// 生成JWT
21.  
    Map<String, Object> claims = new HashMap<String, Object>();
22.  
    claims.put("username", "zss");
23.  
    claims.put("age", 18);
24.  
     
25.  
    String jwt = JwtUtils.createJwt(claims, JwtUtils.JWT_WEB_TTL);
26.  
    System.out.println(jwt);
27.  
     
28.  
    Claims parseJwt = JwtUtils.parseJwt(jwt);
29.  
    for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
30.  
    System.out.println(entry.getKey() "=" entry.getValue());
31.  
    }
32.  
    Date d1 = parseJwt.getIssuedAt();
33.  
    Date d2 = parseJwt.getExpiration();
34.  
    System.out.println("令牌签发时间：" sdf.format(d1));
35.  
    System.out.println("令牌过期时间：" sdf.format(d2));
36.  
    }
37.  
     
38.  
    // 场景二：令牌过期
39.  
    @Test
40.  
    public void test2() {// 解析oldJwt
41.  
    // String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjI5MDMzNjAsImlhdCI6MTU2MjkwMTU2MCwiYWdlIjoxOCwianRpIjoiZDVjMzE4Njg0MDcyNDgyZDg1MDE5ODVmMDY3OGQ4NjkiLCJ1c2VybmFtZSI6InpzcyJ9.XDDDRRq5jYq5EdEBHtPm7GcuBz4S0VhDTS1amRCdf48";
42.  
    String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjM1MjU5MjMsImlhdCI6MTU2MzUyNDEyMywiYWdlIjoxOCwianRpIjoiOTAzNmMwY2Q3NGIwNDBjMzgzMDAxYzdiNmZkMzYzZmIiLCJ1c2VybmFtZSI6InpzcyJ9.sgV9fr4fgmmahDFRJnsfazA6R3H-gNMVcg2ucA227n4";
43.  
    Claims parseJwt = JwtUtils.parseJwt(oldJwt);
44.  
    for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
45.  
    System.out.println(entry.getKey() "=" entry.getValue());
46.  
    }
47.  
    Date d1 = parseJwt.getIssuedAt();
48.  
    Date d2 = parseJwt.getExpiration();
49.  
    System.out.println("令牌签发时间：" sdf.format(d1));
50.  
    System.out.println("令牌过期时间：" sdf.format(d2));
51.  
    }
52.  
     
53.  
    // 场景三：延长过期时间
54.  
    @Test
55.  
    public void test3() {// 复制jwt，并延时30秒
56.  
    String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjI4NTMzMzAsImlhdCI6MTU2Mjg1MzMyNywidXNlcm5hbWUiOiJ6c3MifQ.e098Vj9KBlZfC12QSDhI5lUGRLbNwb27lrYYSL6JwrQ";
57.  
    String jwt = JwtUtils.copyJwt(oldJwt, JwtUtils.JWT_WEB_TTL);
58.  
    Claims parseJwt = JwtUtils.parseJwt(jwt);
59.  
    for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
60.  
    System.out.println(entry.getKey() "=" entry.getValue());
61.  
    }
62.  
    Date d1 = parseJwt.getIssuedAt();
63.  
    Date d2 = parseJwt.getExpiration();
64.  
    System.out.println("令牌签发时间：" sdf.format(d1));
65.  
    System.out.println("令牌过期时间：" sdf.format(d2));
66.  
    }
67.  
     
68.  
    @Test
69.  
    public void test4() {// 测试JWT的有效时间
70.  
    Map<String, Object> claims = new HashMap<String, Object>();
71.  
    claims.put("username", "zss");
72.  
    String jwt = JwtUtils.createJwt(claims, 3 * 1000L);
73.  
    System.out.println(jwt);
74.  
    Claims parseJwt = JwtUtils.parseJwt(jwt);
75.  
    Date d1 = parseJwt.getIssuedAt();
76.  
    Date d2 = parseJwt.getExpiration();
77.  
    System.out.println("令牌签发时间：" sdf.format(d1));
78.  
    System.out.println("令牌过期时间：" sdf.format(d2));
79.  
    }
80.  
     
81.  
    @Test
82.  
    public void test5() {// 三秒后再解析上面过期时间只有三秒的令牌，因为过期则会报错io.jsonwebtoken.ExpiredJwtException
83.  
    String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjI4NTMzMzAsImlhdCI6MTU2Mjg1MzMyNywidXNlcm5hbWUiOiJ6c3MifQ.e098Vj9KBlZfC12QSDhI5lUGRLbNwb27lrYYSL6JwrQ";
84.  
    Claims parseJwt = JwtUtils.parseJwt(oldJwt);
85.  
    // 过期后解析就报错了，下面代码根本不会执行
86.  
    Date d1 = parseJwt.getIssuedAt();
87.  
    Date d2 = parseJwt.getExpiration();
88.  
    System.out.println("令牌签发时间：" sdf.format(d1));
89.  
    System.out.println("令牌过期时间：" sdf.format(d2));
90.  
    }
91.  
    }

这篇好文章是转载于：学新通技术网