Spring Boot学习04--使用JWT进行Token验证

JWT(Json Web Token)是一种认证协议，在前后端分离的项目中，客户端向服务端发送的请求存在“跨域”的问题。而在分布式架构体系下，一般会有多个服务器提供服务。例如使用Nginx进行反向代理，使用轮询或根据负载的策略对服务器进行分配时，客户端每次请求的可能是不同的服务器。

这两种情况下，传统的Session存储客户端身份的方式就会有很多的不便。而JWT是解决方案之一。

1. Token的组成

JWT的Token由三部分组成：头部(Header)、负载(Payload)、验证签名(Signature)。

这三部分之间，使用英文句号"."分割，举例如下：

首先有一个固定的明文的前缀："Bearer "。

"token": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1aWQiOjUwMCwicmlkIjowLCJpYXQiOjE2MTExOTE3OTksImV4cCI6MTYxMTI3ODE5OX0.dCZFvxwJ0TS_fB_yj_6msveURl6xMYrsaaWraRqOA7Q"

 

Header默认内容如下：

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

将其进行Base64编码，得到的字符串为：eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9。头部是紧跟在Bearer 后面的的内容。

Payload中存储的是有效的信息，也是一个json格式，例如：

{
    'id': 1,
    'username': "zhangsan",
    'gender': 0
}

对其进行Base64编码，得到字符串为：ewogICAgJ2lkJzogMSwKICAgICd1c2VybmFtZSc6ICJ6aGFuZ3NhbiIsCiAgICAnZ2VuZGVyJzogMAp9。

 

Signature是根据两部分的信息进行签名得到的字符串，其签名规则为：

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

注：这里加密算法HMACSHA256由头部来指定，secret是存储在服务端的秘钥。

例如，对字符串"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1aWQiOjUwMCwicmlkIjowLCJpYXQiOjE2MTExOTE3OTksImV4cCI6MTYxMTI3ODE5OX0"，使用秘钥："itcast"，进行HMACSHA256进行加密，得到的结果为："dCZFvxwJ0TS_fB_yj_6msveURl6xMYrsaaWraRqOA7Q"。这做为token的第三部分。

 

2.在Spring Boot项目中使用JWT进行Token验证

首先在pom文件中添加JWT的坐标

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

 

编写工具类，实现Token的生成和验证逻辑：

package com.example.demo.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Calendar;
import java.util.Date;
import java.util.Map;

public class JWTUtils {

    public static final String secret = "mysecret";

    //生成token
    public static String getToken(Map<String,String> map){
        Calendar instance = Calendar.getInstance();
        Date date = instance.getTime();
        instance.add(Calendar.DATE,1);

        JWTCreator.Builder builder = JWT.create();
        map.forEach( (k,v) -> {
            builder.withClaim(k,v);
        });

        String token = builder
                .withIssuedAt(date)
                .withExpiresAt(instance.getTime())
                .sign(Algorithm.HMAC256(secret));

        return token;
    }

    public static DecodedJWT verify(String token){
        JWTVerifier build = JWT.require(Algorithm.HMAC256(secret)).build();
        DecodedJWT verify = build.verify(token);
        return verify;
    }
}

 

编写拦截器，实现对HTTP请求中的Token自动验证：

package com.example.demo.interceptors;

import com.auth0.jwt.interfaces.DecodedJWT;
import com.example.demo.utils.JWTUtils;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Map<String,Object> map = new HashMap<>();
        String token = request.getHeader("Authorization");
        try{
            DecodedJWT verify = JWTUtils.verify(token);
            return true;
        }
        catch (Exception e){
            e.printStackTrace();
            map.put("state",false);
            map.put("msg","请求失败");
        }
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().println(json);
        return false;
    }
}

 

编写Controller对Token接受请求，并处理：

package com.example.demo.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.example.demo.model.dto.SPManager;
import com.example.demo.model.out.LoginData;
import com.example.demo.model.out.LoginResult;
import com.example.demo.model.out.Meta;
import com.example.demo.service.SPManagerService;
import com.example.demo.utils.JWTUtils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;

@RestController
public class ManagerController {

    @Autowired
    SPManagerService spManagerService;

    @PostMapping("/login")
    public JSONObject Login(@RequestParam String username, @RequestParam String password) {
        System.out.println(username + "|" + password);
        
        LoginData lt = new LoginData();
        Meta meta = new Meta();
        SPManager model = spManagerService.getManagerByNameAndPwd(username, password);
        System.out.println(model);
        if (model != null) {
            HashMap<String, String> map = new HashMap<>();
            map.put("uid", model.getMgId().toString());
            map.put("rid", model.getRoleId().toString());
            String token = JWTUtils.getToken(map);

            lt.setId(model.getMgId());
            lt.setRid(model.getRoleId());
            lt.setUsername(model.getMgName());
            lt.setEmail(model.getMgEmail());
            lt.setMobile(model.getMgMobile());
            lt.setToken(token);

            meta.setMsg("登录成功");
            meta.setStatus(200);
        }else{
            lt = null;
            meta.setMsg("登录失败");
            meta.setStatus(400);
        }
        LoginResult lr = new LoginResult();
        lr.setData(lt);
        lr.setMeta(meta);

        String json = JSON.toJSONString(lr);
        JSONObject jsonObject = JSONObject.parseObject(json);
        return jsonObject;
    }
}

在拦截器JWTInterceptor中已经定义了对request头[Authorization]中存储的Token自动验签的处理的逻辑，请求只有通过了拦截器的验证，才能进入到Controller中。这样在具体的业务逻辑处理时就无需编写重复的验证逻辑了。