package com.jilongda.common.security;
|
|
import com.jilongda.common.basic.Constant;
|
import com.jilongda.common.exception.ServiceException;
|
import com.jilongda.common.exception.TokenException;
|
import com.jilongda.common.swagger.GlobalResultEnum;
|
import io.jsonwebtoken.*;
|
import io.jsonwebtoken.impl.DefaultClaims;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
|
import org.springframework.security.core.Authentication;
|
import org.springframework.security.core.GrantedAuthority;
|
import org.springframework.security.core.context.SecurityContextHolder;
|
import org.springframework.security.core.userdetails.UserDetails;
|
import org.springframework.util.Base64Utils;
|
import org.springframework.util.StringUtils;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.io.Serializable;
|
import java.util.*;
|
|
/**
|
* JWT工具类
|
*
|
* @author Louis
|
* @date Jun 29, 2019
|
*/
|
@Slf4j
|
public class JwtTokenUtils implements Serializable {
|
|
|
/**
|
* 用户名称
|
*/
|
private static final String USERNAME = Claims.SUBJECT;
|
|
/**
|
* 环境信息
|
*/
|
private static final String ENV = "env";
|
|
/**
|
* 用户主体信息
|
*/
|
private static final String USERID = "userId";
|
/**
|
* 创建时间
|
*/
|
private static final String CREATED = "created";
|
/**
|
* 权限列表
|
*/
|
private static final String AUTHORITIES = "authorities";
|
|
/**
|
* JWT Token 签发机构
|
*/
|
private static final String ISSUING_AGENCY = "Lingser Technology ISSUER";
|
/**
|
* JWT Token 默认的密钥
|
*/
|
private static final String SIGNING_KEY = "Lingser Technology SIGNING_KEY";
|
private static final long serialVersionUID = -576504484244573039L;
|
|
/**
|
* 从数据声明生成令牌
|
*
|
* @param payload 载荷
|
* @param tokenExpireTime
|
* @return
|
*/
|
private static String generateToken(Map<String, Object> payload, long tokenExpireTime) {
|
// token存在时间
|
Date expirationDate = new Date(System.currentTimeMillis() + tokenExpireTime * 1000L);
|
Claims claims = new DefaultClaims();
|
// 签发机构
|
claims.setIssuer(ISSUING_AGENCY);
|
// 载荷
|
claims.putAll(payload);
|
//
|
String token = Jwts.builder()
|
.setClaims(claims)
|
.setExpiration(expirationDate)
|
.signWith(SignatureAlgorithm.HS512, SIGNING_KEY)
|
.compact();
|
return token;
|
}
|
|
/**
|
* 生成token
|
*
|
* @param userName
|
* @param tokenExpireTime
|
* @return
|
*/
|
public static String generateToken(String userName, long tokenExpireTime) {
|
Map<String, Object> payload = new HashMap<>(2);
|
payload.put(USERNAME, userName);
|
payload.put(CREATED, new Date());
|
return generateToken(payload, tokenExpireTime);
|
}
|
|
/**
|
* 主要用于token不需要托管，但有多个场景的情况
|
* 生成token
|
*
|
* @param userName
|
* @param evn
|
* @param tokenExpireTime
|
* @return
|
*/
|
public static String generateToken(String userName, String evn, long tokenExpireTime) {
|
Map<String, Object> payload = new HashMap<>(3);
|
payload.put(USERNAME, userName);
|
payload.put(ENV, evn);
|
payload.put(CREATED, new Date());
|
return generateToken(payload, tokenExpireTime);
|
}
|
|
/**
|
* 从令牌中获取用户名
|
*
|
* @param token 令牌
|
* @return 用户名
|
*/
|
public static String getUsername(String token) {
|
Claims claims = getClaimsFromToken(token);
|
return claims.getSubject();
|
}
|
|
|
/**
|
* 根据请求令牌获取登录认证信息
|
*
|
* @param token
|
* @return
|
*/
|
public static Authentication getAuthenticatione(String token) {
|
Authentication authentication = getAuthentication();
|
if (StringUtils.hasLength(token)) {
|
// 上下文认证为空
|
if (Objects.isNull(authentication)) {
|
// 上下文中Authentication为空
|
Claims claims = getClaimsFromToken(token);
|
if (Objects.isNull(claims)) {
|
throw new ServiceException("从令牌中获取数据声明失败");
|
}
|
String username = claims.getSubject();
|
Object userDetails = claims.get(USERID);
|
if (!StringUtils.hasLength(username)) {
|
throw new ServiceException("获取用户名失败");
|
}
|
// 如果需要手动续期，此项判断需要注释
|
if (isTokenExpired(token)) {
|
throw new TokenException(GlobalResultEnum.TOKEN_EXPIRE.getCode(),GlobalResultEnum.TOKEN_EXPIRE.getMessage());
|
}
|
List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
|
authentication = new UsernamePasswordAuthenticationToken(username, userDetails, authorities);
|
} else {
|
if (validateToken(token, getUsername())) {
|
// 如果上下文中Authentication非空，且请求令牌合法，直接返回当前登录认证信息
|
authentication = getAuthentication();
|
}
|
}
|
}
|
return authentication;
|
}
|
|
/**
|
* 从令牌中获取数据声明
|
* 解析JWT Token
|
*
|
* @param token 令牌
|
* @return 数据声明
|
*/
|
public static Claims getClaimsFromToken(String token) {
|
try {
|
// 传入令牌,判断accessToken是否存在
|
Claims claims = Jwts.parser().setSigningKey(SIGNING_KEY).parseClaimsJws(token).getBody();
|
return claims;
|
} catch (ExpiredJwtException e) {
|
log.error("Token 已过期");
|
throw new TokenException(GlobalResultEnum.TOKEN_EXPIRE.getCode(),GlobalResultEnum.TOKEN_EXPIRE.getMessage());
|
} catch (UnsupportedJwtException e) {
|
log.error("不支持的 Token");
|
throw new TokenException(GlobalResultEnum.TOKEN_PARSE_ERROR);
|
} catch (MalformedJwtException e) {
|
log.error("Token 无效");
|
throw new TokenException(GlobalResultEnum.TOKEN_PARSE_ERROR);
|
} catch (SignatureException e) {
|
log.error("无效的 Token 签名");
|
throw new TokenException(GlobalResultEnum.TOKEN_PARSE_ERROR);
|
} catch (IllegalArgumentException e) {
|
log.error("Token 参数不存在");
|
throw new TokenException(GlobalResultEnum.TOKEN_PARSE_ERROR);
|
} catch (TokenException e) {
|
log.error("Token 已过期");
|
throw new TokenException(GlobalResultEnum.TOKEN_EXPIRE.getCode(),GlobalResultEnum.TOKEN_EXPIRE.getMessage());
|
} catch (Exception e) {
|
log.error("token 解析失败，请尝试重新登录");
|
throw new TokenException(GlobalResultEnum.TOKEN_PARSE_ERROR);
|
}
|
|
}
|
|
|
/**
|
* 验证令牌
|
*
|
* @param token
|
* @param username
|
* @return
|
*/
|
public static Boolean validateToken(String token, String username) {
|
String userName = getUsername(token);
|
if (!StringUtils.hasLength(userName)) {
|
throw new IllegalArgumentException("请求令牌无效");
|
}
|
return (userName.equals(username) && !isTokenExpired(token));
|
}
|
|
|
/**
|
* 刷新令牌，重新生成
|
*
|
* @param token
|
* @return
|
*/
|
public static String refreshToken(String token, long tokenExpireTime) {
|
String refreshedToken;
|
try {
|
Claims claims = getClaimsFromToken(token);
|
String userName = claims.getSubject();
|
refreshedToken = generateToken(userName, tokenExpireTime);
|
} catch (Exception e) {
|
throw new SecurityException("刷新令牌出错！");
|
}
|
return refreshedToken;
|
}
|
|
/**
|
* 刷新令牌，重新生成
|
*
|
* @param token
|
* @param env
|
* @param tokenExpireTime
|
* @return
|
*/
|
public static String refreshToken(String token, String env, long tokenExpireTime) {
|
String refreshedToken;
|
try {
|
Claims claims = getClaimsFromToken(token);
|
String userName = claims.getSubject();
|
refreshedToken = generateToken(userName, env, tokenExpireTime);
|
} catch (Exception e) {
|
throw new SecurityException("刷新令牌出错！");
|
}
|
return refreshedToken;
|
}
|
|
/**
|
* 判断令牌是否过期
|
*
|
* @param token 令牌
|
* @return 是否过期
|
*/
|
public static Boolean isTokenExpired(String token) {
|
try {
|
Claims claims = getClaimsFromToken(token);
|
Date expiration = claims.getExpiration();
|
return expiration.before(new Date());
|
} catch (Exception e) {
|
return false;
|
}
|
}
|
|
/**
|
* 获取请求token
|
*
|
* @param request
|
* @return
|
*/
|
public static String getToken(HttpServletRequest request) {
|
String token = request.getHeader(Constant.DEF_TOKEN_HEADER);
|
String asToken = request.getHeader(Constant.ALIAS_TOKEN_HEADER);
|
// 如果这两个头部信息均不存在
|
if (!StringUtils.hasLength(token) && !StringUtils.hasLength(asToken)) {
|
throw new ServiceException("资源未认证，访问受限");
|
}
|
// token转换
|
if (!StringUtils.hasLength(token)) {
|
token = asToken;
|
}
|
String tokenHead = "Bearer ";
|
if (token.contains(tokenHead)) {
|
token = token.substring(tokenHead.length());
|
}
|
if (!StringUtils.hasLength(token)) {
|
throw new ServiceException("访问令牌不能为空");
|
}
|
// base64 解码
|
try {
|
token = new String(Base64Utils.decode(token.getBytes()));
|
} catch (IllegalArgumentException e) {
|
throw new IllegalArgumentException("无效的令牌");
|
}
|
return token;
|
}
|
|
|
|
/**
|
* 获取当前用户名
|
*
|
* @return
|
*/
|
public static String getUsername() {
|
String username = null;
|
Authentication authentication = getAuthentication();
|
if (Objects.nonNull(authentication)) {
|
Object principal = authentication.getPrincipal();
|
if (Objects.nonNull(principal)) {
|
username = (String) principal;
|
}
|
}
|
return username;
|
}
|
|
|
|
|
|
|
|
/**
|
* 获取当前用户信息id
|
*
|
* @return
|
*/
|
public static Object getUserInfo() {
|
Object userInfo = null;
|
Authentication authentication = getAuthentication();
|
if (Objects.nonNull(authentication)) {
|
userInfo = authentication.getDetails();
|
}
|
return userInfo;
|
}
|
|
/**
|
* 获取用户名
|
*
|
* @return
|
*/
|
public static String getUsername(Authentication authentication) {
|
String username = null;
|
if (Objects.nonNull(authentication)) {
|
Object principal = authentication.getPrincipal();
|
if (Objects.nonNull(principal) && principal instanceof UserDetails) {
|
username = (String) principal;
|
}
|
}
|
return username;
|
}
|
|
/**
|
* 获取当前登录信息
|
*
|
* @return
|
*/
|
public static Authentication getAuthentication() {
|
if (Objects.isNull(SecurityContextHolder.getContext())) {
|
return null;
|
}
|
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
|
return authentication;
|
}
|
|
}
|
