JWT介绍及其基本使用

官网：https://jwt.io/

什么是JWT

全称：JSON Web Token（JSON Web令牌）

一个开放标准(RFC 7519) ，它定义了一种紧凑和自包含的方式， 用于作为 JSON 对象在各方之间安全地传输信息。此信息可以进行验证和信任，因为它是经过数字签名的。JWT 可以使用机密(使用 HMAC 算法)或使用 RSA 或 ECDSA 的公钥/私钥对进行签名。

虽然可以对 JWT 进行加密，以便在各方之间提供保密性，但是我们将关注已签名的Token。签名Token可以验证其中包含的声明的完整性，而加密Token可以向其他方隐藏这些声明。当使用公钥/私钥对对令牌进行签名时，该签名还证明只有持有私钥的一方才是对其进行签名的一方( 签名技术是保证传输的信息不被篡改,并不能保证信息传输的安全 )。

JWT有什么作用

JWT最常见的场景就是授权认证，一旦用户登录之后，后续的每个请求都将包含JWT。系统在每次处理用户请求之前都要先通过JWT安全校验，通过之后再去进行处理。

解决了使用session的跨域问题

JWT的结构

JWT由三部分组成，他们分别为：

• Header：包含了算法名称，token名称
• Payload：包含注册声明、公共声明、私有声明
• Signature：由加密后的Header和Payload再次进行二次加密构成

在请求当中的出现形式为Header.Payload.Signature，如下：

JWT的实际应用

JWT依赖引入

<!--JWT(Json Web Token)登录支持-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

JWT工具类

package com.liangtl.utils;

import com.liangtl.dao.User;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

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

@Component
@ConfigurationProperties("jwt.data")
public class JwtTokenUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(JwtTokenUtil.class);
    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";
    private String secret = "jwt-token-secret";
    private Long expiration = 604800L;
    private String tokenHead = "Bearer";

    /**
     * 根据负责生成JWT的token
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }

    /**
     * 从token中获取JWT中的负载
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            LOGGER.error("JWT格式验证失败:{}", token);
        }
        return claims;
    }

    /**
     * 生成token的过期时间
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /**
     * 从token中获取登录用户名
     */
    public String getUserNameFromToken(String token) {
        String username;
        try {
            Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 验证token是否还有效
     *
     * @param token       客户端传入的token
     * @param User 从数据库中查询出来的用户信息
     */
    public boolean validateToken(String token, User User) {
        String username = getUserNameFromToken(token);
        return username.equals(User.getUserName()) && !isTokenExpired(token);
    }

    /**
     * 判断token是否已经失效
     */
    private boolean isTokenExpired(String token) {
        Date expiredDate = getExpiredDateFromToken(token);
        return expiredDate.before(new Date());
    }

    /**
     * 从token中获取过期时间
     */
    private Date getExpiredDateFromToken(String token) {
        Claims claims = getClaimsFromToken(token);
        return claims.getExpiration();
    }

    /**
     * 根据用户信息生成token
     */
    public String generateToken(User User) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, User.getUserName());
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    /**
     * 当原来的token没过期时是可以刷新的
     *
     * @param oldToken 带tokenHead的token
     */
    public String refreshHeadToken(String oldToken) {
        if (StringUtils.isEmpty(oldToken)) {
            return null;
        }
        String token = oldToken.substring(tokenHead.length());
        if (StringUtils.isEmpty(token)) {
            return null;
        }
        //token校验不通过
        Claims claims = getClaimsFromToken(token);
        if (claims == null) {
            return null;
        }
        //如果token已经过期，不支持刷新
        if (isTokenExpired(token)) {
            return null;
        }
        //如果token在30分钟之内刚刷新过，返回原token
        if (tokenRefreshJustBefore(token, 30 * 60 * 1000)) {
            return token;
        } else {
            claims.put(CLAIM_KEY_CREATED, new Date());
            return generateToken(claims);
        }
    }

    /**
     * 判断token在指定时间内是否刚刚刷新过
     *
     * @param token 原token
     * @param time  指定时间（秒）
     */
    private boolean tokenRefreshJustBefore(String token, int time) {
        Claims claims = getClaimsFromToken(token);
        Date created = claims.get(CLAIM_KEY_CREATED, Date.class);
        Date refreshDate = new Date();
        //刷新时间在创建时间的指定时间内
        if (refreshDate.after(new Date(System.currentTimeMillis() - time)) && refreshDate.before(new Date())) {
            return true;
        }
        return false;
    }
}

接口定义

Controller

package com.liangtl.api;

import com.liangtl.dao.User;
import com.liangtl.framework.common.ResponseData;
import com.liangtl.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/system")
public class LoginController {

    @Autowired
    private UserService userService;

    @PostMapping("/login")
    public ResponseData login(@RequestBody User user) {
        return userService.login(user);
    }
}

Service

package com.liangtl.service.impl;

import com.liangtl.dao.User;
import com.liangtl.framework.common.ErrorCode;
import com.liangtl.framework.common.ResponseData;
import com.liangtl.framework.exception.TokenException;
import com.liangtl.service.UserService;
import com.liangtl.utils.JwtTokenUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Override
    public ResponseData login(User user) {
        if (user == null || StringUtils.isEmpty(user.getUserName()) || StringUtils.isEmpty(user.getPassword())) {
            throw new TokenException(ErrorCode.USER_ERROR_CODE, ErrorCode.USER_ERROR_MSG);
        }
        if ("admin".equals(user.getUserName()) && "123456".equals(user.getPassword())) {
            String token = jwtTokenUtil.generateToken(user);
            return ResponseData.success(token);
        }
        return ResponseData.failure();
    }
}

api测试结果

（tips：以上代码不完整，报错并非代码逻辑有问题而是有缺失类，如果完全copy的话需要适当调整使用）

后续相关思路

• 接口请求验证：在拦截器中先校验token来验证用户是否有权限访问接口
• 自动续期：考虑将token放在redis中并且设置过期时间，这样每次发起请求的时候可以设置一个拦截器刷新redis的过期时间以实现自动续期的效果

。。。