全栈之路-小程序API-JWT令牌详细剖析与使用

  JSON Web Token（JWT）是目前最流行的跨域身份验证解决方案。通过客户端保存数据，而服务器根本不保存会话数据，每个请求都被发送回服务器。 JWT是这种解决方案的代表。

一、跨域身份验证

1、Internet服务无法与用户身份验证分开。一般过程如下：

（1）用户向服务器发送用户名和密码。

（2）验证服务器后，相关数据（如用户角色，登录时间等）将保存在当前会话中。

（3）服务器向用户返回session_id，session信息都会写入到用户的Cookie。

（4）用户的每个后续请求都将通过在Cookie中取出session_id传给服务器。

（5）服务器收到session_id并对比之前保存的数据，确认用户的身份。

2、此模式存在的问题

这种模式最大的问题是，没有分布式架构，无法支持横向扩展。如果使用一个服务器，该模式完全没有问题。

但是，如果它是服务器群集或面向服务的跨域体系结构的话，则需要一个统一的session数据库库来保存会话数据实现共享，这样负载均衡下的每个服务器才可以正确的验证用户身份。

在分布式的情况下，jwt令牌的这种解决方案是比较优雅的，只是通过客户端保存数据，而服务器根本不保存会话数据，每个请求都被发送回服务器，jwt验证模式流程图如下：

 注意：图片来源网络

 二、jwt详解

（注意：jwt详解的内容来自 https://baijiahao.baidu.com/s?id=1608021814182894637&wfr=spider&for=pc 什么鬼，我怎么会引用百家号的内容！！！）

1、jwt的原则

JWT的原则是在服务器身份验证之后，将生成一个JSON对象并将其发送回用户，之后，当用户与服务器通信时，客户在请求中发回JSON对象。服务器仅依赖于这个JSON对象来标识用户。为了防止用户篡改数据，服务器将在生成对象时添加签名（有关详细信息，请参阅下文）。服务器不保存任何会话数据，即服务器变为无状态，使其更容易扩展

2、jwt的数据结构

一个jwt的由三部分构成，此对象为一个很长的字符串，字符之间通过"."分隔符分为三个子串。注意JWT对象为一个长字串，各字串之间也没有换行符，此处为了演示需要，我们特意分行并用不同颜色表示了。每一个子串表示了一个功能块，总共有以下三个部分：

jwt的三个部分如下。jwt头、有效载荷和签名，将它们写成一行，如下：

 

 注意：图片来源于网络

（1）jwt头

JWT头部分是一个描述JWT元数据的JSON对象，通常如下所示：

{"alg": "HS256","typ": "JWT"}

在上面的代码中，alg属性表示签名使用的算法，默认为HMAC SHA256（写为HS256）；typ属性表示令牌的类型，JWT令牌统一写为JWT。

最后，使用Base64 URL算法将上述JSON对象转换为字符串保存。

（2）有效载荷

有效载荷部分，是JWT的主体内容部分，也是一个JSON对象，包含需要传递的数据。 JWT指定七个默认字段供选择。

  iss：发行人

  exp：到期时间

  sub：主题

  aud：用户

  nbf：在此之前不可用

  iat：发布时间

  jti：JWT ID用于标识该JWT

除以上默认字段外，我们还可以自定义私有字段，如下例：

{"sub": "1234567890","name": "chongchong","admin": true}

请注意，默认情况下JWT是未加密的，任何人都可以解读其内容，因此不要构建隐私信息字段，存放保密信息，以防止信息泄露。

JSON对象也使用Base64 URL算法转换为字符串保存。

（3）签名哈希

签名哈希部分是对上面两部分数据签名，通过指定的算法生成哈希，以确保数据不会被篡改。

  首先，需要指定一个密码（secret）。该密码仅仅为保存在服务器中，并且不能向用户公开。然后，使用标头中指定的签名算法（默认情况下为HMAC SHA256）根据以下公式生成签名。

HMACSHA256( base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

在计算出签名哈希后，JWT头，有效载荷和签名哈希的三个部分组合成一个字符串，每个部分用"."分隔，就构成整个JWT对象。

（4）Base64URL算法

如前所述，JWT头和有效载荷序列化的算法都用到了Base64URL。该算法和常见Base64算法类似，稍有差别。

作为令牌的JWT可以放在URL中（例如api.example/?token=xxx）。 Base64中用的三个字符是"+"，"/"和"="，由于在URL中有特殊含义，因此Base64URL中对他们做了替换："="去掉，"+"用"-"替换，"/"用"_"替换，这就是Base64URL算法，很简单把。

三、jwt在小程序API中使用

1、整体流程梳理

（1）我们用code码（用户的account账户）通过调用微信开放的接口，获取到一个唯一的openid

（2）分为两种情况：（首先是通过openid查询user表）

  用户第一次使用（相当于注册）：我们将openid写入到user表中

  用户第二次或者多次使用之后（相当于登录）：得到userId

（3）userId写入到jwt令牌中

（4）将jwt令牌返回给小程序

2、令牌的生成

注意：生成jwt的时候，可供选择的库有多个，例如：jjwt，auth0 （详情见：https://jwt.io/）

（1）安装auth0的依赖（版本随意，bug自处理）

<dependency>
   <groupId>com.auth0</groupId>
   <artifactId>java-jwt</artifactId>
   <version>3.8.3</version>
</dependency>

（2）生成令牌（这里只看一下生成jwt令牌的方法）

@Component
public class JwtToken {

    private static String jwtKey;

    private static Integer expiredTimeIn;

    private static Integer defaultScope = 8;

    @Value("${missyou.security.jwt-key}")
    public void setJwtKey(String jwtKey) {
        JwtToken.jwtKey = jwtKey;
    }

    @Value("${missyou.security.token-expired-in}")
    public void setExpiredTimeIn(Integer expiredTimeIn) {
        JwtToken.expiredTimeIn = expiredTimeIn;
    }

    /**
     * 生成token 主方法(适用于有分级权限的)
     *
     * @param uid   用户id
     * @param scope 权限分级的数字
     * @return
     */
    public static String makenToken(Long uid, Integer scope) {
        return JwtToken.getToken(uid, scope);
    }

    /**
     * 生成token方法 (适用于没有分级权限的)
     *
     * @param uid 用户id
     * @return
     */
    public static String makeToken(Long uid) {
        return JwtToken.getToken(uid, JwtToken.defaultScope);
    }

    /**
     * 真正生成token的方法
     *
     * @param uid
     * @param scope
     * @return
     */
    private static String getToken(Long uid, Integer scope) {

        // 需要传入一个secret 随机字符串 这个写到配置文件中，从配置文件中读取，方便更改
        Algorithm algorithm = Algorithm.HMAC256(JwtToken.jwtKey);

        // 计算过期时间以及令牌签发的当前时间
        Map<String, Date> map = JwtToken.calculateExpiredIssues();

        // 过期时间是传入Date类型，需要我们自己来转换成一个过期时间
        // 例如 12:00 10s后过期，我们需要得到 12:00:10 这个过期时间
        String token = JWT.create()
                .withClaim("uid", uid)
                .withClaim("scope", scope)
                .withExpiresAt(map.get("expiredTime"))
                .withIssuedAt(map.get("now")) //令牌的签发时间
                .sign(algorithm);
        return token;
    }

    /**
     * 计算过期时间以及当前的时间
     *
     * @return
     */
    private static Map<String, Date> calculateExpiredIssues() {
        Map<String, Date> map = new HashMap<>();
        Calendar calendar = Calendar.getInstance();
        Date now = calendar.getTime();
        calendar.add(Calendar.SECOND, JwtToken.expiredTimeIn);
        map.put("now", now);
        map.put("expiredTime", calendar.getTime());
        return map;
    }
}

注意：方法基本上就是这样子，jwt令牌的create()方法可以加入多个参数的，你自己自定义的！还有那个setter方法注入的是可以值得思考学习一下的！

（3）后续

至于如何和微信小程序进行交互，接口如何设计，就不贴出来了，自己思考一下吧！

 3、令牌的校验与全局处理

思考：令牌如果在每一个请求中进行校验的话，在每个controller中的方法进行校验的话，会导致大量重复的代码，我们需要做的是做一个全局处理，进行令牌的验证

（1）令牌的校验

主要就是在token工具类中继续追加验证token的方法，其实是验证并且获取令牌中的数据，这里用的是Optional来进行处理的，具体方法如下：

    /**
     * 验证令牌token并获取令牌中的数据(Optional的使用)
     *
     * @param token 加密令牌token
     * @return
     */
    public Optional<Map<String, Claim>> verifyAndGetClaims(String token) {
        DecodedJWT decodedJWT;
        Algorithm algorithm = Algorithm.HMAC256(JwtToken.jwtKey);
        JWTVerifier jwtVerifier = JWT.require(algorithm).build();

        try{
            decodedJWT = jwtVerifier.verify(token);
        }catch (JWTVerificationException e){
            return Optional.empty();
        }
        return Optional.of(decodedJWT.getClaims());
    }

 （2）全局处理

  在springboot中，有三种方式实现拦截HTTP请求的方式，分别是filter，interceptor以及AOP

三者主要的区别：

  ## filter是基于servlet（servlet其实是一种为web开发制定的规范，是一种标准接口，Tomcat是一种servlet的容器）

  ## interceptor和AOP是基于spring框架的（interceptor相对来说实现起来简单一些）

 注意：

当一个http请求向服务器发送的时候，如果项目中同时配置了这三种拦截机制，那么他是有一个顺序的，就是

filter --> interceptor --> aop （请求经过的顺序）

--> controller --> （controller处理层）

aop --> interceptor --> filter （处理结果返回顺序）

 当然，在这里我们使用的是interceptor，开始搞起！

interceptor相关代码：

public class PermissionInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Optional<ScopeLevel> scopeLevel = this.getScopeLevel(handler);
        // 没有加上@ScopeLevel注解，说明没有访问权限的设定
        if (!scopeLevel.isPresent()) {
            return true;
        }
        String bearerToken = request.getHeader("Authorization");
        // token为空
        if (StringUtils.isEmpty(bearerToken)) {
            throw new UnAuthenticatedException(10004);
        }
        // token是默认的Bearer <token>格式，以Bearer开头，需要进行判断一下
        if (bearerToken.startsWith("Bearer")) {
            throw new UnAuthenticatedException(10004);
        }
        String[] tokens = bearerToken.split(" ");
        if(tokens.length != 2){
            throw new UnAuthenticatedException(10004);
        }
        String token = tokens[1];
        Optional<Map<String, Claim>> stringClaimMap = JwtToken.verifyAndGetClaims(token);
        Map<String, Claim> map = stringClaimMap.orElseThrow(
                () -> new UnAuthenticatedException(40001));
        return this.hasPermission(scopeLevel.get(), map);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        super.afterCompletion(request, response, handler, ex);
    }

    @Override
    public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        super.afterConcurrentHandlingStarted(request, response, handler);
    }

    /**
     * 获取请求方法上的scope权限
     *
     * @param handler
     * @return
     */
    private Optional<ScopeLevel> getScopeLevel(Object handler) {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            ScopeLevel scopeLevel = handlerMethod.getMethod().getAnnotation(ScopeLevel.class);
            if(scopeLevel == null){
                return Optional.empty();
            }
            return Optional.of(scopeLevel);
        }
        return Optional.empty();
    }

    /**
     * token中的权限与注解中的权限进行比较 判断是否有权限进行访问
     *
     * @param scopeLevel 权限注解
     * @param map token中传递的参数
     * @return
     */
    private boolean hasPermission(ScopeLevel scopeLevel, Map<String, Claim> map) {
        Integer level = scopeLevel.value();
        Integer scope = map.get("scope").asInt();
        if(level > scope){
            throw new ForbiddenException(10005);
        }
        return true;
    }
}

将interceptor注册到spring容器的启动项中：

@Component
public class InterceptorConfiguration implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 将权限拦截器注册到spring启动项中
        registry.addInterceptor(new PermissionInterceptor());
    }
}

 

 

 内容出处：七月老师《从Java后端到全栈》视频课程

七月老师课程链接：https://class.imooc.com/sale/javafullstack