JWT的基本使用

最新推荐文章于 2023-06-18 00:59:33 发布

吉吉冕下

最新推荐文章于 2023-06-18 00:59:33 发布

阅读量231

点赞数

文章标签： jwt

本文链接：https://blog.csdn.net/ilove_story/article/details/109678627

版权

1、什么是JWT

官网介绍

JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed. JWTs can be signed using a secret (with the HMAC algorithm) or a public/private key pair using RSA or ECDSA.

中文翻译：JWT是一种开放标准(RFC 7519),它定义了一种紧凑的、自包含的方式在多方之间以JSON对象的形式安全的传输信息。这个信息可被验证和信任，因为它是数字签名的。JWT可以使用一种秘密(使用HMAC算法)或者使用RSA或者ECDSA的公钥、私钥进行签名。

通俗解释：JWT(JSON Web Token)，就是使用JSON形式作为web应用中的令牌，用于在各方之间使用JSON形式安全的传输信息，在传输过程中可以对信息进行数字签名和加密等处理

2、JWT能做什么

授权：
这是使用JWT较为广泛的解决方案，一旦用户登录，后续每个请求都将包含JWT，从而允许用户访问该令牌允许的路由、服务和资源。单点登录是如今使用JWT较广泛的一项功能，因为他开销很小，并且可以在多个域中轻松使用。
信息交换：JWT可用作在多方之间安全的传输信息，因为JWT是可被签名的(如使用公钥、私钥)。

3、为什么JWT

3.1 基于传统的Session的认证

# 介绍
我们知道，http是一种无状态的协议，也就意味着，当用户在第一次请求进行用户验证时，下一次请求时还需要进行用户验证，因为http是无状态的协议，我们无法知道是哪个用户发出的请求，所以为了让服务端知道是哪个用户发出的请求，我们通常会在服务端使用Session保存用户信息，并将这份用户信息响应给客户端，告诉客户端以cookie的方式保存，在下次请求时，客户端需要携带保存的cookie，这样服务端就能知道是哪个用户了，这就是传统的Session认证。
# 暴露问题
1、用户每进行一次验证，我们都要在服务端做一次记录，而Session一般是保存在内存中的，随着用户量的增大，服务端的开销会明显增多。
2、用户认证之后，服务端会将信息保存在session中，也就是会保存到内存中，那么也就意味着用户的下一次请求必须得请求这一台服务器才行(当然，可以做session共享)，在分布式的应用中，会限制负载均衡的能力，也限制了应用的扩展能力。
3、因为是基于cookie进行用户验证的，如果cookie被拦截，很容易受到跨站请求伪造的攻击。
4、如果是前后端分离应用的话，会增加部署的复杂性。因为用户的请求会被转发多次，而在此期间，如果cookie被拦截，很容易受到CSRF(跨站伪造请求攻击)，而且如果后端应用是多节点部署，那么就需要实现Session共享机制，不方便集群应用。

3.2 基于JWT的认证

在这里插入图片描述

# 认证流程
- 首先，前端使用web表单将用户的用户名和密码发送到后端接口。
- 后端对用户名和密码验证成功后，将用户的id等信息作为JWT Payload(负载)，将其与头部分别进行Base64拼接后签名，形成一个JWT(Token)。Token包含三部分：头部(header)、负载(payload)和签名(signature)，是一个字符串
- 最终将JWT字符串返回给前端，前端可以将它保存在localStorage或者sessionStorage中，当用户退出登录时删除JWT即可
- 前端在每次请求时将JWT放入http请求的header的Authorization位(授权位)，解决XSS和XSRF问题
- 后端检查是否存在，检查签名是否正确，检查token是否过期，检查接收方是否是自己
- 验证通过后使用JWT包含的用户信息进行相应的操作，返回结果
# JWT优势
- 简洁(compact):JWT可以通过url、Post参数或者header发送，由于数据量小，传输速度很快
- 自包含(self-contained):由于负载中包含了所有用户需要的信息，避免了多次查询数据库
- 因为JWT是以JSON加密的形式保存在客户端的，原则上所有web应用都支持
- 不需要在服务端保存会话信息，是用于分布式微服务

4、JWT的结构

# JWT的组成
1、标头(header)
2、有效载荷(payload)
3、签名(signature)
通常格式是：xxxx.yyyyy.zzzzz

# 标头(header)
标头通常由两部分组成：令牌的类型(JWT)和所使用的签名算法，如HMAC、SHA256和RSA，它们会使用Base64编码后形成JWT结构的第一部分。(注意，Base64编码后可以被翻译会原来的样子，他并不是一个加密的过程)

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

# 有效载荷(payload)
令牌的第二部分是有效载荷，包含声明。声明是有关实体(通常是用户)和其它数据的声明，同样，有效载荷也会被Base64编码后作为JWT的第二部分(建议不要在负载中存放密码等敏感信息)

{
    "name" : "zzt",
    "role" : "admin"
}

# 签名(Signature)
前面两部分都是使用Base64进行编码的，可以通过Base64翻译后查看里面的信息，而Signature需要使用编码后的header和payload以及只有我们自己知道的密钥(随机盐)，通过header中签名算法形成签名，成为JWT的第三部分。
# 签名目的
签名的目的或者说作用是为了保证JWT没有被篡改过。因为标头和有效载荷使用Base64进行编码的，可以使用Base64解密后查看内部的信息(所以不建议把密码放里边)，如果有人将里面的信息
篡改了，并使用Base64重新编码后加上原来的签名拼凑成新的JWT发送到服务端，那么服务端会根据发送来的头部和负载使用密钥生成签名，判断生成的签名和发送来的签名是否一致，从而知道信息是否被篡改过。

4、第一个JWT程序

4.1 搭建环境

创建一个maven项目，导入下列依赖：

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

4.2编写测试类

public static void main(String[] args) {
        //创建一个token
        HashMap<String,Object> map = new HashMap<String, Object>();
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.SECOND,100);//20秒
        String token = JWT.create()
                .withHeader(map)  //头部
                .withClaim("username", "张三")  //payload
                .withClaim("birth",new Date())
                .withExpiresAt(calendar.getTime())  //过期时间
                .sign(Algorithm.HMAC256("mdcoijheri"));//签名 mdcoijheri是密钥

        System.out.println(token);
        //创建验证器对象
        JWTVerifier verifier = JWT.require(Algorithm.HMAC256("mdcoijheri")).build();
        DecodedJWT verify = verifier.verify(token);//对token进行验证
        System.out.println(verify.getClaim("username").asString());//获取payload里面的声明(用户信息)
        System.out.println(verify.getClaim("birth").asDate());
    }

5、整合SpringBoot

5.1 搭建环境

创建一个SpringBoot项目，导入以下依赖：

    <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.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>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.4.7</version>
        </dependency>
    </dependencies>

接着，打开mysql，创建user表

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(11) NOT NULL,
  `login_id` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `pwd` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `age` int(11) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

5.2 整合JWT

三层的创建，简单做个登录功能就行了，这里只贴service层和controller

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

    @Override
    public User login(User user) {
        if (ObjectUtil.isNotEmpty(user)){
            QueryWrapper<User> wrapper = new QueryWrapper<>();
            wrapper.setEntity(user);
            User u = userMapper.selectOne(wrapper);
            if (ObjectUtil.isNotEmpty(u)){
                return u;
            }else {
                return null;
            }
        }
        return null;
    }
}

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

    @GetMapping("/user/login")
    public Map<String,String> login(User user){
        User u = userService.login(user);
        HashMap<String,String> map = new HashMap<>();
        if (ObjectUtil.isNotEmpty(u)){
            String token = JWTUtil.getToken(u);
            map.put("1","认证成功");
            map.put("token",token);
        }else {
            map.put("0","认证失败");
        }
        return map;
    }

    @GetMapping("/user/test")
    public void test(){
        System.out.println("哈哈哈");
    }
}

这里有一个JWTUtil工具类

public class JWTUtil {

    private static final String secret = "aksioahvyrg";

    public static String getToken(User user) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.SECOND,100);
        JWTCreator.Builder builder = JWT.create();
        String token = builder.withClaim("name", user.getName())
                .withClaim("age", user.getAge())
                .withExpiresAt(calendar.getTime())
                .sign(Algorithm.HMAC256(secret));
        return token;
    }

    public static void verify(String token){
        JWTVerifier verifier = JWT.require(Algorithm.HMAC256(secret)).build();
        verifier.verify(token);
    }

}

我们通常在拦截器中校验token，这样可以更好的保护我们的接口，并且可以减少代码冗余

public class JWTInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //从header中获取token
        String token = request.getHeader("token");
        //验证token
        HashMap<String,String> map = new HashMap<>();
        try {
            JWTUtil.verify(token);
            return true;//放行
        }catch (SignatureVerificationException e){
            e.printStackTrace();
            map.put("error_1","无效签名");
        }catch (TokenExpiredException e){
            e.printStackTrace();
            map.put("error_2","token已过期");
        }catch (AlgorithmMismatchException e){
            e.printStackTrace();
            map.put("error_3","token算法不匹配");
        }catch (Exception e){
            e.printStackTrace();
            map.put("error_4","token无效");
        }
        //将map 转为json
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}

创建InterceptorConfig配置类配置拦截器

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("/user/test")
                .excludePathPatterns("/user/login");//排除
    }
}

5.3 测试

首先不登录，直接访问:http://localhost:8888/user/test
然后先登录获取token:http://localhost:8888/user/login?loginId=xxx&pwd=xxx
接着复制token到header中，访问test:http://localhost:8888/user/test

吉吉冕下

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
JWT的基本使用

1、什么是JWT官网介绍JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally sig
复制链接

扫一扫