JWT的理解与使用

JWT的理解与使用

JSON Web Token（JSON Web令牌）

1 传统的session

1.1 认证的方式

​ 由于http协议本身是一种无状态的服务,当客户端连接一次后,下次连接必须要再次获得身份信息才能确定是否是同一用户,因此传统的验证方式是在用户登录后在服务端存贮一份用户的登录信息,并且传递给浏览器保存为cookie,这样下次请求时浏览器发送请求时只需要带着cookie就能被服务端识别出.

1.2 缺点

• 随着用户数量的增多必然会导致服务端存储的session数量增多,而其大多是保存在内存当中的,因此随着认证用户的增多,服务端的开销也会增大
• 由于是保存在内存当中所以当用户访问时必须访问特定的服务器才能获取到对应的session.在微服务的或者分布式的应用上,限制负载均衡,限制了应用的扩展能力

2 JWT认证

认证的流程如上图

2.1 优点

• 简介,可以在url中进行传输
• 自包含,包含了用户的信息,避免查询数据库
• 跨语言
• 不需要在服务端保存信息,适用于分布式微服务

3 JWT结构

本质上就是一个string字符串,由3个部分组成,中间用点隔开

组成

1. 标头 (header)
2. 有效载荷(payload)
3. 签名(signature)

eg(header.payload.signature)

• Header: 包含了令牌的类型以及签名的算法,使用base64编码

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

• payload: 有效负载,包含声明,通常是用户id信息和一些特定数据的存放,不包含密码同样是使用base64编码(base64是一种编码并不是加密方式,可以被还原)

  {
    "sub": "1234567890",
    "name": "John Doe",
    "admin": true
  }
  
  

• 签名: 前面两部分都使用Base64进行编码，前端可以解开知道里面的信息。Signature需要使用编码后的header和payload加上我们提供的一个密钥，使用header中指定的签名算法(HS256)进行签名。签名的作用是保证JWT没有被篡改过

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

  签名的目的:签名的过程实际上是对头部以及负载内容进行签名，防止内容被窜改。如果有人对头部以及负载的内容解码之后进行修改，再进行编码，最后加上之前的签名组合形成新的JWT的话，那么服务器端会判断出新的头部和负载形成的签名和JWT附带上的签名是不一样的。如果要对新的头部和负载进行签名，在不知道服务器加密时用的密钥的话，得出来的签名也是不一样的。

4. 使用

本次是在springBoot项目中使用并不是单纯介绍技术,因此会有相关设计的不同

4.1 引入依赖

<!--引入JWT-->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.10.0</version>
</dependency>

4.2 声明一个jwt的配置类

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "sky.jwt")
@Data
public class JwtProperties {

    /**
     * 管理端员工生成jwt令牌相关配置
     */
    private String adminSecretKey;
    private long adminTtl;
    private String adminTokenName;

    /**
     * 用户端微信用户生成jwt令牌相关配置
     */
    private String userSecretKey;
    private long userTtl;
    private String userTokenName;

}

这里分为微信端和网页端

4.3 相关的配置文件 .yml

ky:
  jwt:
    # 设置jwt签名加密时使用的秘钥
    admin-secret-key: itcast
    # 设置jwt过期时间
    admin-ttl: 7200000
    # 设置前端传递过来的令牌名称
    admin-token-name: token
    # 微信端
    user-secret-key: itplf
    user-ttl: 7200000
    user-token-name: authentication

4.4 使用

在之前可以封装一个工具类方便使用

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.Map;

public class JwtUtil {
    /**
     * 生成jwt
     * 使用Hs256算法, 私匙使用固定秘钥
     *
     * @param secretKey jwt秘钥
     * @param ttlMillis jwt过期时间(毫秒)
     * @param claims    设置的信息
     * @return
     */
    public static String createJWT(String secretKey, long ttlMillis, Map<String, Object> claims) {
        // 指定签名的时候使用的签名算法，也就是header那部分
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        // JWT的过期时间
        long expMillis = System.currentTimeMillis() + ttlMillis;
        Date exp = new Date(expMillis);

        // 设置jwt的body
        JwtBuilder builder = Jwts.builder()
                // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                .setClaims(claims)
                // 设置签名使用的签名算法和签名使用的秘钥
                .signWith(signatureAlgorithm, secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置过期时间
                .setExpiration(exp);

        return builder.compact();
    }

    /**
     * Token解密
     *
     * @param secretKey jwt秘钥 此秘钥一定要保留好在服务端, 不能暴露出去, 否则sign就可以被伪造, 如果对接多个客户端建议改造成多个
     * @param token     加密后的token
     * @return
     */
    public static Claims parseJWT(String secretKey, String token) {
        // 得到DefaultJwtParser
        Claims claims = Jwts.parser()
                // 设置签名的秘钥
                .setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置需要解析的jwt
                .parseClaimsJws(token).getBody();
        return claims;
    }

}

在用户登录成功后可以生成jwt令牌

//使用前先注入配置类
    @Autowired
    private JwtProperties jwtProperties;
	public void login(){
        //判断是否登录成功
        .................
        //登录成功后，生成jwt令牌
        Map<String, Object> claims = new HashMap<>();
        claims.put(userID, employee.getId()); //放入用户信息
        //生成令牌
        String token = JwtUtil.createJWT(
        jwtProperties.getAdminSecretKey(),
        jwtProperties.getAdminTtl(),
        claims);
        //将令牌返回给前端
		..............
  
    }

解密: 使用拦截器在非登录界面请求的其他请求进行拦截

 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }

        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getAdminTokenName());

        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);
            Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());
            //使用到Threadlocal保存当前线程的变量
            BaseContext.setCurrentId(empId);
            log.info("当前员工id：{}", empId);
            //3、通过，放行
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

5 总结

可以看出来,这种方式对服务端的内存消耗几乎可以忽略不记,只需要在配置文件中配置好相对应的密钥并且不泄漏出去外界是无法获得密钥信息,且对分布式服务比较友好不需要在特定服务器获取数据.