前言：
编程不良人——JWT认证原理、流程整合springboot实战应用,前后端分离认证的解决方案!
https://www.bilibili.com/video/BV1i54y1m7cP?p=1
欢迎大家支持。
以下是个人学习笔记。

一、简介

1.1 含义

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

1.2 认证流程

在这里插入图片描述
1.认证流程

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

2.与传统的基于Session认证相比
由于HTTP是无状态链接，用户第一次请求时，服务器会将用户信息保存在Session里，并且返回SessionID给用户，保存在Cookied中；用户再次请求时，可以通过SessionID从服务器中取出响应的数据，不需要再次认证。
基于session认证暴力的问题：

每一个用户经过我们的应用认证之后，我们的应用都会在服务端做一次记录，一遍用户下次请求鉴别，通常而言session都是保存在在内存中，随着用户数的增加，服务器的开销会明显增大。
用户认证之后，服务器做认证，如果认证的记录保存在内存中，这意味下次认证必须还是这台服务器，在分布式系统中明显限制了负载均衡的能力。
Session是基于Cookie进行用户识别的，如果Cookie被获取容易造成信息安全问题，用户容易受到跨站请求伪造的攻击。

2.jwt优势

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

1.3JWT结构

令牌形成

1.标头(Header)
2.有效载荷(Payload)
3.签名(Signature)

Header

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

Payload

将能用到的用户信息放在 Payload中。官方建议不要放特别敏感的信息，例如密码。

签名

签名由三部分组成，header和payload分别经base64Url(一种在base64上做了一点改变的编码)编码后由’.’连接,服务器生成秘钥（secret），连接之后的字符串在经header中声明的加密方式和秘钥加密，再用’.'和加密前的字符串连接。服务器验证token时只会验证第三部分。

二、使用JWT

2.1 导入依赖

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

2.2 生成令牌

    @Test
    void contextLoads() {
    
    
        HashMap<String, Object> map = new HashMap<>();
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND,100);
        String token = JWT.create().withHeader(map)  //header
                .withClaim("userId",21) //playload
                .withClaim("username","xiaoming")
                .withExpiresAt(instance.getTime()) //指定令牌的过期时间
                .sign(Algorithm.HMAC256("!q@w#s$er")); //签名
        System.out.println(token);
    }

2.3 验证令牌

    @Test
    public void test(){
    
    
        //创建验证对象
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("!q@w#s$er")).build();
        DecodedJWT verify = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2NDA0NTUwNTEsInVzZXJJZCI6MjEsInVzZXJuYW1lIjoieGlhb21pbmcifQ.gSzHO_u4-bzThmXaj28cFOq6IkSgFNbqbbJIrbT18bw");
        System.out.println(verify.getHeader()); //通过解码拿出playload信息
        System.out.println(verify.getClaim("userId").asInt());
        System.out.println(verify.getClaim("username").asString());
    }

三、JWT工具类封装

创建JWTUtils.java

public class JWTUtils {
    
    
    private static final String SING = "!q@w#s$er";
    /*
    * 生成token header.payload.sing
    * */
    public static String getToken(Map<String,String> map){
    
    
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.DATE,7);
        JWTCreator.Builder builder = JWT.create();
        map.forEach((k,v)->{
    
    
            builder.withClaim(k,v);
        }); //加入用户信息
        //sign
        String token = builder.withExpiresAt(instance.getTime())
                .sign(Algorithm.HMAC256(SING));//签名
        return token;
    }
    /*
    * 验证token
    * */
    public static DecodedJWT vertify(String token){
    
    
        return JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
    }

    //获取token信息方法
    public static DecodedJWT getTokenInfo(String token){
    
    
        DecodedJWT verify = JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
        return verify;
    }
}

四、整合SpringBoot

4.1 导入依赖

        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.19</version>
        </dependency>
        <!--mysql 依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--lombok 依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

4.2 配置文件配置:

spring:
  datasource:
    username: root
    password: 123
    #?serverTimezone=UTC解决时区的报错
    url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    #Spring Boot 默认是不注入这些属性值的，需要自己绑定
    #druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true

    #配置监控统计拦截的filters，stat:监控统计、log4j：日志记录、wall：防御sql注入
    #如果允许时报错  java.lang.ClassNotFoundException: org.apache.log4j.Priority
    #则导入 log4j 依赖即可，Maven 地址：https://mvnrepository.com/artifact/log4j/log4j
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

mybatis:
  type-aliases-package: com.kuang.springbootjwt.pojo
  mapper-locations: classpath:mapper/*.xml

server:
  port: 8080

4.3数据库新建库和表：

在这里插入图片描述

4.4 新建实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class User {
    
    
    private Integer id;
    private String name;
    private String pwd;

    public User(String name, String pwd) {
    
    
        this.name = name;
        this.pwd = pwd;
    }
}

4.5 dao层

import com.kuang.springbootjwt.mapper.UserMapper;
import com.kuang.springbootjwt.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class UserDao {
    
    

    @Autowired
    private UserMapper userMapper;

    public User Login(User user) {
    
    
        return userMapper.Login(user);
    }

    public User checkUserName(String username) {
    
    
        return userMapper.checkUserName(username);
    }
}

4.6UserMapper.xml文件

import com.kuang.springbootjwt.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

//这个注解表示了这是一个Mybatis的Mapper
@Mapper
@Repository
public interface UserMapper {
    
    
    // 获取所有部门信息
    List<User> queryUserList();

    // 通过id获得用户
    User queryUserById(int id);

    // 通过用户密码查询
    User Login(User user);

    //查询用户姓名
    User checkUserName(String username);

    //添加用户
    Integer addUser(User user);

    int deleteUser(int id);

4.7service层

public interface UserService {
    
    
    public User UserLogin(User user);
}

@Transactional
@Service
public class UserServiceImpl implements UserService {
    
    
    @Autowired
    private UserDao userDao;
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public User UserLogin(User user){
    
    
        System.out.println(user.getName());
        System.out.println(user.getPwd());
        User userDB = userDao.Login(user);
        if(userDB != null){
    
    
            return userDB;
        }
        throw new RuntimeException("登录失败");
    }
}

4.8 controller层

@RestController
@Slf4j
public class UserController {
    
    
    @Autowired
    private UserServiceImpl userService;
    @GetMapping("/user/login")
    public Map login(User user){
    
    
        log.info("用户名：",user.getName());
        log.info("密码：",user.getPwd());
        HashMap<String, Object> map = new HashMap<>();
        try {
    
    
            User userDB = userService.UserLogin(user);
            HashMap<String, String> payload = new HashMap<>();
            payload.put("id",userDB.getName());
            String token = JWTUtils.getToken(payload);
            map.put("state",true);
            map.put("msg","登录成功");
            map.put("token",token);
        }catch (Exception e){
    
    
            map.put("state",false);
            map.put("msg",e.getMessage());
        }
        return map;
    }
}

认证token

    @GetMapping("/user/test1")
    public  Map<String,Object> test1(String token) {
    
    
        HashMap<String, Object> map = new HashMap<>();
        log.info("当前token:[{}]",token);
        try{
    
    
            JWTUtils.vertify(token);
            map.put("state",true);
            map.put("msg","登录成功");
            return map;
        }catch (SignatureVerificationException e){
    
    
            e.printStackTrace();
            map.put("msg","无效签名");
        }catch (TokenExpiredException e){
    
    
            map.put("msg","token过期");
            e.printStackTrace();
        }catch (AlgorithmMismatchException e){
    
    
            map.put("msg","算法不一致");
            e.printStackTrace();
        }catch (Exception e){
    
    
            e.printStackTrace();
        }
        map.put("state",false);

        return map;
    }

4.9测试

登录成功
在这里插入图片描述
登录失败

认证成功：

五、JWT封装成拦截器

5.1 创建JWTInteceptor.java

public class JWTInteceptor implements HandlerInterceptor {
    
    
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler) throws IOException {
    
    
        String token = request.getHeader("token"); //获取请求头中的令牌
        HashMap<String , Object> map = new HashMap<>();
        try{
    
    
            JWTUtils.vertify(token);
           return true;
        }catch (SignatureVerificationException e){
    
    
            e.printStackTrace();
            map.put("msg","无效签名");
        }catch (TokenExpiredException e){
    
    
            map.put("msg","token过期");
            e.printStackTrace();
        }catch (AlgorithmMismatchException e){
    
    
            map.put("msg","算法不一致");
            e.printStackTrace();
        }catch (Exception e){
    
    
            e.printStackTrace();
        }
        map.put("state",false);
        //将map转为json
        String json = new ObjectMapper().writeValueAsString(map);
        //以json形式转回前台
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return  false;
    }

5.2 拦截器

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    
    
    public void addInterceptors(InterceptorRegistry registry){
    
    
        registry.addInterceptor(new JWTInteceptor())
                .addPathPatterns("/user/test")      //其他接口保护
                .excludePathPatterns("user/login");  //所有用户都放行
    }
}

5.3处理业务逻辑

    @PosttMapping("/user/test")
    public  Map<String,Object> test(HttpServletRequest request) {
    
    
        String token = request.getHeader("token");

       DecodedJWT vertify = JWTUtils.vertify(token);
//  处理业务逻辑
//        log.info("当前token为:[{}]",vertify.getClaim("name").asString());
        HashMap<String, Object> map = new HashMap<>();
        map.put("state",true);
        map.put("msg","登录成功");

        return map;
    }

JWT概述