JWT整合springBoot简单实用

JWT是什么?

Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。

JWT的构成

第一部分我们称它为头部（header),第二部分我们称其为载荷（payload, 类似于飞机上承载的物品)，第三部分是签证（signature).

header

jwt的头部承载两部分信息：

声明类型，这里是jwt
声明加密的算法 通常直接使用 HMAC SHA256
完整的头部就像下面这样的JSON：

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

然后将头部进行base64加密（该加密是可以对称解密的),构成了第一部分.

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

playload

载荷就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分

标准中注册的声明
公共的声明
私有的声明

定义一个payload:

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

然后将其进行base64加密，得到Jwt的第二部分。

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9

signature

jwt的第三部分是一个签证信息，这个签证信息由三部分组成：

header (base64后的)
payload (base64后的)
secret

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。

// javascript
var encodedString = base64UrlEncode(header) + '.' + base64UrlEncode(payload);

var signature = HMACSHA256(encodedString, 'secret'); // TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

将这三部分用.连接成一个完整的字符串,构成了最终的jwt:

  eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

如何应用

一般是在请求头里加入Authorization，并加上Bearer标注：

fetch('api/user/1', {
  headers: {
    'Authorization': 'Bearer ' + token
  }
})

接下来是重点

整合springboot

maven依赖

 <dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.7.0</version>
 </dependency>
 <dependency>
     <groupId>com.auth0</groupId>
     <artifactId>java-jwt</artifactId>
     <version>3.4.0</version>
 </dependency>

utils

@Component
public class Test {
    /**
     * 登录Token的生成和解析
     */
    public static final String SECRET = "JKKLJOoasdlfj";
    /** token 过期时间: 10天 */
    public static final int calendarField = Calendar.DATE;
    public static final int calendarInterval = 10;

    /**
     * @param user_id
     *            登录成功后用户user_id, 参数user_id不可传空
     */
    public static String createToken(Long user_id) throws Exception {
        Date iatDate = new Date();
        // expire time
        Calendar nowTime = Calendar.getInstance();
        nowTime.add(calendarField, calendarInterval);
        Date expiresDate = nowTime.getTime();

        // header Map
        Map<String, Object> map = new HashMap<>();
        map.put("alg", "HS256");
        map.put("typ", "JWT");

        // build token
        String token = JWT.create().withHeader(map) // header
                .withClaim("iss", "Service") // payload
                .withClaim("aud", "APP")
                .withClaim("user_id", null == user_id ? null : user_id.toString())
                .withIssuedAt(iatDate) // sign time
                .withExpiresAt(expiresDate) // expire time
                .sign(Algorithm.HMAC256(SECRET)); // signature

        return token;
    }

    /**
     * 解密Token
     *
     * @param token
     * @return
     * @throws Exception
     */
    public static Map<String, Claim> verifyToken(String token) {
        DecodedJWT jwt = null;
        try {
            JWTVerifier verifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
            jwt = verifier.verify(token);
        } catch (Exception e) {
            // e.printStackTrace();
            // token 校验失败, 抛出Token验证非法异常
        }
        return jwt.getClaims();
    }

    /**
     * 根据Token获取user_id
     *
     * @param token
     * @return user_id
     */
    public static Long getAppUID(String token) {
        Map<String, Claim> claims = verifyToken(token);
        Claim user_id_claim = claims.get("user_id");
        if (null == user_id_claim || StringUtils.isEmpty(user_id_claim.asString())) {
            // token 校验失败, 抛出Token验证非法异常
        }
        return Long.valueOf(user_id_claim.asString());
    }
}

这里有两种方法分别为:

jwt+cookie

    @GetMapping("/getAll")
    public String  getAll(HttpServletRequest request, HttpServletResponse response) 
    throws Exception {
        //创建token
        String token = test.createToken(1L);
        //生成cookie
        Cookie cookie = new Cookie("acc",token);
        //放入cookie
        response.addCookie(cookie);
        //写入请求头
        response.setHeader("acc", token);
        //输出令牌
        System.out.println("token===========>"+token);
        return token;
    }

调用得出结果:

token===========>eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJBUFAiLCJ1c2VyX2lkIjoiMSIsImlzcyI6IlNlcnZpY2UiLCJleHAiOjE1OTEwMjg4MzYsImlhdCI6MTU5MDE2NDgzNn0.UOAchNYYXECyey1np87kOF0Di0XagpNJE-ruPGwQ3B8

解析token

@PostMapping("/getAll")
    public Map<String, Claim> postGetAll(HttpServletRequest request){
        //拿到头信息
        String acc = request.getHeader("acc");
        //输出头信息
        System.out.println("头信息===========>"+acc);
        //得到所有cookie
        Cookie[] cookies = request.getCookies();
        //定义返回值
        Map<String, Claim> stringClaimMap = null;
        //迭代cookie数组
        for (Cookie cookie : cookies) {
            //得到key值
            String name = cookie.getName();
            //得到对应key值
            if("acc".equals(name)){
                //得到cookie值
                String value = cookie.getValue();
                System.out.println(name+"======cookie中的值=====>"+value);
                //解析值得到token中信息
                stringClaimMap = test.verifyToken(value);
                //迭代信息key值
                Set<String> keySet = stringClaimMap.keySet();
                Iterator<String> iterator = keySet.iterator();
                while (iterator.hasNext()){
                    String key = iterator.next();
                    //得到有关user_id中的值
                    if("user_id".equals(key)){
                        //通过key值得到value
                        Claim claim = stringClaimMap.get(key);
                        System.out.println(key+"=====map中信息======>"+claim.asString());
                    }
                }
                Long appUID = test.getAppUID(value);
                System.out.println("appUID===========>"+appUID);
            }
        }
        return stringClaimMap;
    }

调用得出结果:

头信息===========>eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJBUFAiLCJ1c2VyX2lkIjoiMSIsImlzcyI6IlNlcnZpY2UiLCJleHAiOjE1OTEwMjgzODIsImlhdCI6MTU5MDE2NDM4Mn0.Mz8VJ4HrYnO8I40hSABWQKQSDY6EtP-weBkwOLjNBVE
acc======cookie中的值=====>eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJBUFAiLCJ1c2VyX2lkIjoiMSIsImlzcyI6IlNlcnZpY2UiLCJleHAiOjE1OTEwMjg4MzYsImlhdCI6MTU5MDE2NDgzNn0.UOAchNYYXECyey1np87kOF0Di0XagpNJE-ruPGwQ3B8
user_id=====map中信息======>1
appUID===========>1

还有一个重要的

JWT的开源的第三方JJWT的初步使用

定义操作类

@Data
@AllArgsConstructor
public class JwtInfo {
    private String uid;
}

定义service解析token

@Component
public class JwtTokenService {

    /**
     * token过期时间
     */
    private int expire = 6000;
    //生成token
    public String generatorToken(JwtInfo jwtInfo){
        return JwtTokenUtils.generatorToken(jwtInfo,expire);
    }
    //获取信息
    public JwtInfo stringInfoFromToken(String token){
        return JwtTokenUtils.getTokenInfo(token);
    }
}

定义utils

public class JwtTokenUtils {
    private static Key getKeyInstance(){
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        byte[] bytes = DatatypeConverter.parseBase64Binary("mall-user");
        return new SecretKeySpec(bytes,signatureAlgorithm.getJcaName());
    }

    /**
     * 生成token的方法
     * @param jwtInfo
     * @param expire
     * @return
     */
    public static String generatorToken(JwtInfo jwtInfo, int expire){
        return Jwts.builder().claim(JwtConstants.JWT_KEY_USER_ID,jwtInfo.getUid())
                .setExpiration(DateTime.now().plusSeconds(expire).toDate())
                .signWith(SignatureAlgorithm.HS256,getKeyInstance()).compact();
    }

    /**
     * 根据token获取token中的信息
     * @param token
     * @return
     */
    public static JwtInfo getTokenInfo(String token){
        Jws<Claims> claimsJws = Jwts.parser()
        			.setSigningKey(getKeyInstance())
        			.parseClaimsJws(token);
        Claims claims = claimsJws.getBody();
        return new JwtInfo(claims.get(JwtConstants.JWT_KEY_USER_ID).toString());
    }
}
class JwtConstants {
    public static final String JWT_KEY_USER_ID = "uid";
}

使用

    @GetMapping("/jjwt/token")
    public String jjwtToken(HttpServletResponse response){
        JwtInfo jwtInfo = new JwtInfo("111");
        String s = jwtTokenService.generatorToken(jwtInfo);
        System.out.println("cookie===========>"+s);
        Cookie cookie = new Cookie("acca",s);
        response.addCookie(cookie);
        return s;
    }

得出结果:

cookie===========>eyJhbGciOiJIUzI1NiJ9.eyJ1aWQiOiIxMTEiLCJleHAiOjE1OTAxNzE1MTJ9.3UXozDO_UoVhk84o0c0ULNIo3wYOk7fFinWUPb-AT3w

解析token

    @GetMapping("/jjwt/token1")
    public JwtInfo jjwtToken1(HttpServletRequest request){
        JwtInfo jwtInfo = null;
        Cookie[] cookies = request.getCookies();
        for (Cookie cookie : cookies) {
            if(cookie.getName().equals("acca")){
                System.out.println("cookie.getName()===========>"+cookie.getName());
                jwtInfo = jwtTokenService.stringInfoFromToken(cookie.getValue());
                System.out.println("jwtInfo===========>"+jwtInfo);
            }
        }
        return jwtInfo;
    }

得出结果:

cookie.getName()===========>acca
jwtInfo===========>JwtInfo(uid=111)