/**
	 * 加密方式
	 */
	private static final String ALGORITHM_FAMILY_NAME = "RSA";

	/**
	 * 私钥，加密用
	 */
	private static final String PRIVATE_KEY = "生成的私钥";

	/**
	 * 公钥，解密用
	 */
	private static final String PUBLIC_KEY = "生成的公钥";


	@Override
	public JwtBody signatureToken(String token) {

		Jws<Claims> claimsJws = authToken(token);

		return new JwtBody(claimsJws.getBody());
	}

	@Override
	public String generateToken(Object object, Date expireAt, String subject) {
		//建立jwt
		JwtBuilder jwtBuilder = Jwts.builder();

		//设置jwt的body
		subject = subject != null ? subject: UUID.randomUUID().toString();
		Map<String,Object> objectMap = new HashMap<>();
		if(Objects.nonNull(object)){
			objectMap.put("data",object);
		}
		jwtBuilder.setClaims(objectMap).setSubject(subject);

		//设置过期时间-时间设置要放在最后，否则设置了body之后会把时间盖掉，无法获取到时间
		if(Objects.isNull(expireAt)){
			log.info("没有设置过期时间,自动设置过期时间三十分钟");
			long currentTime = System.currentTimeMillis();
			currentTime += 30*60*1000;
			Date newDate = new Date(currentTime);
			jwtBuilder.setExpiration(newDate);
		}else{
			//设置过期时间
			jwtBuilder.setExpiration(expireAt);
		}
		//生成加密jwt
		return jwtBuilder.signWith(SignatureAlgorithm.RS256,privateKeyFromBase64()).compact();
	}



	/**
	 * 解析token
	 * @param token token
	 * @return claims
	 */
	private Jws<Claims> authToken(String token){
		if(null == token){
			log.info("本次请求token不存在");
			throw new TokenException(TokenReturnCode.RESOLVE_FAILED);
		}
		Jws<Claims> claimsJws;
		//解析token
		try {
			//如果传来的token不对，会对异常进行捕获
			claimsJws = Jwts.parser().setSigningKey(publicKeyFromBase64()).parseClaimsJws(token);
		}catch (JwtException e){
			log.error("token:\"{}\" 不正确",token);
			log.error(e.getMessage());
			throw new TokenException(TokenReturnCode.RESOLVE_FAILED);
		}

		return claimsJws;
	}

	/**
	 * 公钥64位序列化
	 * @return PublicKey
	 */
	private static PublicKey publicKeyFromBase64() {
		try {
			byte[] keyBytes = Base64Utils.decodeFromString(PUBLIC_KEY);
			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
			KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_FAMILY_NAME);
			return keyFactory.generatePublic(keySpec);
		} catch (NoSuchAlgorithmException | InvalidKeySpecException ex) {
			throw new IllegalArgumentException(ex);
		}
	}

	/**
	 * 私钥64位序列化
	 * @return PrivateKey
	 */
	private static PrivateKey privateKeyFromBase64() {
		try {
			byte[] keyBytes = Base64Utils.decodeFromString(PRIVATE_KEY);
			PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
			KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_FAMILY_NAME);
			return keyFactory.generatePrivate(keySpec);
		} catch (NoSuchAlgorithmException | InvalidKeySpecException ex) {
			throw new IllegalArgumentException(ex);
		}
	}

因为在解密token后会产生claims，也就是token的body，里面包含了用户需要在token里传递的信息，所以解析后需要有一个方式传递给接口。这里采用了全局参数注入，使用了拦截器，将token解析方法产生的jwtBody注入全局，使接口可以自行获取：

全局参数handler：

/**
 * 创建时间：2021/1/25 17:24
 * 实现拦截并注入参数
 * @author wyb
 */
public class JwtArgumentResolver implements HandlerMethodArgumentResolver {

	private TokenUtils tokenUtils;

	private String tokenHeader;

	@Override
	public boolean supportsParameter(MethodParameter methodParameter) {
		return methodParameter.getParameterType().equals(JwtBody.class);
	}

	@Override
	public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {
		//将解析后的jwtBody作为全局参数，所有接口均可调用
		return tokenUtils.signatureToken(nativeWebRequest.getHeader(tokenHeader));
	}

	/**
	 * 构造方法，因为使用注解注入的形式不生效
	 * @param tokenUtils token工具bean
	 * @param tokenHeader 请求头名字
	 */
	JwtArgumentResolver(TokenUtils tokenUtils, String tokenHeader){
		this.tokenHeader = tokenHeader;
		this.tokenUtils = tokenUtils;
	}
}

/**
 * 创建时间：2021/1/26 10:55
 * 创建拦截器
 * @author wyb
 */
@Configuration
public class WebConfig extends WebMvcConfigurationSupport {

	@Autowired
	private TokenUtils tokenUtils;

	@Value("${token.header:token}")
	private String tokenHeader;

	@Override
	protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
		argumentResolvers.add(new JwtArgumentResolver(tokenUtils,tokenHeader));
	}
}

@Data
public class JwtBody {

	private String subject;

	private Object object;

	public JwtBody(Claims claims){
		if(Objects.nonNull(claims)){
			this.subject = claims.getSubject();
			Map map = new HashMap<>(claims);
			map.remove("sub");
			this.object = map.get("data");
		}
	}
}

token:
	header: token
	ignore: /test,/example,/aaa

@Override
	protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
		argumentResolvers.add(new JwtArgumentResolver(tokenUtils,tokenHeader));
	}