JWT简介及使用

言烬

已于 2022-10-29 22:25:17 修改

阅读量3k

点赞数 5

分类专栏：权限校验文章标签：前端 java

于 2022-09-07 14:08:06 首次发布

本文链接：https://blog.csdn.net/weixin_43994244/article/details/126699133

版权

权限校验专栏收录该内容

3 篇文章 0 订阅

订阅专栏

JWT简介及使用

JWT
JWT能做什么
- 认证流程
为什么需要JWT
- jwt结构
JWT使用
- java-jwt
- jjwt
JWT工具类编写
JWT整合springboot
JWT整合Springboot优化

JWT

jwt：json web token 官网
感谢编程不良人：视频学习
任何编程语言都可以用，目前最流行的跨域认证解决方案。
是一个开放标准，定义了一种紧凑的，自包含的方式，用于在各方之间以json对象安全地传输信息，此信息可以验证和信任，因为它是数字签名的。Jwt可以使用秘钥(使用HMAC算法)或使用RSA或ECDSA的公钥/私钥进行签名。
简单来说是通过JSON形式作为web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输，在数据传输过程中还可以完成数据加密，签名等相关处理。

JWT能做什么

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

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

认证流程

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

为什么需要JWT

cookie和session的缺点：

session信息都存储在服务端内存
集群环境中需要额外处理
csrf：Cross-site request forgery，cookie被截获后可能发生跨站点请求伪造
cookie的跨域(前后端分离)读写不方便

jwt优势：

输出是三个由.分割的Base64-URL字符串，可以在HTML和HTTP环境中轻松传递这些字符串，与基于XML的标准(如SAML)相比，更紧凑。
简洁：可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快。
自包含：负载中包含了所有用户所需的信息，避免了多次查询数据库。
因为token是以JSON加密的新三国hi保存在客户端的，所以JWT是跨语言的，原则上任何web形式都支持。
不需要再服务端保存会话信息，特别适用于分布式微服务。

jwt结构

Header(标头).Payload(有效载荷).Signature(签名)
Header
标头由令牌的类型(即JWT)和所使用的签名算法组成，如HMAC，SHA256和RSA，会使用Base64编码组成JWT结构的第一部分
注意：Base64是一种编码，也就是说，它可以翻译回原来的样子，不是一种加密过程。
头默认值：(一般不做处理)

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

Payload
有效负载，其中包含声明，声明是有关实体(通常是用户)和其他数据的声明。同样会用Base64编码组成JWT结构的第二部分，不存放密码。

{ 
  "id":"122222256",
  "name": "jhon",
  "admin":true
}

Signature
Header和Payload是使用Base64进行编码的，即其翻译可以解开知道里面的信息。Signature将“head.Payload”，然后调用header中指定的alg算法HS256进行加密处理。（需要一个secret秘钥，不对外公开）,作为第三部分结果签名的作用是保证JWT没有被篡改过(对头部以及负载内容进行签名，防止内容被篡改)。

HMACSHA256(base4UrlEncode(header)+"."+base64enc(payload),secret)

JWT使用

java-jwt

1.引入依赖

<!--jwt的第一种实现方式：java-jwt-->
<dependency>
   <groupId>com.auth0</groupId>
   <artifactId>java-jwt</artifactId>
   <version>3.11.0</version>
</dependency>

2.生成token

 @Test
    public void testGeneratorToken(){
        //一分钟后过期
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND,60*10);
        //claim：声明，断言
        JWTCreator.Builder builder = JWT.create()
                //payload的内容，由一个个的claim组成
                .withClaim("userId", 123)
                .withClaim("userName", "乐之者java")
                .withClaim("url", "https://jwt.io/")
                //设置过期时间，参数data对象
                .withExpiresAt(calendar.getTime());
        //设置签名，传入算法对象
        String sign = builder.sign(Algorithm.HMAC256(key));
        System.out.println(sign);
    }

结果
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6IuS5kOS5i-iAhWphdmEiLCJleHAiOjE2NjIzNDk2MjksInVzZXJJZCI6MTIzLCJ1cmwiOiJodHRwczovL2p3dC5pby8ifQ.6ZRqIdZmI7P-0eGBtD3BXackMBwZyA9NVCdUHCadTU4

3.根据令牌和签名解析数据

   @Test
    public void testVerify(){
        String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6IuS5kOS5i-iAhWphdmEiLCJleHAiOjE2NjIzNDk2MjksInVzZXJJZCI6MTIzLCJ1cmwiOiJodHRwczovL2p3dC5pby8ifQ.6ZRqIdZmI7P-0eGBtD3BXackMBwZyA9NVCdUHCadTU4";
        DecodedJWT verify = JWT.require(Algorithm.HMAC256(key)).build().verify(token);
        System.out.println(verify);
        if(verify != null){
            //胡哦去payload里面的信息，注意类型，如果类型不一致，获取不到，为null
            Integer userId = verify.getClaim("userId").asInt();
            System.out.println(userId);
        }
    }

常见异常信息

SignatureVerificationException 签名不一致
TokenExpiredException 令牌过期
AlgorithmMismatchException 签名算法不匹配
InvalidClaimException payload不可用

jjwt

1.引入依赖

<!--jwt的第一种实现方式：jjwt-->
<dependency>
   <groupId>io.jsonwebtoken</groupId>
   <artifactId>jjwt</artifactId>
   <version>0.9.0</version>
</dependency>

2.生成token

    @Test
    public void testGeneratorToken(){
        //10分钟后过期
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND,60*10);
        //创建payload的私有声明(根据特定的业务需求添加)
        HashMap<String,Object> claims = new HashMap<>();
        claims.put("userId",123);
        claims.put("userName","乐之者java");
        claims.put("url","https://jwt.io/");
        //setClaim()单独设置，setExpiration()设置过期时间
        JwtBuilder builder = Jwts.builder().setClaims(claims).setExpiration(calendar.getTime())
                //设置签名使用的签名算法和签名使用的密钥
                .signWith(SignatureAlgorithm.HS256, key);
        String sign = builder.compact();
        System.out.println(sign);
    }

结果
eyJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6IuS5kOS5i-iAhWphdmEiLCJleHAiOjE2NjIzNTAzNjUsInVzZXJJZCI6MTIzLCJ1cmwiOiJodHRwczovL2p3dC5pby8ifQ.Q2uMy8YQFlOF6V8sSVFmBydTuFsIikh-yuXeOtbc8Lk

3.根据令牌和签名解析数据

    @Test
    public void testVerify(){
        String token = "eyJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6IuS5kOS5i-iAhWphdmEiLCJleHAiOjE2NjIzNTAzNjUsInVzZXJJZCI6MTIzLCJ1cmwiOiJodHRwczovL2p3dC5pby8ifQ.Q2uMy8YQFlOF6V8sSVFmBydTuFsIikh-yuXeOtbc8Lk";
        Claims claims = Jwts.parser()//得到defaultJwtParser
                .setSigningKey(key)//设置签名的密钥
                .parseClaimsJws(token).getBody();//设置需要解析的jwt
        Integer userId = claims.get("userId", Integer.class);
        String userName = claims.get("userName", String.class);
        String url = claims.get("url", String.class);
        System.out.println(userId+"的name："+userName+"的url："+url);
    }

JWT工具类编写

public class JwtUtils {
    private static String TOKEN = "abc1234567";

    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();
        instance.add(Calendar.SECOND,60*10);
        builder.withExpiresAt(instance.getTime());
        return builder.sign(Algorithm.HMAC256(TOKEN));
    }

    public static void verify(String token){
        JWT.require(Algorithm.HMAC256(TOKEN)).build().verify(token);
    }
}

JWT整合springboot

1.引入依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
            <version>5.5.2</version>
            <scope>test</scope>
        </dependency>
        <!--jwt的第一种实现方式：java-jwt-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!--jwt的第一种实现方式：jjwt-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
        <!--序列化-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</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.11</version>
        </dependency>
    </dependencies>

2.配置文件编写

#数据库信息
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/sg_mp?useAffectedRows=true&useSSL=false&useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=12345678

#mybatis设置
mybatis.type-aliases-package=com.suisui.entity
mybatis.mapper-locations=classpath:/mapper/*.xml
logging.level.com.suisui.dao=debug

3.代码编写
mapper层查询数据库

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

<?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.suisui.dao.UserMapper">
    <select id="login" resultType="com.suisui.entity.User">
        select * from user where user_name = #{userName} and password = #{password}
    </select>
</mapper>

service层处理逻辑

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


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

    @Override
    public User login(User user) {
        User login = userMapper.login(user);
        if(login != null){
            return login;
        }
        throw  new RuntimeException("登录失败！");
    }
}

4.测试

@RestController
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;

	//用户登录，认证token
    @GetMapping("/user/login")
    public Map<String,Object> login(User user){
        log.info("获取到的信息："+user.getUserName()+user.getPassword());
        HashMap<String, Object> map = new HashMap<>();
        try {
            User login = userService.login(user);
            HashMap<String,String> payload = new HashMap<>();
            payload.put("id",login.getUserName());
            payload.put("name",login.getUserName());
            //生成JWT令牌
            String token = JwtUtils.getToken(payload);
            //token返回
            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;
    }

在这里插入图片描述

@RestController
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;
	//用户请求，解析token
    @PostMapping("/user/test")
    public Map<String,Object> test(String token){
        HashMap<String, Object> map = new HashMap<>();
        log.info("当前token为："+token);
        try {
            JwtUtils.verify(token);
            map.put("state",true);
            map.put("msg","请求成功");
            return map;
        } 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);
        return map;
    }
 }

测试不传token：在这里插入图片描述
测试传入正确token：

JWT整合Springboot优化

每次都要传递token数据，每个方法都需要验证token代码冗余，不够灵活，可以使用拦截器优化，分布式可以在网关中解决

1.编写拦截器，验证token

/**
 * 拦截器
 */
public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HashMap<String, Object> map = new HashMap<>();
        //获取请求头中的token
        String token = request.getHeader("token");
        try {
            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，响应给前端
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }
}

2.配置拦截器的请求

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("/*")//其他路径都拦截
                .excludePathPatterns("/user/login");//所有用户都放行
    }
}

3.业务代码只需处理逻辑

@RestController
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;
    @PostMapping("/user/test")
    public Map<String,Object> test(){
        //直接处理业务逻辑
        HashMap<String, Object> map = new HashMap<>();
            map.put("state",true);
            map.put("msg","请求成功");
            return map;
    }
}