Merge branch 'master' of http://210.22.126.130:1111/r/dry/herb

bsw215583320

2024-04-16 c2fccb01b972176dc3da5a497b5e904025e9e98d

 jeecg-boot-base-core/src/main/java/org/jeecg/common/system/util/JwtUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,250 @@
package org.jeecg.common.system.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Joiner;

import java.io.IOException;
import java.io.OutputStream;
import java.util.Date;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.DataBaseConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.TenantConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.system.vo.SysUserCacheInfo;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;

/**
 * @Author Scott
 * @Date 2018-07-12 14:23
 * @Desc JWT工具类
 **/
public class JwtUtil {

   /**Token有效期为1小时（Token在reids中缓存时间为两倍）*/
   public static final long EXPIRE_TIME = 1000 * 24 * 60 * 60 * 1000;
   static final String WELL_NUMBER = SymbolConstant.WELL_NUMBER + SymbolConstant.LEFT_CURLY_BRACKET;

    /**
     *
     * @param response
     * @param code
     * @param errorMsg
     */
    public static void responseError(ServletResponse response, Integer code, String errorMsg) {
      HttpServletResponse httpServletResponse = (HttpServletResponse) response;
      // issues/I4YH95浏览器显示乱码问题
      httpServletResponse.setHeader("Content-type", "text/html;charset=UTF-8");
        Result jsonResult = new Result(code, errorMsg);
      jsonResult.setSuccess(false);
        OutputStream os = null;
        try {
            os = httpServletResponse.getOutputStream();
         httpServletResponse.setCharacterEncoding("UTF-8");
         httpServletResponse.setStatus(code);
            os.write(new ObjectMapper().writeValueAsString(jsonResult).getBytes("UTF-8"));
            os.flush();
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

   /**
    * æ ¡éªŒtoken是否正确
    *
    * @param token  å¯†é’¥
    * @param secret ç”¨æˆ·çš„密码
    * @return æ˜¯å¦æ­£ç¡®
    */
   public static boolean verify(String token, String username, String secret) {
      try {
         // æ ¹æ®å¯†ç ç”ŸæˆJWT效验器
         Algorithm algorithm = Algorithm.HMAC256(secret);
         JWTVerifier verifier = JWT.require(algorithm).withClaim("username", username).build();
         // æ•ˆéªŒTOKEN
         DecodedJWT jwt = verifier.verify(token);
         return true;
      } catch (Exception exception) {
         return false;
      }
   }

   /**
    * èŽ·å¾—token中的信息无需secret解密也能获得
    *
    * @return token中包含的用户名
    */
   public static String getUsername(String token) {
      try {
         DecodedJWT jwt = JWT.decode(token);
         return jwt.getClaim("username").asString();
      } catch (JWTDecodeException e) {
         return null;
      }
   }

   /**
    * ç”Ÿæˆç­¾å,5min后过期
    *
    * @param username ç”¨æˆ·å
    * @param secret   ç”¨æˆ·çš„密码
    * @return åŠ å¯†çš„token
    */
   public static String sign(String username, String secret) {
      Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
      Algorithm algorithm = Algorithm.HMAC256(secret);
      // é™„带username信息
      return JWT.create().withClaim("username", username).withExpiresAt(date).sign(algorithm);

   }

   /**
    * æ ¹æ®request中的token获取用户账号
    * 
    * @param request
    * @return
    * @throws JeecgBootException
    */
   public static String getUserNameByToken(HttpServletRequest request) throws JeecgBootException {
      String accessToken = request.getHeader("X-Access-Token");
      String username = getUsername(accessToken);
      if (oConvertUtils.isEmpty(username)) {
         throw new JeecgBootException("未获取到用户");
      }
      return username;
   }
	
   /**
     *  ä»Žsession中获取变量
    * @param key
    * @return
    */
   public static String getSessionData(String key) {
      //${myVar}%
      //得到${} åŽé¢çš„值
      String moshi = "";
      String wellNumber = WELL_NUMBER;

      if(key.indexOf(SymbolConstant.RIGHT_CURLY_BRACKET)!=-1){
          moshi = key.substring(key.indexOf("}")+1);
      }
      String returnValue = null;
      if (key.contains(wellNumber)) {
         key = key.substring(2,key.indexOf("}"));
      }
      if (oConvertUtils.isNotEmpty(key)) {
         HttpSession session = SpringContextUtils.getHttpServletRequest().getSession();
         returnValue = (String) session.getAttribute(key);
      }
      //结果加上${} åŽé¢çš„值
      if(returnValue!=null){returnValue = returnValue + moshi;}
      return returnValue;
   }
	
   /**
     * ä»Žå½“前用户中获取变量
    * @param key
    * @param user
    * @return
    */
   public static String getUserSystemData(String key,SysUserCacheInfo user) {
      if(user==null) {
         user = JeecgDataAutorUtils.loadUserInfo();
      }
      //#{sys_user_code}%
		
      // èŽ·å–登录用户信息
      LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		
      String moshi = "";
        String wellNumber = WELL_NUMBER;
      if(key.indexOf(SymbolConstant.RIGHT_CURLY_BRACKET)!=-1){
          moshi = key.substring(key.indexOf("}")+1);
      }
      String returnValue = null;
      //针对特殊标示处理#{sysOrgCode}，判断替换
      if (key.contains(wellNumber)) {
         key = key.substring(2,key.indexOf("}"));
      } else {
         key = key;
      }
      //替换为系统登录用户帐号
      if (key.equals(DataBaseConstant.SYS_USER_CODE)|| key.toLowerCase().equals(DataBaseConstant.SYS_USER_CODE_TABLE)) {
         if(user==null) {
            returnValue = sysUser.getUsername();
         }else {
            returnValue = user.getSysUserCode();
         }
      }
      //替换为系统登录用户真实名字
      else if (key.equals(DataBaseConstant.SYS_USER_NAME)|| key.toLowerCase().equals(DataBaseConstant.SYS_USER_NAME_TABLE)) {
         if(user==null) {
            returnValue = sysUser.getRealname();
         }else {
            returnValue = user.getSysUserName();
         }
      }
		
      //替换为系统用户登录所使用的机构编码
      else if (key.equals(DataBaseConstant.SYS_ORG_CODE)|| key.toLowerCase().equals(DataBaseConstant.SYS_ORG_CODE_TABLE)) {
         if(user==null) {
            returnValue = sysUser.getOrgCode();
         }else {
            returnValue = user.getSysOrgCode();
         }
      }
      //替换为系统用户所拥有的所有机构编码
      else if (key.equals(DataBaseConstant.SYS_MULTI_ORG_CODE)|| key.toLowerCase().equals(DataBaseConstant.SYS_MULTI_ORG_CODE_TABLE)) {
         if(user==null){
            //TODO æš‚时使用用户登录部门，存在逻辑缺陷，不是用户所拥有的部门
            returnValue = sysUser.getOrgCode();
         }else{
            if(user.isOneDepart()) {
               returnValue = user.getSysMultiOrgCode().get(0);
            }else {
               returnValue = Joiner.on(",").join(user.getSysMultiOrgCode());
            }
         }
      }
      //替换为当前系统时间(年月日)
      else if (key.equals(DataBaseConstant.SYS_DATE)|| key.toLowerCase().equals(DataBaseConstant.SYS_DATE_TABLE)) {
         returnValue = DateUtils.formatDate();
      }
      //替换为当前系统时间（年月日时分秒）
      else if (key.equals(DataBaseConstant.SYS_TIME)|| key.toLowerCase().equals(DataBaseConstant.SYS_TIME_TABLE)) {
         returnValue = DateUtils.now();
      }
      //流程状态默认值（默认未发起）
      else if (key.equals(DataBaseConstant.BPM_STATUS)|| key.toLowerCase().equals(DataBaseConstant.BPM_STATUS_TABLE)) {
         returnValue = "1";
      }
      //update-begin-author:taoyan date:20210330 for:多租户ID作为系统变量
      else if (key.equals(TenantConstant.TENANT_ID) || key.toLowerCase().equals(TenantConstant.TENANT_ID_TABLE)){
         returnValue = SpringContextUtils.getHttpServletRequest().getHeader(CommonConstant.TENANT_ID);
      }
      //update-end-author:taoyan date:20210330 for:多租户ID作为系统变量
      if(returnValue!=null){returnValue = returnValue + moshi;}
      return returnValue;
   }
	
//   public static void main(String[] args) {
//       String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjUzMzY1MTMsInVzZXJuYW1lIjoiYWRtaW4ifQ.xjhud_tWCNYBOg_aRlMgOdlZoWFFKB_givNElHNw3X0";
//       System.out.println(JwtUtil.getUsername(token));
//   }
}