SpringBoot集成JWT令牌认证技术

1.什么是 JWT?

    JSON Web Token（ JWT ） 是一个开放标准（ RFC 7519 ），它定义了一种紧凑的、自包含的方式，用于在各方之间作为 JSON 对象安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。 JWT 可以使用秘密（使用 HMAC 算法）或公钥 / 私钥对使用 RSA 或 ECDSA 来签名。

    虽然 JWT 可以加密，但也提供保密各方之间，我们将重点放在签名令牌。签名的令牌可以验证包含在其中的声明的完整性，而加密的令牌隐藏这些声明以防止其他各方查阅变更。当令牌使用公钥 / 私钥对签名时，签名也证明只有持有私钥的方才是签名方。

    关于数字签名：数字签名（又称公钥数字签名）是只有信息的发送者才能产生的别人无法伪造的一段数字串,这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。它是一种类似写在纸上的普通的物理签名，但是使用了公钥加密领域的技术来实现的，用于鉴别数字信息的方法。一套数字签名通常定义两种互补的运算，一个用于签名，另一个用于验证。数字签名是非对称密钥加密技术与数字摘要技术的应用。

2.JWT的结构

    JWT 是由三段信息构成的，将这三段信息文本用. 符号，链接一起就构成了 JWT 字符串。 就像这样

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ
![avatar](img/1.jpg)

JWT 包含了三部分：

• 1.Header 头部 ( 标题包含了令牌的元数据，并且包含签名和 / 或加密算法的类型) ;

• 2.Payload 负载 ( 类似于飞机上承载的物品 ) ；

• 3.Signature 签名 / 签证;

  
  
  JWT TOKEN 结构图

• 2.1 JWT 头

  JWT 头部分是一个描述 JWT 元数据的 JSON 对象，通常如下所示。

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

    在上面的代码中， alg 属性表示签名使用的算法，默认为 HMAC SHA256 （写为 HS256 ）； typ 属性表示令牌的类型， JWT 令牌统一写为 JWT 。
    最后，使用 Base64 URL 算法将上述 JSON 对象转换为字符串保存。

• 2.2 有效载荷

  有效载荷部分，是 JWT 的主体内容部分，也是一个 JSON 对象，包含需要传递的数据。 JWT 指定七个默认字段供选择。

• iss ：发行人
• exp ：到期时间
• sub ：主题
• aud ：用户
• nbf ：在此之前不可用
• iat ：发布时间
• jti ： JWT ID 用于标识该 JWT

除以上默认字段外，我们还可以自定义私有字段，如下例：

{
"loginName": "zs",
"userName": " 张三 ",
"admin": true
}

请注意，默认情况下 JWT 是未加密的，任何人都可以解读其内容，因此不要构建隐私信息字段，存放保密信息，以防止信息泄露。JSON 对象也使用 Base64 URL 算法转换为字符串保存。

• 2.3 签名哈希

  签名哈希部分是对上面两部分数据签名，通过指定的算法生成哈希，以确保数据不会被篡改。
  首先，需要指定一个密码（ secret ）。该密码仅仅为保存在服务器中，并且不能向用户公开。然后，使用标头(Header)中指定的签名算法（默认情况下为HMAC SHA256 ）根据以下公式生成签名。

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

  在计算出签名哈希后， JWT 头，有效载荷和签名哈希的三个部分组合成一个字符串，每个部分用 "." 分隔，就构成整个 JWT 对象。

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9. eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9. TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

3.为什么使用 JWT ？

  随着技术的发展，分布式 web 应用的普及，通过 session 管理用户登录状态成本越来越高，因此慢慢发展成为 token 的方式做登录身份校验，然后通过 token 去取 redis 中的缓存的用户信息，随着之后 jwt 的出现，校验方式更加简单便捷化，无需通过 redis 缓存，而是直接根据 token 取出保存的用户信息，以及对 token 可用性校验，单点登录更为简单。

JWT 架构图：

JWT 架构图

token的使用原理：

token的使用原理

4.JWT 工作机制？

  在身份验证中，当用户使用其凭据成功登录时，将返回 JSON Web Token （即： JWT ）。由于令牌是凭证，因此必须非常小心以防止出现安全问题。一般情况下，不应将令牌保留的时间超过要求。理论上超时时间越短越好。

  每当用户想要访问受保护的路由或资源时，用户代理应该使用 Bearer(持票人) 模式发送 JWT，通常在Authorization(授权) header中。标题内容应如下所示：

Authorization: Bearer 

  在某些情况下，这可以作为无状态授权机制。服务器的受保护路由将检查 Authorization header 中的有效 JWT ，如果有效，则允许用户访问受保护资源。如果 JWT 包含必要的数据，则可以减少查询数据库或缓存信息。 如果在 Authorization header 中发送令牌，则跨域资源共享（ CORS ）将不会成为问题，因为它不使用 cookie 。
  注意：使用签名令牌，虽然他们无法更改，但是令牌中包含的所有信息都会向用户或其他方公开。这意味着不应该在令牌中放置敏感信息。

5.如何使用 JWT?

• 5.1 创建 springboot 工程

  在 IDEA 中构建一个 springboot 的 web 工程，在对应的 pom.xml 文件中引入以下内容：

    4.0.0
    
        
        
        
        
    
    com.sccl
    spring-boot-jwt
    0.0.1-SNAPSHOT
    spring-boot-jwt
    Spring Boot For Json Web Token

    
        1.8
    
    
    
        
            
                org.springframework.boot
                spring-boot-dependencies
                2.2.1.RELEASE
                pom
                import
            
        
    

    
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
        
            com.auth0
            java-jwt
            3.4.1
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-devtools
            runtime
            true
        
        
        
            org.projectlombok
            lombok
            true
        
        
        
            com.google.guava
            guava
            18.0
        
        
        
            org.springframework.boot
            spring-boot-configuration-processor
            true
        
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

• 5.2 编写 application.yml 配置文件

server:
  port: 8099
  servlet:
    context-path: /boots
#jwt 设置
com:
  sccl:
    springbootjwt:
      secret: wangbin # 私钥
      issuer: www.sccl.com #发布者
      subject: userLoginToken #主题
      audience: App # 签发给谁?
      hour: 1 #令牌过期时间
      minute: 30 #令牌刷新时间

#redis配置
spring:
  redis:
    database: 0 #Redis 数据库索引（默认为 0 ） (0-15,共16个数据库)
    host: 127.0.0.1 # Redis 服务器地址
    port: 6379 # Redis 服务器连接端口
    password:  # Redis 服务器连接密码（默认为空）
    jedis:
      pool:
        max-active: 200 # 连接池最大连接数（使用负值表示没有限制）
    timeout: 5000ms # 连接超时时间（毫秒）

• 5.3 构建项目包结构

项目包结构

包结构说明： annotation 注解包， bean 实体包， configure 配置包， exception 异常包， interceptor 拦截器包， jwt JWT 工具包， message 返回消息包， sysmag 系统管理包， usermag 用户管理包， util 工具包

• 5.4 代码说明

annotation 包
  FieldMarker 该注解的作用：主要在于说明 UserBean 中那些字段是 JWT 的负载字段

package com.sccl.springbootjwt.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Create by wangbin
 * 2019-12-03-19:36
 *  主要在于说明 UserBean 中那些字段是 JWT 的负载字段
 *  功能描述 标记 JWT  字段 用在 JavaBean 身上
 *  用来描述 对象与 Map  进行转换时 属性是否需要忽略
 */
@Retention(RetentionPolicy.RUNTIME) //生命周期运行时
@Target({ElementType.METHOD,ElementType.FIELD,ElementType.PARAMETER}) //作用范围方法，字段，参数
public @interface FieldMarker {
    /**
     *  功能描述 属性的名称
     *  开发时间 2019-12-03-19:36
     */
    String value();
}

bean 包
  UserBean 是一个 JavaBean ，代表用户资源，此类中某些属性可以作为 JWT 负载中的一部分

package com.sccl.springbootjwt.bean;

import com.sccl.springbootjwt.annotation.FieldMarker;
import lombok.Data;

import java.io.Serializable;

/** UserBean  是一个 JavaBean ，
 * 代表用户资源，此类中某些属性可以作为 JWT 负载中的一部分
 * Create by wangbin
 * 2019-12-03-19:41
 */
@Data
public class UserBean implements Serializable {
    private Long id;
    /**
     *  功能描述 用户名
     *  将 userName 作为 token 令牌中的一部分
     *  一定不要把过于敏感的数据，作为令牌中的一部分，切记
     *  开发时间 2019-12-03-19:41
     */
    @FieldMarker(value = "userName")
    private String userName;
    /**
     *  功能描述 登录名
     *  开发时间 2019-12-03-19:41
     */
    private String loginName;
    /**
     *  功能描述 密码
     *  开发时间 2019-12-03-19:41
     */
    private String password;
    /**
     *  功能描述 年龄
     *  开发时间 2019-12-03-19:41
     */
    private Integer age;
}

configure 包
  RedisConfig 类，通过 @Configuration 标记为一个 spring 配置类， 使用 @Bean 向容器中装配一个 RedisTemplate 的模板实例

package com.sccl.springbootjwt.configure;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/** redis的配置类
 * 通过 @Configuration 标记为一个 spring 配置类，
 * 使用 @Bean 向容器中装配一个 RedisTemplate 的模板实例
 * Create by wangbin
 * 2019-12-03-19:47
 */
@Configuration
public class RedieConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate redisTemplate(RedisConnectionFactory factory){
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om  = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        /* 制定 key  与 value  的 序列化规则 */
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key 采用 String 的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        // hash 的 key 也采用 String 的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // value 序列化方式采用 jackson
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // hash 的 value 序列化方式采用 jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

  WebMvcConfig 类，通过 @Configuration 标记为一个 spring 配置类， 使用 @Bean 向容器中装配一个 LoginInterceptor 的模板实例，该拦截器主要用来做 JWT 令牌认证

package com.sccl.springbootjwt.configure;

import com.sccl.springbootjwt.interceptor.LoginInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/** 通过 @Configuration 标记为一个 spring 配置类，
 *  使用 @Bean 向容器中装配一个 LoginInterceptor 的模板实例，拦截器主要用
 来做 JWT 令牌认证
 * Create by wangbin
 * 2019-12-04-9:57
 * 功能描述 springmvc 补充配置
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    /**
     * 方法说明:向容器中添加拦截器
     * @author wangbin
     * @date 2019/12/4 10:02
     */
    @Bean
    public LoginInterceptor loginInterceptor(){
        return new LoginInterceptor();
    }
    /**
     * 方法说明：拦截器添加拦截规则
     * @author wangbin
     * @date 2019/12/4 10:03
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor()) //注册拦截器
                .addPathPatterns("/**")  //拦截的路径模式
                .excludePathPatterns("/sys/login") //排除哪些路径
                .excludePathPatterns("/sys/logout")
                .excludePathPatterns("/static/**");
    }
}

exception 异常处理包
  异常，代表后端系统可能存在的问题。可能是持久层的，也可能是业务层的，当然也可能是表现的，还有可能是其他组件的。但不管是哪个层的，都要注意，不要抛给前端（特别是：不要让用户看到，体验感很重要！！！）
  ExceptionHandle 全局异常处理类，通过 @RestControllerAdvice 使用 AOP 编程原理将通知定义在表现层，只要表现层有异常都可以被该处理类监听到，从而可以从容的在此处对 " 异常 " 进行加工处理！！！

package com.sccl.springbootjwt.exception;

import com.sccl.springbootjwt.exception.customer.CustomerException;
import com.sccl.springbootjwt.message.ReturnMessage;
import com.sccl.springbootjwt.message.ReturnMessageUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.servlet.http.HttpServletResponse;

/** 全局异常处理类
 * 异常，代表后端系统可能存在的问题。可能是持久层的，也可能是业务层的，
 * 当然也可能是表现的，还有可能是其他组件的。但不管是哪个层
 * 的，都要注意，不要抛给前端（特别是：不要让用户看到，体验感很重要！！！）
 * ExceptionHandle  全局异常处理类，通过 @RestControllerAdvice 使用 AOP 编程原理
 * 将通知定义在表现层，只要表现层有异常都可以被该处理类监听到，
 * 从而可以从容的在此处对 " 异常 " 进行加工处理！！！
 * Create by wangbin
 * 2019-12-04-10:08
 */
@RestControllerAdvice
public class ExceptionHandle {
    private static final Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);
    @ExceptionHandler(value = Exception.class)
    public ReturnMessage