JWT学习

2019-04-09

字数统计: 2.9k字 | 阅读时长: 13分

× 文章目录

1. 前言
2. 1 跨域认证的问题
3. 2 JWT的原理
4. 3 JWT的数据结构
5. 4 JWT 的使用方式
6. 5 JWTI的几个特点
7. 六 SpringBoot2.0集成JWT作鉴权

前言

文章出处： JSON Web Token–摘自阮一峰

JSON Web Token(缩写 JWT)是目前最流行的跨域认证解决方案。

1 跨域认证的问题

互联网离不开用户认证，一般流程是下面这样。

用户向服务器发送用户名和密码。
服务器验证通过后，在当前会话（session）里面保存相关数据，比如用户角色、登录时间等。
服务器向用户返回一个 session_id，写入用户的Cookie。
用户随后的每一次请求，都会通过Cookie，将 session_id 回传服务器。
服务器收到 session_id ，找到前期保存的数据，由此得知用户的身份。

这种模式的问题在于：扩展性（scaling）不好。单机当然没有问题，如果是服务器集群，或者跨域的服务导向架构，就要求 session 数据共享，每台服务器都能够读取 session。
举例来说，A网站和B网站是同一家公司的关联服务。现在要求，用户只要在其中一个网站登录，再访问另一个网站就会自动登录，请问怎么实现？

一种解决方案是 session数据持久化，写入数据库或别的持久层。各种服务受到请求后，都向持久层请求数据。这种方案的优点是架构清晰，缺点是工程量比较大。另外，持久层万一挂了，就会单点失败。
另一种方案是服务器索性不保存 session数据了，所有数据都保存在客户端，每次请求都回传服务器。JWT就是这种方案的一个代表。

2 JWT的原理

JWT的原理是，服务器认证后，生成一个JSON 对象，发回给用户，就像下面这样。

{
 "name":"superadmin”
 "role":"manager"
 "expire_time：“2018-5-5 16:16:16”
}

以后，用户与服务端通信的时候，都要发挥这个JSON对象。服务器完全只靠这个对象认定用户身份。为了防止用户篡改数据，服务器再生成这个对象的时候，会家上签名。
服务器不再保存任何session数据了，即：服务器变成无状态了，从而较容易实现扩展。

3 JWT的数据结构

     实际的JWT大概就像下面这样：

     它是一个很长的字符串。中间用点(.)分割成三个部分。注意。JWT内部是没有换行的，这里只是为了便与便于展示，将它写成了几行。
     JWT的三个部分依次如下：

Header（头部）
Payload（负载）
Signature（签名）
即：Header.Payload.Signature

3.1 Header

Header部分就是一个JSON对象。描述了JWT的元数据，通常是下面这样：

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

上面代码中，alg属性表示签名的算法（algorithm）,默认是HMAC SHA256(写成HS256)；typ属性标识这个令牌（Token）的类型（type），JWT令牌统一写成JWT。

3.2 Payload

Payload部分也是一个JSON对象，用来存放实际需要传递的数据。JWT官方规定了7个字段，供使用。

iss（issuer) 签发人
exp(expiration time): 过期时间
sub(subject): 主体
aud(audience): 受众
nbf(Not Before): 生效时间
iat(Issued At): 签发时间
jti(JWT ID): 编号
除了官方字段，你可以在这个部分定义私有字段，如下所示：

{
“sub” :”123456”
“name”:”superadmin”
“admin”:true

}

注意：JWT默认是不加密的，任何人都可以读到，所以不要把秘密信息放在这个部分。这个JSON对象也要使用Base64URL算法转成字符串。

3.3 Signature

Signature 部分是对前两部分的签名。防止数据篡改。
首先，需要指定一个密钥（secret)。这个密钥只有服务器才知道，不能泄露给用户。然后，使用Header里面指定的签名算法（默认是HMAC SHA256），按照下面的公式产生签名。

HMACSHA256
(
base64URLEncode(header)+”.”+
base64URLEncode(payload),
secret
)

算出签名以后，把Header、Payload、Signature三个部分拼成一个字符串，每个部分之间用”点”(.)分割，即可返回给用户。

3.4 Base64URL

前面提到，Header和Payload串行化的算法是Base64URL。这个算法跟Base64算法基本类似，但不同的是：
JWT作为一个令牌（token)，有些场合可能会放到URL（如：api.example.com/token=xxx)。Base64有3个字符+、/和=。在URL里面有特殊含义，所以要被替换掉：=被省略、+替换成-、/换成_。这是Base64URL算法。

4 JWT 的使用方式

     客户端收到服务器返回的JWT，可以存储到Cookie里面，也可以存储到localStorage。
     此后，客户端每次与服务器通信，都要带上这个JWT。你可以把她它放在Cookie里面自动发送，但是这样不能跨域，所以更好地做法是放在HTTP请求的头信息Authorrization字段里面。
     Authorization：Bearer
     另一种做法是，跨域的时候，JWT就放在POST**请求的数据体里面。

5 JWTI的几个特点

（1）JWT默认是不加密，但也可以加密。生成原始Token以后，可以使用密钥再加密一次。
（2）JWT不加密的情况下，不能将秘密数据写入JWT。
（3）JWT不仅可以用于认证，也可以用户交换信息，有效使用JWT，可以降低服务器查询数据库的次数。
（4）JWT的最大缺点是：由于服务器不保存Session状态，因此无法再使用过程中废止某个token。
（5）JWT本身包含了认证信息，一旦泄露，任何人都可以获得该令牌的所有权限。为了减少盗用，JWT的有效期应该设置的比较短。对于一些比较重要的权限，使用时应该再次对用户进行认证。
（6）为了减少盗用。JWT不应该使用HTTP协议明码传输，要使用HTTPS协议传输。

六 SpringBoot2.0集成JWT作鉴权

项目架构：

entity —>>> User:

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
 private String name;
 private String password;
}

utils —>>> JwtUtil:

public class JwtUtil {
    /**
      * 过期时间为1天
      * 正式上线更换为15分钟
      */
  private static final long EXPIRE_TIME = 24*60*60*1000;

  /**
    * token 私钥
    */
  private static final String TOKEN_SECRET = "joijsdfjlsjfljfljl5135313135";

 public static String sign(String username,String userId){
        //过期时间
  Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
  //私钥及加密算法
  Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
  //设置头信息
  HashMap<String,Object> header = new HashMap<>(2);
  header.put("typ","JWT");
  header.put("alg","HS256");
  //附带username和userId生成签名
  return JWT.create().withHeader(header)
                .withClaim("loginName",username)
                .withClaim("userId",userId)
                .withExpiresAt(date)
                .sign(algorithm);
  }

    public static boolean verity(String token) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
  JWTVerifier verifier = JWT.require(algorithm).build();
  DecodedJWT jwt = verifier.verify(token);
 return true;  } catch (IllegalArgumentException e) {
            return false;
  } catch (JWTVerificationException e) {
            return false;
  }
    }
}

自定义状态码
utils —>>> AjaxResult

public class AjaxResult extends HashMap<String,Object> {
 private static final long serialVersionUID = 1L;

 public static final String CODE_TAG = "code";

 public static final String MSG_TAG = "msg";

 public static final String DATA_TAG = "data";

  /**
 * 状态类型
  */
  public enum Type
    {
        /** 成功 */
  SUCCESS(0),
  /**失败*/
  FAIL(1),
  /** 警告 */
  WARN(301),
  /** 错误 */
  ERROR(500);
 private final int value;

  Type(int value)
        {
            this.value = value;
  }

        public int value()
        {
            return this.value;
  }
    }

    /** 状态类型 */
  private Type type;

  /** 状态码 */
  private int code;

  /** 返回内容 */
  private String msg;

  /** 数据对象 */
  private Object data;

  /**
 * 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。
  */
  public AjaxResult()
    {
    }

    /**
 * 初始化一个新创建的 AjaxResult 对象
  *
 * @param type 状态类型
  * @param msg 返回内容
  */
  public AjaxResult(Type type, String msg)
    {
        super.put(CODE_TAG, type.value);
 super.put(MSG_TAG, msg);
  }

    /**
 * 初始化一个新创建的 AjaxResult 对象
  *
 * @param type 状态类型
  * @param msg 返回内容
  * @param data 数据对象
  */
  public AjaxResult(Type type, String msg, Object data)
    {
        super.put(CODE_TAG, type.value);
 super.put(MSG_TAG, msg);
 super.put(DATA_TAG, data);
  }

    /**
 * 返回成功消息
  *
 * @return 成功消息
  */
  public static AjaxResult success()
    {
        return AjaxResult.success("操作成功");
  }

    /**
 * 返回成功消息
  *
 * @param msg 返回内容
  * @return 成功消息
  */
  public static AjaxResult success(String msg)
    {
        return AjaxResult.success(msg, null);
  }

    /**
 * 返回成功消息
  *
 * @param msg 返回内容
  * @param data 数据对象
  * @return 成功消息
  */
  public static AjaxResult success(String msg, Object data)
    {
        return new AjaxResult(Type.SUCCESS, msg, data);
  }

    /**
 * 返回失败消息
  *
 * @return 成功消息
  */
  public static AjaxResult fail()
    {
        return AjaxResult.fail("操作失败");
  }

    /**
 * 返回失败消息
  *
 * @param msg 返回内容
  * @return 成功消息
  */
  public static AjaxResult fail(String msg)
    {
        return AjaxResult.fail(msg, null);
  }

    /**
 * 返回失败消息
  *
 * @param msg 返回内容
  * @param data 数据对象
  * @return 成功消息
  */
  public static AjaxResult fail(String msg, Object data)
    {
        return new AjaxResult(Type.FAIL, msg, data);
  }

    /**
 * 返回警告消息
  *
 * @param msg 返回内容
  * @return 警告消息
  */
  public static AjaxResult warn(String msg)
    {
        return AjaxResult.warn(msg, null);
  }

    /**
 * 返回警告消息
  *
 * @param msg 返回内容
  * @param data 数据对象
  * @return 警告消息
  */
  public static AjaxResult warn(String msg, Object data)
    {
        return new AjaxResult(Type.WARN, msg, data);
  }

    /**
 * 返回错误消息
  *
 * @return
  */
  public static AjaxResult error()
    {
        return AjaxResult.error("操作失败");
  }

    /**
 * 返回错误消息
  *
 * @param msg 返回内容
  * @return 警告消息
  */
  public static AjaxResult error(String msg)
    {
        return AjaxResult.error(msg, null);
  }

    /**
 * 返回错误消息
  *
 * @param msg 返回内容
  * @param data 数据对象
  * @return 警告消息
  */
  public static AjaxResult error(String msg, Object data)
    {
        return new AjaxResult(Type.ERROR, msg, data);
  }

    public Type getType()
    {
        return type;
  }

    public void setType(Type type)
    {
        this.type = type;
  }

    public int getCode()
    {
        return code;
  }

    public void setCode(int code)
    {
        this.code = code;
  }

    public String getMsg()
    {
        return msg;
  }

    public void setMsg(String msg)
    {
        this.msg = msg;
  }

    public Object getData()
    {
        return data;
  }

    public void setData(Object data)
    {
        this.data = data;
  }

}

Service接口

public interface IUserService {

    /**
 * 校验用户信息
  * @param loginName
  * @return
  */
  boolean checkUser(String loginName, String passWord);

  /**
 * 查询用户信息
  * @param loginName
  * @return
  */
  User getUser(String loginName);
}

Service 接口实现类

@Service
public class UserServiceImpl implements IUserService {

    @Override
  public boolean checkUser(String loginName, String passWord) {
        return true;
  }

    @Override
  public User getUser(String loginName) {
        User user = new User();
  user.setName("李四");
  user.setPassword("123");
 return user;
  }
}

Controller:

@Controller
@RequestMapping
public class LoginController {

    @Resource
  private IUserService userService;

  @PostMapping("login")
    @ResponseBody
  public AjaxResult login (@RequestBody Map<String,String> map){
        String loginName = map.get("loginName");
  String passWord = map.get("passWord");
  //身份验证
  boolean isSuccess =  userService.checkUser(loginName,passWord);
 if (isSuccess) {
            //模拟数据库查询
  User user = userService.getUser(loginName);
 if (user != null) {
                //返回token
  String token = JwtUtil.sign(loginName, passWord);
 if (token != null) {
                    return AjaxResult.success("成功",token);
  }
            }
        }
        return AjaxResult.fail();
  }

    @PostMapping("getUser")
    @ResponseBody
  public AjaxResult getUserInfo(HttpServletRequest request, @RequestBody Map<String, String> map){
        String loginName = map.get("loginName");
  String token = request.getHeader("token");
 boolean verity = JwtUtil.verity(token);
 if (verity) {
            User user = userService.getUser(loginName);
 if (user != null) {
                HashMap <String ,Object> hashMap = new HashMap<>();
  hashMap.put("name",user.getName());
  hashMap.put("password",user.getPassword());
 return AjaxResult.success("成功", new JSONObject(hashMap).toString());
  }
        }
        return AjaxResult.fail();
  }

}

yml文件

server:
  port: 8089
  servlet:
    context-path: /milo

postman进行测试