jwt utils

最新推荐文章于 2024-03-26 16:50:11 发布
转载 最新推荐文章于 2024-03-26 16:50:11 发布 · 621 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/xiaominmin/blog/3000381
文章标签：

#java #前端 #python #ViewUI

本文深入讲解了JSON Web Token (JWT) 认证机制的实现细节，包括如何使用Java生成和解析JWT，以及如何在Web应用中集成JWT进行用户身份验证。文章通过具体代码示例，解释了JWT的创建、加密、存储和验证过程，并探讨了JWT在实际应用中的常见问题及解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.codec.binary.Base64;

import com.dominos.cloud.common.enums.ResultMsg;
import com.dominos.cloud.common.exception.DominosRunTimeException;
import com.dominos.cloud.common.helper.RedisManager;
import com.dominos.cloud.common.util.ConstantsUtil;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class JwtUtil {

	
	    public static final String JWT_ID = UUID.randomUUID().toString();
	    /**
	     * 加密密文
	     */
	    public static final String JWT_SECRET = "XXX";
	    public static final String JWT_ISSUER = "XXX";
	    public static final String JWT_SUBJECT= "XXX";
	    
	    //jwt 的缓存时间 
	    public static final int JWT_TTL = 60 * 1000 ;  //millisecond
	    //老的jwt缓存10秒
	    public static final int OLD_JWT_TTL = 10; 
	    
	    public static final String OLD_JWT_KEY = "old_";
	    
	    public static final String NEW_JWT_KEY = "new_";
	    
	    public static final String USER_JWT_KEY = "user_jwt_";
	    
	    public static final byte[] bt = new byte[] {};
	    
	    
    /**
     * 由字符串生成加密key
     *
     * @return
     */
    public static SecretKey generalKey() {
    	
    	
    	    
    	    
        String stringKey = JWT_SECRET;

        // 本地的密码解码
        byte[] encodedKey = Base64.decodeBase64(stringKey);

        // 根据给定的字节数组使用AES加密算法构造一个密钥
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");

        return key;
    }
    
    /**
     * 创建jwt
     * @param id
     * @param issuer
     * @param subject
     * @param ttlMillis
     * @return
     * @throws Exception
     */
    public static String createJWT(String id) throws Exception {
    	return createJWT(id, JWT_ISSUER, JWT_SUBJECT, JWT_TTL);
    }
    
    
    /**
     * 创建jwt
     * @param id
     * @param issuer
     * @param subject
     * @param ttlMillis
     * @return
     * @throws Exception
     */
    public static String createJWT(RedisManager redisManager,String id) throws Exception {
    	String jwt = createJWT(id, JWT_ISSUER, JWT_SUBJECT, JWT_TTL);
    	//每次格局用户id存储最近的一次jwt
    	String rs = redisManager.set(USER_JWT_KEY+id, jwt);
    	log.info(" redisManager.set {} 结果：{}",jwt,rs);
    	return jwt ;
    }

    /**
     * 创建jwt
     * @param id
     * @param issuer
     * @param subject
     * @param ttlMillis
     * @return
     * @throws Exception
     */
    public static String createJWT(String id, String issuer, String subject, long ttlMillis) throws Exception {

        // 指定签名的时候使用的签名算法，也就是header那部分，jjwt已经将这部分内容封装好了。
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        // 生成JWT的时间
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);

        // 创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
        Map<String, Object> claims = new HashMap<>();
        //claims.put("uid", "123456");
        //claims.put("user_name", "admin");
        //claims.put("nick_name", "X-rapido");

        // 生成签名的时候使用的秘钥secret，切记这个秘钥不能外露哦。它就是你服务端的私钥，在任何场景都不应该流露出去。
        // 一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。
        SecretKey key = generalKey();

        // 下面就是在为payload添加各种标准声明和私有声明了
        JwtBuilder builder = Jwts.builder() // 这里其实就是new一个JwtBuilder，设置jwt的body
                .setClaims(claims)          // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                .setId(id)                  // 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
                .setIssuedAt(now)           // iat: jwt的签发时间
                .setIssuer(issuer)          // issuer：jwt签发人
                .setSubject(subject)        // sub(Subject)：代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可以存放什么userid，roldid之类的，作为什么用户的唯一标志。
                .signWith(signatureAlgorithm, key); // 设置签名使用的签名算法和签名使用的秘钥

        // 设置过期时间
        if (ttlMillis >= 0) {
            long expMillis = nowMillis + ttlMillis;
            Date exp = new Date(expMillis);
            builder.setExpiration(exp);
        }
        String jwt = builder.compact();
        return  jwt ;
    }

    /**
     * 解密jwt
     *
     * @param jwt
     * @return
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey key = generalKey();  //签名秘钥，和生成的签名的秘钥一模一样
        Claims claims = Jwts.parser()  //得到DefaultJwtParser
                .setSigningKey(key)                 //设置签名的秘钥
                .parseClaimsJws(jwt).getBody();     //设置需要解析的jwt
        return claims;
    }
    
    /**
     * 验证档次请求是否可用， 这里header authorization,是独存，独校验。跟其他无关
     * @param redisManager 可替换本地缓存
     * @param httpServletRequest
     * @param httpServletResponse
     * @return
     */
    public static boolean  jwtValidate(RedisManager redisManager,HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse) {
        String jwtKey = ConstantsUtil.Common.AUTHORIZATION;
   	    //jwt Id 
   	    String jwt = httpServletRequest.getHeader(jwtKey);
   	    //老的
   	    String oldJwtKey = OLD_JWT_KEY+jwt;
   	    
   	    if(StringUtils.isBlank(jwt)) {
   	    	return false;
   	    }
		try {
			Claims parseJWT = JwtUtil.parseJWT(jwt);
			if(parseJWT != null) {
				return true;
			}
		} catch (io.jsonwebtoken.ExpiredJwtException e) {
				  /**
				   * 分几种情况
				   * 1.正常超时(服务端token时间到):重新生成一个新的token给前端，下次带新的token过来
				   * 2.非正常超时(用户隔了很长时间没有时间):重新生成一个新的token给前端，下次带新的token过来
				   * 3.并发情况考虑(当超时，第一个请求，第二个请求会同时过来)
				   * 4.同一用户多方登陆：目前只允许同一个用户一方登陆。多方登陆支持。这里只校验jwt失效问题。
				   * 
				   * 
				   */
					try {
						Claims c = e.getClaims();
						String id = c.getId();
						String subject = c.getSubject();
						String issuer  = c.getIssuer();
						
						String lastJwtKey  =  USER_JWT_KEY+id;
						
						 //先判断是否是最近的一次jwt,如果不是最新的jwt，返回false
						String redisLastJwtVal = redisManager.get(lastJwtKey, String.class);
				   	    if(!jwt.equals(redisLastJwtVal)) {
				   	    	log.error("当前访问的jwt不是最新的：{}",redisLastJwtVal);
					    	return false;
					    }
						
					    log.info("jwt 超时 {}",jwt);
					   //当存在鬓发请求时  如果老的jwtId存在.解决同一页面并发请求
						if(redisManager.setnx(oldJwtKey, "", OLD_JWT_TTL) != 1) {
							return true;
						}
						
						//从新生成jwt id
						String sessionId = JwtUtil.createJWT(id.toString(), issuer,subject, JwtUtil.JWT_TTL);
						//TODO设置新的 sessionId 到httpServletResponse， Header 中 返回给前端用
						//TODO设置新的 sessionId 到 httpServletRequest  给后面的程序用
						httpServletResponse.setHeader(jwtKey, sessionId);
						
						//记录最后一次jwt
						redisManager.set(lastJwtKey,sessionId);
						return true;
					} 
					catch (Exception e1) {
						log.error(e1.getMessage(),e1);
					}
		}catch (Exception e) {
			log.error(e.getMessage(),e);
			throw new DominosRunTimeException(ResultMsg.USER_LOGIN_INVALID);
		}
		return false;
    }
    
    
    /*
    public static void main(String[] args) {

        try {
            String jwt = createJWT(JWT_ID, "userName", "userName", JWT_TTL);
            System.out.println("JWT：" + jwt);
            System.out.println("\n解密\n");

            Claims c = parseJWT(jwt);
            System.out.println(c.getId());
            System.out.println(c.getIssuedAt());
            System.out.println(c.getSubject());
            System.out.println(c.getIssuer());
            System.out.println(c.get("uid", String.class));

        }catch (ExpiredJwtException ee) {
        	System.out.println("超时了>>>>>>>>>>>>>>");
        	Claims c = ee.getClaims();
        	System.out.println(c.getId());
            System.out.println(c.getIssuedAt());
            System.out.println(c.getSubject());
            System.out.println(c.getIssuer());
            System.out.println(c.get("uid", String.class));
		}
        catch (Exception e) {
            e.printStackTrace();
        }
    }*/
}

 

if(!JwtUtil.jwtValidate(httpServletRequest, httpServletResponse)) {
        		Log.error("url : {} jwt 解析失败 >>>>>>>>>>>>>>>",url);
        		return false;
        	}
public class JwtInterceptor implements HandlerInterceptor {


    @Autowired
    private RedisManager redisManager;

    /**
     * 处理请求之前拦截
     *
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) {
        return JwtUtil.jwtValidate(redisManager,httpServletRequest, httpServletResponse);
    }
    
    
    
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) {

    }

    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {

    }
}
public class JwtFilter implements javax.servlet.Filter {
 
	@Autowired
	private RedisManager redisManager;
	 
    @Override
    public void destroy() {
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) request;
        MutableHttpServletRequestWrapper mutableRequest = new MutableHttpServletRequestWrapper(httpServletRequest);
        JwtUtil.jwtValidate(redisManager,httpServletRequest, httpServletResponse);
        chain.doFilter(mutableRequest, response);
    }
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        
    }
    
}

登陆成功后

  try {
        	 String authorization = JwtUtil.createJWT(redisManager,user.getId().toString());
        	 response.setHeader(ConstantsUtil.Common.AUTHORIZATION, authorization);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}

 

转载于:https://my.oschina.net/xiaominmin/blog/3000381

【SpringBoot】44、SpringBoot中整合JWT实现Token验证（整合篇）
Asurplus
02-28 21万+
什么是JWT？ Json web token (JWT)，是为了在网络应用环境间传递声明而执行的一种基于 JSON 的开放标准（(RFC 7519)，该 token 被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT 的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 为什么需要JWT? 当我们开发前后端分离项目时，要求我们对用户会话状态要进行一
JwtUtils.java
10-16
文件为jwtUtils的java版本代码，其中包含了生成token，解析token，生成秘钥的函数
JWT工具类
Java技术工坊
03-02 509
public class JwtUtils { public static final long EXPIRE = 1000 * 60 * 60 * 24; //设置token过期时间 public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO"; //密钥 //生成token字符串的方法 public static String getJwtToken(String id, String
JWT（Json Web Token）
大白能的博客
04-11 1151
什么是JWT（Json网络令牌） JWT（JSON 网络令牌）是一个开源的标准（RFC 7519）。这个标准定义了一个简洁并且自包含的方法，以便在系统各个部分之间安全地传送JSON对象格式的信息。因为通过JWT传递的信息是被数字签名过的，所以是可以被证实和信任的。我们可以使用单一密钥来加密 JWT 的签名，比如 HMAC 算法；也可以使用 RSA 的公私密钥对来加密 JWT 的签名。 让我们更...
JWTUtils
m0_59164927的博客
06-09 1783
jwt工具类
JwtUtils
生命的演绎的博客
11-27 779
package com.math.util; import com.nimbusds.jose.*; import com.nimbusds.jose.crypto.MACSigner; import com.nimbusds.jose.crypto.MACVerifier; import com.nimbusds.jose.crypto.RSASSASigner; import com.nimbusds.jose.crypto.RSASSAVerifier; import com.nimbusds.j.
python jwt utils 国密算法gmssl库和信息摘要
u013607239的博客
03-26 1335
gmssl 国密算法支持库的基本使用，基于此库的jwt utils工具方法，以及基于hmac的工具方法
cpp-jwt-utils:C ++ JSON Web令牌实用程序
03-30
该库提供了实用程序，用于生成，解析和验证用于通过REST API实施身份验证机制的JWT（JSON Web令牌）。 设置 使用柯南下载 该库旨在通过使用软件包管理器进行安装。 因此，您只需要在柯南食谱中添加以下要求： def ...
Cookie、Session、JWT令牌技术、JwtUtils工具类
最新发布
2301_77358195的博客
03-26 1609
这篇文章将带你彻底理解会话跟踪方案的三种技术，分别是Cookie、Session、令牌技术， 揭示它们的原理以及对各个技术进行通俗化，让你更好的了解，它们的交互过程 ！ ！ ！
fastify-jwt:用于Fastify的JWT实用程序
04-27
Fastify的JWT utils在内部使用 。 fastify-jwt支持Fastify @ 3。 fastify-jwt 支持Fastify @ 2。 安装 npm i fastify-jwt --save 用法 注册为插件。 这将使用标准的方法decode ， sign和verify来装饰您的fastify...
JwtUtil.java
04-14
主要用于单点登录，基于Jwt生成Token的工具类，包括生成和解析Token，JWT token的格式主要为header.payload.signature
JWTUtils工具
weixin_64443786的博客
07-13 5554
JWT
31.整合JWT
gunsmoke的专栏
04-19 397
pom.xml <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> </dependency> 工具类 package com.gunsmoke.comm...
jwtUtils的使用
芒果的日常记录
03-23 3716
引入pom <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.7.0</version> </dependency> <dependency&gt...
JwtUtil是一个用于生成和解析JWT（JSON Web Token）的工具类
weixin_51493673的博客
09-22 844
【代码】JwtUtil是一个用于生成和解析JWT（JSON Web Token）的工具类。
JwtUtil类
Mr_Huifeng的博客
02-27 585
JwtUtil类
JWTUtils工具类：生成与验证JWT令牌
"JWTUtils工具类是一个用于处理JSON Web Token (JWT)的实用类，它包含生成、解析和检查JWT的函数。这个类主要用于在Java应用程序中实现基于JWT的身份验证和授权。" JWT (JSON Web Token) 是一种轻量级的身份验证...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值