学习记录-JWT

最新推荐文章于 2024-09-25 09:27:18 发布

fafa-1

最新推荐文章于 2024-09-25 09:27:18 发布

阅读量852

点赞数 21

文章标签：学习笔记

本文链接：https://blog.csdn.net/m0_70953351/article/details/134766015

版权

什么是JWT?

1.官网解释：

官网地址：https://jwt.io/introduction/

翻译过来是指：jsonwebtoken(JWT)是一个开放标准(rfc7519),它定义了一种紧凑的，自包含的方式，用于在各方之间以JSON对象安全地传输信息。此信息可以验证和信任，因为它是数字签名的jwt可以使用秘密(使用HMAC算法)或使用RSA或ECDSA的公钥/私钥对进行签名。

2.通俗理解

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

JWT能做什么

1.授权

授权是使用JWT的一种常见方案，用于用户登录，一旦用户登录，登录之后的每个请求将包括JWT，从而允许用户访问该令牌允许的路由，服务和资源。单点登录是当今广泛使用JWT的一项功能，因为它的开销很小并且可以在不同的域中轻松使用。
2.信息交换
JSON Web Token是在各方之间安全地传输信息的好方法。因为可以对JWT进行签名，例如，使用公钥/私钥对)，所以您可以确保发件人是他们所说的人。此外，由于签名是使用标头和有效负载计算的，因此您还可以验证内容是否遭到篡改。

为什么要选择JWT

对于传统的Session认证：

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

使用session的问题：

1.每个用户经过我们的应用认证之后，我们的应用都要在服务端做一次记录，以方便用户下次请求的鉴别，通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大。

⒉.用户认证之后，服务端做认证记录，如果认证的记录被保存在内存中的话，这意味着用户下次请求还必须要请求在这台服务器上,这样才能拿到授权的资源，这样在分布式的应用上，相应的限制了负载均衡器的能力。这也意味着限制了应用的扩展能力。

3.因为是基于cookie来进行用户识别的,cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。
4.在前后端分离系统中非常的不便利
前后端分离在应用解耦后增加了部署的复杂性。通常用户一次请求就要转发多次。如果用session 每次携带sessionid到服务器，服务器还要查询用户信息。同时如果用户很多。这些信息存储在服务器内存中，给服务器增加负担。还有就是CSRF(跨站伪造请求攻击)攻击，session是基于cookie进行用户识别的，cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。还有就是
sessionid就是一个特征值，表达的信息不够丰富。不容易扩展。而且如果你后端应用是多节点部署。那么就需要实现session共享机制。不方便集群应用。

基于JWT认证：

认证流程：

简单来说就是用户在前端页面输入用户名和密码之后，将其传递给后端这边，后端验证密码和用户的真假性，并生成对应的JWT令牌，将令牌通过JSON格式传递给前端，前端拿到这个令牌就将它存储在本地的浏览器里，而每一个令牌都设置了一个时间的，在时间到后，会失效，而登录后的所有所有操作，都必须携带正确，并没超时的令牌，后端在使用拦截器拿到令牌后就会判断令牌的真伪，这样就能实现认证。

JWT优势：

1.简洁(Compact):可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快

2.自包含(Self-contained):负载中包含了所有用户所需要的信息，避免了多次查询数据库

3.因为Token是以JSON加密的形式保存在客户端的，所以JWT是跨语言的，原则上任何web形式都支持。

4.不需要在服务端保存会话信息，特别适用于分布式微服务。

JWT结构

如图所识

标头：

标头通常由两部分组成：令牌的类型(即JWT)和所使用的签名算法，如HMAC,SHA256等，它使用Base64编码组成JWT的第一部分，也就是标头，注意（Base64只是一种编码，不是一种加密，是可以还原的）

有效负载：

第二部分就是用来存储你所要使用到的数据的，比如用户名，用户id，和用户不重要的基本信息，但是注意不要放入用户的保密的信息，如密码等，因为也是用户Base64编码，被别人获取到你的令牌后，是可以通过反编译，获取到这个用户的信息的，所以只能放一些不重要的信息。

签名：

签名就是通过算法等生成对应的密钥，对你的令牌进行签名，防止他人的窃取

使用JWT

1.引入依赖

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

2.用测试类测试怎么获取的令牌

@SpringBootTest
class SpingbootJwtApplicationTests {

    @Test
    void contextLoads() {
        HashMap<String, Object> map = new HashMap<>();
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND,20);
        String token = JWT.create()
                .withHeader(map)//标头,可以不写，默认就是这个
                .withClaim("userId",21)//负载
                .withClaim("username","xiaochen")
                .withExpiresAt(instance.getTime())//指定令牌的过期时间
                .sign(Algorithm.HMAC256("!Q@wefa"));//签名
        System.out.println(token);
    }

}

3.用测试类测试怎么获取JWT的内容

@Test
    void text(){
        //创建验证对象
        JWTVerifier jwtVerifier =JWT.require(Algorithm.HMAC256("!Q@wefa")).build();//选判断算法是否正确，

        DecodedJWT verify =jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3MDA2Nzc1ODQsInVzZXJpZCI6MjEsInVzZXJuYW1lIjoieGlhb2NoZW4ifQ.-BSXQJkldKtSLnqQIMR9hK7u69SHKEKlDHkypxEkEJ4");//再解码
        System.out.println(verify.getClaim("userid").asInt());
        System.out.println(verify.getClaim("username").asString());
        System.out.println("过期时间:"+verify.getExpiresAt());
//        System.out.println(verify.getClaims().get("userid").asInt());
//        System.out.println(verify.getClaims().get("username").asString());
    }

我们这里就通过了测试类的方式测试了如何使用和获取JWT，但在业务中肯定不能这样，我们可以将它封装为一个类

封装JWT为一个类

package com.example.spingbootjwt.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.Map;

public class JWTUtils {

    private static final  String SING = "!Q@wefa";
    /*
    生成token header.payload.sing
    * */
    public static String getToken(Map<String,String> map){
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.DATE,7);//默认7天过期
//闯进啊jwt builder
        JWTCreator.Builder builder = JWT.create();
//payload
        map.forEach((k,v)->{
            builder.withClaim(k,v);
        });

        String token = builder.withExpiresAt(instance.getTime())
                .sign(Algorithm.HMAC256(SING));


        return token;
    }
    /*
    * 验证token 合法性
    * */
    public static DecodedJWT verify(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整合JWT完成登录

1.导入依赖

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>
        <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>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>
    </dependencies>

2.创建数据库，自行创建

3.写一个mapper包，并写相应的Mapper文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.spingbootjwt.dao.UserDao">
    <select id="login" parameterType="User" resultType="User">
        select * from user1 where name = #{name} and password = #{password}
    </select>
</mapper>

4.配置application.properties文件

server.port=8080
spring.application.name=jwt

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/bobo?serverTimezone=Asia/Shanghai&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=czj520hjh

mybatis.type-aliases-package=com.example.spingbootjwt.entity
mybatis.mapper-locations=classpath:com/example/example/spingbootjwt/mapper/*.xml

logging.level.com.example.spingbootjwt.dao=debug

5.编写实体类

package com.example.spingbootjwt.entity;

import lombok.Data;

@Data
public class User {
    private String id;
    private String name;
    private String password;
}

6.编写dao层

package com.example.spingbootjwt.dao;

import com.example.spingbootjwt.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserDao {
    User login(User user);
}

7.编写service层和它的实现类

package com.example.spingbootjwt.service;

import com.example.spingbootjwt.entity.User;

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


package com.example.spingbootjwt.service;

import com.example.spingbootjwt.dao.UserDao;
import com.example.spingbootjwt.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class UserServiceImpl implements UserService{
    @Autowired
    private UserDao userDao;
    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public User login(User user) {
//        根据接收用户名密码查询数据库
        User userDB = userDao.login(user);
        if(userDB!=null){
            return userDB;
        }
        throw new RuntimeException("登录失败!");
    }
}

8.编写JWT的过滤器进行过滤

package com.example.spingbootjwt.interceptors;

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.example.spingbootjwt.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("token");
        try{
            DecodedJWT verify = JWTUtils.verify(token);
            return true;
        }catch (SignatureVerificationException e){
            e.printStackTrace();
            map.put("msg","无效签名");
        }catch (TokenExpiredException e){
            e.printStackTrace();
            map.put("msg","token失效");
        }catch (AlgorithmMismatchException e){
            e.printStackTrace();
            map.put("msg","两次算法不一致");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg","token无效");
        }
        map.put("state",false);
        //将map转为json jackson
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }

}

9.编写config文件，让过滤器能够使用

package com.example.spingbootjwt.config;

import com.example.spingbootjwt.interceptors.JWTInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

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

10.编写controll层进行测试

package com.example.spingbootjwt.controller;

import com.auth0.jwt.JWT;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.example.spingbootjwt.entity.User;
import com.example.spingbootjwt.service.UserService;
import com.example.spingbootjwt.utils.JWTUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@Slf4j
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/login")//登录接口用来生成token并响应出去
    public Map<String,Object> login(User user){
        log.info("用户名：[[]]",user.getName());
        log.info("密码：[{}]",user.getPassword());
        Map<String,Object> map = new HashMap<>();
        try {
            User userDB=userService.login(user);
            Map<String,String> payload = new HashMap<>();
            payload.put("id",userDB.getId());
            payload.put("name",userDB.getName());
//            生成JWT令牌
            String token= JWTUtils.getToken(payload);
            map.put("state",true);
            map.put("msg","认证成功");
            map.put("token",token);//响应token
        }catch (Exception e){
            map.put("state",false);
            map.put("msg",e.getMessage());
        }
        return map;
    }
    @PostMapping("/test")//被过滤器保护的类
    public Map<String,Object>test(String token){
        Map<String,Object> map = new HashMap<>();
        //处理自己业务逻辑
        map.put("state",true);
        map.put("msg","请求成功!");
        return map;
    }
}