JWT入门

╰半橙微兮° 2024-04-06 10:38 81阅读 0赞

**目录**

一、JWT是什么？

二、JWT的组成

三、JWT的运行机制

四、实际应用

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

--------------------

## 一、JWT是什么？ ##

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

有那么多的技术用于跨域身份验证我们为什么要用JWT呢？

> JWT的精髓在于：“[去中心化][Link 1]”，数据是保存在客户端的。

## 二、JWT的组成 ##

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

![6db049dabab1466e8c70643012367baa.jpeg][]

## 三、JWT的运行机制 ##

在分享JWT运行机制之前，先要分享如果不用JWT我们要怎么完成跨域身份验证。

> 按之前的方法：
> 
> 1、用户向服务器发送用户名和密码
> 
> 2、服务器验证后，相关的数据会保存在会话中。
> 
> 3、服务器向用户返回session\_id，session信息写入用户的cookie中。
> 
> 4、用户的每个后续的请求都将在cookie中取出session\_id传给服务器。
> 
> 5、服务器接收后与之前存储的数据进行对比，确认用户身份。
> 
> 对于这种方法优化的话，应该持久化session数据，写入数据库或者文件持久层等。收到请求后，验证服务从持久层请求数据。
> 
> 但是这种方法工作量大，由于依赖持久的数据库，会有风险。

另一种方法就是用JWT啦,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串进行解析，解析成用户信息，最终进行校验。**  
>

## 四、实际应用 ##

JWTFilter

package com.zking.vue.util;
     
    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验证过滤器，配置顺序 ：CorsFilte-->JwtFilter-->struts2中央控制器
     * 
     * @author Administrator
     *
     */
    public class JwtFilter implements Filter {
     
    	// 排除的URL，一般为登陆的URL(请改成自己登陆的URL)
    	private static String EXCLUDE = "^/vue/userAction_login\\.action?.*$";
     
    	private static Pattern PATTERN = Pattern.compile(EXCLUDE);
     
    	private boolean OFF = true;// 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;
    		String path = req.getServletPath();
    		if (OFF || isExcludeUrl(path)) {// 登陆直接放行
    			chain.doFilter(request, response);
    			return;
    		}
     
    		// 从客户端请求头中获得令牌并验证
    		String jwt = req.getHeader(JwtUtils.JWT_HEADER_KEY);
    		Claims claims = this.validateJwtToken(jwt);
    		if (null == claims) {
    			// resp.setCharacterEncoding("UTF-8");
    			resp.sendError(403, "JWT令牌已过期或已失效");
    			return;
    		} else {
    			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) {
    				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);
    	// }
     
    }

在没开启JWT之前我们可以通过地址栏输入的方式跳过登录步骤直接进入页面。

在开启JWT之后我们直接通过地址栏进行页面跳转是不成功的。

UserAction

package com.zking.vue.web;
     
    import java.util.HashMap;
    import java.util.Map;
     
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.opensymphony.xwork2.ModelDriven;
    import com.zking.base.web.BaseAction;
    import com.zking.vue.biz.UserBiz;
    import com.zking.vue.entity.User;
    import com.zking.vue.util.JsonData;
    import com.zking.vue.util.JwtUtils;
    import com.zking.vue.util.PageBean;
    import com.zking.vue.util.ResponseUtil;
    import com.zking.vue.util.StringUtils;
     
    public class UserAction extends BaseAction implements ModelDriven<User>{
     
    	private UserBiz userBiz;
    	private User user = new User();
     
    	public UserBiz getUserBiz() {
    		return userBiz;
    	}
     
    	public void setUserBiz(UserBiz userBiz) {
    		this.userBiz = userBiz;
    	}
    	 
    	public String login() {
    		ObjectMapper om = new ObjectMapper();
    		JsonData jsonData = null;
    		try {
    			if(StringUtils.isBlank(user.getUname()) || StringUtils.isBlank(user.getPwd())) {
    				jsonData = new JsonData(0, "用户或者密码为空", user);
    			}else {
    				User u = this.userBiz.login(user);
    				Map<String, Object> claims = new HashMap<String, Object>();
    				claims.put("uname",user.getUname());
    				claims.put("pwd", user.getPwd());
    				String jwt = JwtUtils.createJwt(claims, JwtUtils.JWT_WEB_TTL);
    				response.setHeader(JwtUtils.JWT_HEADER_KEY, jwt);
    				jsonData = new JsonData(1, "登录成功", u);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    			jsonData = new JsonData(0, "用户或者密码错误", user);
    		}finally {
    			try {
    				ResponseUtil.write(response, om.writeValueAsString(jsonData));
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    		
    		return null;
    	}
    	
    	public String getAsyncData() {
    		ObjectMapper om = new ObjectMapper();
    		try {
    			Thread.sleep(6000);
    			ResponseUtil.write(response, om.writeValueAsString("http://www.javaxl.com"));
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
     
    	@Override
    	public User getModel() {
    		return user;
    	}
    }

**mutations.js**

export default {
        setAddress:(state,payload)=>{
      //  state对象就对应了state.js中的对象
      //  payload载荷 对应的 传递的 json对象参数{name:zs,age:24}
        state.resName=payload.resName;
      },
      setJwt:(state,payload)=>{
        state.jwt=payload.jwt;
      }
    }

**State.js**

export default{
      address:'地球'，
      jwt：''
    }

**http.js**

/**
     * vue项目对axios的全局配置
     */
    import axios from 'axios'
    import qs from 'qs'
     
    //引入action模块，并添加至axios的类属性urls上
    import action from '@/api/action'
    axios.urls = action
     
    // axios默认配置
    axios.defaults.timeout = 10000; // 超时时间
    // axios.defaults.baseURL = 'http://localhost:8080/j2ee15'; // 默认地址
    axios.defaults.baseURL = action.SERVER;
     
    //整理数据
    // 只适用于 POST,PUT,PATCH，transformRequest` 允许在向服务器发送前，修改请求数据
    axios.defaults.transformRequest = function(data) {
    	data = qs.stringify(data);
    	return data;
    };
     
     
    // 请求拦截器
    axios.interceptors.request.use(function(config) {
    	var jwt = window.vm.$store.getters.getJwt;
    	config.headers['jwt'] = jwt;
    	return config;
    }, function(error) {
    	return Promise.reject(error);
    });
     
     
     
     
    export default axios;

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

####  **JwtUtils** ####

package com.zking.vue.util;
     
    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那部分，jjwt已经将这部分内容封装好了。
    	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<String, Object> claims, long ttlMillis) {
    		// 生成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();
    	}
     
    	/**
    	 * 复制jwt，并重新设置签发时间(为当前时间)和失效时间
    	 * 
    	 * @param jwt
    	 *            被复制的jwt令牌
    	 * @param ttlMillis
    	 *            jwt的有效时间(单位毫秒)，当前时间+有效时间=过期时间
    	 * @return
    	 */
    	public static String copyJwt(String jwt, Long ttlMillis) {
    		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();
    	}
    }

package com.zking.vue.test;
     
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
     
    import org.junit.Test;
     
    import com.zking.vue.util.JwtUtils;
     
    import io.jsonwebtoken.Claims;
     
    public class JwtDemo {
     
    	private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
     
    //	应用场景一：就是用户信息加密，解密的场景
    	@Test
    	public void test1() {// 生成JWT
    		Map<String, Object> claims = new HashMap<String, Object>();
    		claims.put("username", "zss");
    		claims.put("age", 18);
     
    		String jwt = JwtUtils.createJwt(claims, JwtUtils.JWT_WEB_TTL);
    		System.out.println(jwt);
     
    		Claims parseJwt = JwtUtils.parseJwt(jwt);
    		for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
    			System.out.println(entry.getKey() + "=" + entry.getValue());
    		}
    		Date d1 = parseJwt.getIssuedAt();
    		Date d2 = parseJwt.getExpiration();
    		System.out.println("令牌签发时间：" + sdf.format(d1));
    		System.out.println("令牌过期时间：" + sdf.format(d2));
    	}
     
    //	场景二：令牌过期
    	@Test
    	public void test2() {// 解析oldJwt
    //		String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjI5MDMzNjAsImlhdCI6MTU2MjkwMTU2MCwiYWdlIjoxOCwianRpIjoiZDVjMzE4Njg0MDcyNDgyZDg1MDE5ODVmMDY3OGQ4NjkiLCJ1c2VybmFtZSI6InpzcyJ9.XDDDRRq5jYq5EdEBHtPm7GcuBz4S0VhDTS1amRCdf48";
    		String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjM1MjU5MjMsImlhdCI6MTU2MzUyNDEyMywiYWdlIjoxOCwianRpIjoiOTAzNmMwY2Q3NGIwNDBjMzgzMDAxYzdiNmZkMzYzZmIiLCJ1c2VybmFtZSI6InpzcyJ9.sgV9fr4fgmmahDFRJnsfazA6R3H-gNMVcg2ucA227n4";
    		Claims parseJwt = JwtUtils.parseJwt(oldJwt);
    		for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
    			System.out.println(entry.getKey() + "=" + entry.getValue());
    		}
    		Date d1 = parseJwt.getIssuedAt();
    		Date d2 = parseJwt.getExpiration();
    		System.out.println("令牌签发时间：" + sdf.format(d1));
    		System.out.println("令牌过期时间：" + sdf.format(d2));
    	}
     
    //	场景三：延长过期时间
    	@Test
    	public void test3() {// 复制jwt，并延时30秒
    		String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjI4NTMzMzAsImlhdCI6MTU2Mjg1MzMyNywidXNlcm5hbWUiOiJ6c3MifQ.e098Vj9KBlZfC12QSDhI5lUGRLbNwb27lrYYSL6JwrQ";
    		String jwt = JwtUtils.copyJwt(oldJwt, JwtUtils.JWT_WEB_TTL);
    		Claims parseJwt = JwtUtils.parseJwt(jwt);
    		for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
    			System.out.println(entry.getKey() + "=" + entry.getValue());
    		}
    		Date d1 = parseJwt.getIssuedAt();
    		Date d2 = parseJwt.getExpiration();
    		System.out.println("令牌签发时间：" + sdf.format(d1));
    		System.out.println("令牌过期时间：" + sdf.format(d2));
    	}
     
    	
    }

[Link 1]: https://so.csdn.net/so/search?q=%E5%8E%BB%E4%B8%AD%E5%BF%83%E5%8C%96&spm=1001.2101.3001.7020
[6db049dabab1466e8c70643012367baa.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/4fccba8f13ad41c39b0b0d3923869aee.jpeg