JWT入门教程

JWT入门教程

按照惯例，先上官网：https://jwt.io/introduction/

JWT是什么？

JWT：JSON Web Token是将字符串通过JSON形式作为Web应用中的令牌,用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。

JWT能干什么？

由上面的定义，我们可以知道JWT有以下两个作用

授权

这是使用JWT的最常见方案。一旦用户登录，每个后续请求将包括JWT，从而允许用户访问该令牌允许的路由，服务和资源。单点登录是当今广泛使用JWT的一项功能，因为它的开销很小并且可以在不同的域中轻松使用

信息交换

JWT是在各方之间安全地传输信息的好方法。因为可以对JWT进行签名（例如，使用公钥/私钥对），所以您可以确保发件人是他们所说的人。此外，由于签名是使用标头和有效负载计算的，因此您还可以验证内容是否遭到篡改。

JWT的优势

谈到JWT的优势，我们就要先熟悉以下传统的基于session的认证方式

传统的基于session认证

认证方式

http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证

认证流程

此认证方式的缺点

• 每个用户经过应用认证之后都要在服务端做一次记录，以方便用户下次请求的鉴别，通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大
• 用户认证之后在服务端做认证记录并被保存在内存中，这意味着用户下次请求还必须要请求这台服务器才能拿到授权的资源。这对分布式的应用来讲，限制了其负载均衡器的能力，也意味着限制了应用的扩展能力
• 该方式是基于cookie来进行用户识别的，如果cookie被截获，用户就会很容易受到跨站请求伪造的攻击
• 对于前后端分离的系统来讲，由于应用的解耦增加了其部署的复杂性。用户的一次请求就要转发多次。如果用session每次携带sessionid到服务器，服务器都要查询用户信息。用户越多服务器的负担越大。还有就是CSRF（跨站伪造请求攻击）攻击，session是基于cookie进行用户识别的, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。另外sessionid是一个特征值，表达的信息不够丰富，不容易扩展。如果你后端应用是多节点部署，那么就需要实现session共享机制，不方便应用集群

基于JWT的认证

认证流程

• 首先，前端通过Web表单将自己的用户名和密码发送到后端。这一过程一般是一个HTTP POST请求。建议的方式是通过SSL加密的传输（https协议），从而避免敏感信息被嗅探
• 后端核对用户名和密码成功后，将用户的id等其他信息作为JWT Payload（负载），将其与头部分别进行Base64编码拼接后签名，形成一个形同xxx.yyy.zzz字符串的JWT(Token)
• 后端将JWT字符串作为登录成功的返回结果返回给前端。前端可以将返回的结果保存在localStorage或sessionStorage上，退出登录时前端删除保存的JWT即可
• 前端在每次请求时将JWT放入HTTP Header中的Authorization位。(解决XSS和XSRF问题)
• 后端检查JWT是否存在，如存在验证其有效性。例如，检查签名是否正确；检查Token是否过期；检查Token的接收方是否是自己（可选）
• 验证通过后后端使用JWT中包含的用户信息进行其他逻辑操作，返回相应结果

JWT的优势

• 简洁(Compact): 可以通过URL，POST参数或者在HTTP header中发送，数据量小，传输速度快
• 自包含(Self-contained)：负载中包含了用户所需要的信息，避免了多次查询数据库
• 因为Token是以JSON加密的形式保存在客户端，所以JWT是跨语言的，原则上任何web形式都支持
• 不需要在服务端保存会话信息，特别适用于分布式微服务

JWT的结构

JWT由三部分组成，可以简单的理解为Header.Payload.Singnature

Header–标头

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

标头通常由两部分组成：令牌的类型（即JWT）和所使用的签名算法，例如HMAC SHA256或RSA。它会使用Base64编码组成JWT结构的第一部分

注意:Base64是一种编码，也就是说，它是可以被翻译回原来的样子的。它并不是一种加密过程

Payload–有效载荷

{
  "id": "1",
  "name": "christy",
  "admin": true
}

令牌的第二部分是有效负载，其中包含声明。声明是有关实体（通常是用户）和其他数据的声明。同样的，它会使用Base64编码组成JWT结构的第二部分

Signature–签名

Signature需要使用编码后的header和payload以及我们提供的一个密钥，然后使用header中指定的签名算法（通常为HS256）进行签名。签名的作用是保证JWT没有被篡改过

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

• 签名的目的

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

• 信息安全问题

  如上所述Base64是一种可逆的编码，那么我们存储在其中的信息不就被暴露了吗？

  答案是肯定的。所以在JWT中，不应该在负载里面加入任何敏感的数据。在上面的例子中，我们传输的是用户的User ID。这个值实际上不是什么敏感内容，一般情况下被知道也是安全的。但是像密码这样的内容就不能被放在JWT中了。如果将用户的密码放在了JWT中，那么怀有恶意的第三方通过Base64解码就能很快地知道你的密码了。因此JWT适合用于向Web应用传递一些非敏感信息。JWT还经常用于设计用户认证和授权系统，甚至实现Web应用的单点登录

SpringBoot中集成JWT

修改pom.xml

新建一个测试项目springboot_jwt，pom中增加以下依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

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

<!-- mybatis plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.1</version>
</dependency>

<!--引入lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

<!--引入druid-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.19</version>
</dependency>

<!--引入mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.38</version>
</dependency>

<!--springfox swagger3.x时代我们使用官方Starter-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>

<!--整合Knife4j-->
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
    <version>3.0</version>
</dependency>

修改application.yml

server:
  port: 8999

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/christy?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=UTC
      username: root
      password: 123456
      # 监控统计拦截的filters
      filters: stat,wall,log4j,config
      # 配置初始化大小/最小/最大
      initial-size: 5
      min-idle: 5
      max-active: 20
      # 获取连接等待超时时间
      max-wait: 60000
      # 间隔多久进行一次检测，检测需要关闭的空闲连接
      time-between-eviction-runs-millis: 60000
      # 一个连接在池中最小生存的时间
      min-evictable-idle-time-millis: 300000
      validation-query: SELECT 'x'
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      # 打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false
      pool-prepared-statements: false
      max-pool-prepared-statement-per-connection-size: 20

mybatis-plus:
  type-aliases-package: com.christy.shiro.model.entity
  configuration:
    map-underscore-to-camel-case: true

# 启用swagger
springfox:
  documentation:
    swagger-ui:
      enabled: true

持久层

package com.christy.jwt.model.entity;

import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @Author Christy
 * @DESC
 * @Date 2020/11/16 15:38
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("t_user")
@ApiModel("用户实体类")
public class User implements Serializable {
    /** 数据库中设置该字段自增时该注解不能少 **/
    @TableId(type = IdType.AUTO)
    @ApiModelProperty(name = "id", value = "ID 主键")
    private Integer id;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(name = "username", value = "用户名")
    private String username;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(name = "password", value = "密码")
    private String password;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(name = "salt", value = "盐")
    private String salt;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(name = "age", value = "年龄")
    private Integer age;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(name = "email", value = "邮箱")
    private String email;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(name = "address", value = "地址")
    private String address;
}

package com.christy.jwt.model.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.christy.jwt.model.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

/**
 * @Author Christy
 * @DESC
 * @Date 2020/11/16 15:49
 **/
@Mapper
public interface UserMapper extends BaseMapper<User> {

    /**
     * 用户登录 这里用的是shiro教程中数据库，密码是加密的，这里没有集成shiro，仅适用用户名	   * 模拟用户登录
     * @param username
     * @return
     */
    @Select("SELECT u.id,u.username,u.password,u.salt,u.age,u.email,u.address FROM t_user u WHERE u.username = #{username}")
    User login(String username);
}

Service层

package com.christy.jwt.service;

import com.christy.jwt.model.entity.User;

public interface UserService {
    /**
     * 用户登录
     * @param username
     */
    User login(String username);
}

package com.christy.jwt.service.impl;

import com.christy.jwt.model.entity.User;
import com.christy.jwt.model.mapper.UserMapper;
import com.christy.jwt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Override
    public User login(String username) {
        return userMapper.login(username);
    }
}

工具类–JWTUtil.java

package com.christy.jwt.utils;

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

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

public class JWTUtil {
    /**
     * 演示demo中salt硬编码，实际开发中应取用户的随机盐
     */
    private static String salt = "1q2w3e";
    /**
     * 生成token
     * @param map  //传入payload
     * @return 返回token
     */
    public static String getToken(Map<String,String> map){
        JWTCreator.Builder builder = JWT.create();
        map.forEach((k,v)->{
            builder.withClaim(k,v);
        });
        Calendar instance = Calendar.getInstance();
        // 设置token的有效期为15秒
        instance.add(Calendar.SECOND,15);
        builder.withExpiresAt(instance.getTime());
        return builder.sign(Algorithm.HMAC256(salt)).toString();
    }
    /**
     * 验证token
     * @param token
     * @return
     */
    public static void verify(String token){
        JWT.require(Algorithm.HMAC256(salt)).build().verify(token);
    }
    /**
     * 获取token中payload
     * @param token
     * @return
     */
    public static DecodedJWT getToken(String token){
        return JWT.require(Algorithm.HMAC256(salt)).build().verify(token);
    }
}

拦截器–JwtTokenInterceptor.java

这里的拦截器主要是做token的验证，避免了每次请求时都在接口校验写重复代码

package com.christy.jwt.interceptors;

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.christy.jwt.utils.JWTUtil;
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 JwtTokenInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("token");
        Map<String,Object> map = new HashMap<>();
        try {
            JWTUtil.verify(token);
            return true;
        } catch (TokenExpiredException e) {
            map.put("state", false);
            map.put("msg", "Token已经过期!!!");
        } catch (SignatureVerificationException e){
            map.put("state", false);
            map.put("msg", "签名错误!!!");
        } catch (AlgorithmMismatchException e){
            map.put("state", false);
            map.put("msg", "加密算法不匹配!!!");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("state", false);
            map.put("msg", "无效token~~");
        }
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}

package com.christy.jwt.configuration;

import com.christy.jwt.interceptors.JwtTokenInterceptor;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Component
public class InterceptorConfiguration implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JwtTokenInterceptor())
                .excludePathPatterns("/user/**")
                .addPathPatterns("/**");
    }
}

Controller层

UserController.java中的login()方法用来获取token

package com.christy.jwt.controller;

import com.christy.jwt.model.entity.User;
import com.christy.jwt.service.UserService;
import com.christy.jwt.utils.JWTUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("user")
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("login")
    public Map<String,Object> login(User user){
        Map<String,Object> result = new HashMap<>();
        log.info("用户名: [{}]", user.getUsername());

        try {
            User userDB = userService.login(user.getUsername());
            Map<String, String> map = new HashMap<>();
            map.put("id",userDB.getId().toString());
            map.put("username", userDB.getUsername());
            String token = JWTUtil.getToken(map);
            result.put("state",true);
            result.put("msg","登录成功!!!");
            result.put("token",token);
        } catch (Exception e) {
            e.printStackTrace();
            result.put("state","false");
            result.put("msg",e.getMessage());
        }
        return result;
    }
}

TestController.java中的test()方法用来测试验证token

启动服务测试

正常登录获取token，这个时间已经过了上面我们设置的token有效期的30秒的范围，现在我们去测试test方法，应该是token过期，我们来验证一下

我们现在重新登陆一下，获取到token后我们先输一个错误的，可以看到返回无效的token

重新输入正确的token，可以看到正确的响应结果