JWT（JSON Web Tokens）基础概览与应用简介

菀星鋶

已于 2024-09-03 17:50:09 修改

阅读量420

点赞数 15

文章标签： gateway java spring boot

于 2024-09-03 17:48:32 首次发布

本文链接：https://blog.csdn.net/2302_78886445/article/details/141867657

版权

1.什么是 JWT

在介绍JWT之前，我们先来回顾一下利用token进行用户身份验证的流程：

客户端使用用户名和密码请求登录
服务端收到请求，验证用户名和密码
验证成功后，服务端会签发一个token，再把这个token返回给客户端
客户端收到token后可以把它存储起来，比如放到cookie中
客户端每次向服务端请求资源时需要携带服务端签发的token，可以在cookie或者header中携带
服务端收到请求，然后去验证客户端请求里面带着的token，如果验证成功，就向客户端返回请求数据

这种基于token的认证方式相比传统的session认证方式更节约服务器资源，并且对移动端和分布式更加友好。其优点如下：

支持跨域访问：cookie是无法跨域的，而token由于没有用到cookie(前提是将token放到请求头中)，所以跨域后不会存在信息丢失问题

无状态：token机制在服务端不需要存储session信息，因为token自身包含了所有登录用户的信息，所以可以减轻服务端压力

更适用CDN：可以通过内容分发网络请求服务端的所有资料

更适用于移动端：当客户端是非浏览器平台时，cookie是不被支持的，此时采用token认证方式会简单很多

无需考虑CSRF：由于不再依赖cookie，所以采用token认证方式不会发生CSRF，所以也就无需考虑CSRF的防御

而JWT就是上述流程当中token的一种具体实现方式，其全称是JSON Web Token

官网地址：JSON Web Tokens - jwt.io

通俗地说，JWT的本质就是一个字符串，它是将用户信息保存到一个Json字符串中，然后进行编码后得到一个JWT token，并且这个JWT token带有签名信息，接收后可以校验是否被篡改，所以可以用于在各方之间安全地将信息作为Json对象传输。JWT的认证流程如下：

首先，前端通过Web表单将自己的用户名和密码发送到后端的接口，这个过程一般是一个POST请求。建议的方式是通过SSL加密的传输(HTTPS)，从而避免敏感信息被嗅探
后端核对用户名和密码成功后，将包含用户信息的数据作为JWT的Payload，将其与JWT Header分别进行Base64编码拼接后签名，形成一个JWT Token，形成的JWT Token就是一个如同lll.zzz.xxx的字符串
后端将JWT Token字符串作为登录成功的结果返回给前端。前端可以将返回的结果保存在浏览器中，退出登录时删除保存的JWT Token即可
前端在每次请求时将JWT Token放入HTTP请求头中的Authorization属性中(解决XSS和XSRF问题)
后端检查前端传过来的JWT Token，验证其有效性，比如检查签名是否正确、是否过期、token的接收方是否是自己等等
验证通过后，后端解析出JWT Token中包含的用户信息，进行其他逻辑操作(一般是根据用户信息得到权限等)，返回结果

2.为什么要用JWT

2.1 传统Session认证的弊端

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

然而，传统的session认证有如下的问题 :

每个用户的登录信息都会保存到服务器的session中，随着用户的增多，服务器开销会明显增大

由于session是存在服务器的物理内存中，所以在分布式系统中，这种方式将会失效。虽然可以将session统一保存到Redis中，但是这样做无疑增加了系统的复杂性，对于不需要redis的应用也会白白多引入一个缓存中间件

对于非浏览器的客户端、手机移动端等不适用，因为session依赖于cookie，而移动端经常没有cookie

因为session认证本质基于cookie，所以如果cookie被截获，用户很容易收到跨站请求伪造攻击。并且如果浏览器禁用了cookie，这种方式也会失效

前后端分离系统中更加不适用，后端部署复杂，前端发送的请求往往经过多个中间件到达后端，cookie中关于session的信息会转发多次

由于基于Cookie，而cookie无法跨域，所以session的认证也无法跨域，对单点登录不适用

2.2 JWT认证的优势

对比传统的session认证方式，JWT的优势是：

简洁：JWT Token数据量小，传输速度也很快

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

不需要在服务端保存会话信息，也就是说不依赖于cookie和session，所以没有了传统session认证的弊端，特别适用于分布式微服务

单点登录友好：使用Session进行身份认证的话，由于cookie无法跨域，难以实现单点登录。但是，使用token进行认证的话， token可以被保存在客户端的任意位置的内存中，不一定是cookie，所以不依赖cookie，不会存在这些问题

适合移动端应用：使用Session进行身份认证的话，需要保存一份信息在服务器端，而且这种方式会依赖到Cookie（需要 Cookie 保存 SessionId），所以不适合移动端

因为这些优势，目前无论单体应用还是分布式应用，都更加推荐用JWT token的方式进行用户认证

JWT结构 token

JWT由3部分组成：标头(Header)、有效载荷(Payload) 和签名(Signature)。在传输的时候，会将JWT的3部分分别进行Base64编码后用.进行连接形成最终传输的字符串

JWTString=Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)

1.Header

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

{

"alg": "HS256",

"typ": "JWT"

}

2.Payload

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

iss：发行人

exp：到期时间

sub：主题

aud：用户

nbf：在此之前不可用

iat：发布时间

jti：JWT ID用于标识该JWT

这些预定义的字段并不要求强制使用。除以上默认字段外，我们还可以自定义私有字段，一般会把包含用户信息的数据放到payload中，如下例：

{

"sub": "1234567890",

"name": "Helen",

"admin": true

}

请注意，默认情况下JWT是未加密的，因为只是采用base64算法，拿到JWT字符串后可以转换回原本的JSON数据，任何人都可以解读其内容，因此不要构建隐私信息字段，比如用户的密码一定不能保存到JWT中，以防止信息泄露。JWT只是适合在网络中传输一些非敏感的信息。

3.Signature

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

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

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

注意JWT每部分的作用，在服务端接收到客户端发送过来的JWT token之后：

header和payload可以直接利用base64解码出原文，从header中获取哈希签名的算法，从payload中获取有效数据

signature由于使用了不可逆的加密算法，无法解码出原文，它的作用是校验token有没有被篡改。服务端获取header中的加密算法之后，利用该算法加上secretKey对header、payload进行加密，比对加密后的数据和客户端发送过来的是否一致。注意secretKey只能保存在服务端，而且对于不同的加密算法其含义有所不同，一般对于MD5类型的摘要加密算法，secretKey实际上代表的是盐值

JWT的使用

1.创建用户表：

CREATE TABLE `tb_user` (

`id` int(11) NOT NULL AUTO_INCREMENT,

`username` varchar(255) DEFAULT NULL,

`password` varchar(255) DEFAULT NULL,

PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;

2.common编写用户实体类

@Data

public class User {

    /**

     * 主键

     */

    private Integer id;

    /**

     * 用户名

     */

    private String username;

    /**

     * 密码

     */

    private String password;

    

}

修改系统微服务配置文件

server:

  port: 10068

spring:

  application:

    name: bawei-system

  datasource:

    url: jdbc:mysql://127.0.0.1:3306/blue?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC

    username: root

    password: root

    driver-class-name: com.mysql.cj.jdbc.Driver

  rabbitmq:

    listener:

      #如果手动声明listener类型，可在config声明时设置

      direct:

        acknowledge-mode: MANUAL

      simple:

        acknowledge-mode: MANUAL

    host: 127.0.0.1

#eureka注册中心地址

eureka:

  instance:

    # 微服务实例IP地址

    instance-id: 127.0.0.1:${server.port}

    # 使用IP进行访问

    prefer-ip-address: true

  client:

    service-url:

      defaultZone: http://localhost:10086/eureka/

# type-aliases-package批量设置别名作用：就是在mapper.xml文件中直接写类名，不配置就需要写类的全路径名

mybatis:

  type-aliases-package: com.bawei.common.domain

  mapper-locations: classpath:mapper/*.xml

  configuration:

    map-underscore-to-camel-case: true

# 将mapper接口所在包的日志级别改成debug，可以在控制台打印sql

logging:

  level:

    com.bawei.**: debug

用户控制层

@RestController

@RequestMapping("/user")

public class UserController {

    @Autowired

    private UserService userService;

    @GetMapping("/{username}")

    public Result<User> findOneUserByUsername(@PathVariable String username) {

        User user = userService.findOneUserByUsername(username);

        return Result.success(user);

    }

}

用户业务层

@Service

public class UserServiceImpl implements UserService {

    @Autowired

    private UserMapper userMapper;

    @Override

    public User findOneUserByUsername(String username) {

        return userMapper.findOneUserByUsername(username);

    }

}

用户持久层

@Mapper

@Repository

public interface UserMapper {

    User findOneUserByUsername(String username);

}

鉴权微服务 - UserFeign

@FeignClient(name = "bawei-system", path = "/user")

public interface UserFeign {

    @GetMapping("/{username}")

    Result<User> findOneUserByUsername(@PathVariable String username);

}

JwtResponse

@Data

public class JwtResponse {

    /**

     * token

     */

    private String token;

    /**

     * 过期时间

     */

    private String time;

}

AuthController

@RestController

public class AuthController {

    @Autowired

    private UserFeign userFeign;

    @Autowired

    private StringRedisTemplate redisTemplate;

    @Autowired

    private HttpServletRequest request;

    @PostMapping("/login")

    public Result<JwtResponse> login(@RequestBody User user) {

        Result<User> res = userFeign.findOneUserByUsername(user.getUsername());

        User loginUser = res.getData();

        if (loginUser == null) {

            return Result.error("用户名不存在");

        }

        if (!user.getPassword().equals(loginUser.getPassword())) {

            return Result.error("密码错误");

        }

        // 设置 JWT载体

        String userKey = UUID.randomUUID().toString().replace("-", "");

        Map<String, Object> jwtMap = new HashMap<>();

        jwtMap.put(JwtUtils.DETAILS_USER_ID, loginUser.getId());

        jwtMap.put(JwtUtils.USER_KEY, userKey);

        // 生成JWT

        String token = JwtUtils.createToken(jwtMap);

        ValueOperations<String, String> ops = redisTemplate.opsForValue();

        // 将用户信息存入 redis 10分钟 有效期

        ops.set(JwtUtils.LOGIN_TOKEN_KEY + userKey, JSON.toJSONString(loginUser), 10, TimeUnit.MINUTES);

        JwtResponse jwtResponse = new JwtResponse();

        jwtResponse.setToken(token);

        jwtResponse.setTime("10MIN");

        return Result.success(jwtResponse);

    }

    

    /**

    * 获取用户信息

    */

    @GetMapping("/user/info")

    public Result<User> userInfo() {

        // 从请求头中获取token

        String token = request.getHeader(JwtUtils.TOKEN);

        // 获取UserKey

        String userKey = JwtUtils.getUserKey(token);

        // Redis 中获取登录的用户信息

        ValueOperations<String, String> ops = redisTemplate.opsForValue();

        String loginUserJson = ops.get(JwtUtils.LOGIN_TOKEN_KEY + userKey);

        // 反序列化成 用户对象

        if (StringUtils.isEmpty(loginUserJson)) {

            return Result.error("用户名信息不存在");

        }

        User user = JSONObject.parseObject(loginUserJson, User.class);

        return Result.success(user);

    }

}

网关路由鉴权

routes:

  # 鉴权

  - id: bawei-auth

    uri: lb://bawei-auth

    predicates:

      - Path=/auth/**

    filters:

      - StripPrefix=1

网关过滤器

/**

 * 网关过滤器

 */

@Component

@Log4j2

public class AuthFilter implements GlobalFilter, Ordered {

    @Autowired

    private StringRedisTemplate redisTemplate;

    // 网关白名单

    private final List<String> paths = new ArrayList<String>(){{

        add("/auth/login");

    }};

    @Override

    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        log.info("开始进行网关鉴权...");

        long startTime = System.currentTimeMillis();

        // 1: 获取请求头

        ServerHttpRequest request = exchange.getRequest();

        HttpHeaders headers = request.getHeaders();

        // 2: 判断请求是否是 白名单

        String path = request.getURI().getPath();

        if (StringUtils.matches(path, paths)) {

            log.info("网关鉴权效验完成耗时：【{}】毫秒！", System.currentTimeMillis() - startTime);

            return chain.filter(exchange);

        }

        // 3: 验证请求是否携带token

        String token = headers.getFirst(JwtUtils.TOKEN);

        if (StringUtils.isEmpty(token)) {

            log.info("网关鉴权效验完成耗时：【{}】毫秒！", System.currentTimeMillis() - startTime);

            return GatewayUtils.errorResponse(exchange, "请携带token");

        }

        // 4: 验证token是否合法【有效】

        Claims claims = JwtUtils.parseToken(token);

        if (claims == null) {

            log.info("网关鉴权效验完成耗时：【{}】毫秒！", System.currentTimeMillis() - startTime);

            return GatewayUtils.errorResponse(exchange, "token不合法");

        }

        // 5: 验证token是否过期

        String userKey = JwtUtils.getUserKey(token);

        Boolean hasKey = redisTemplate.hasKey(JwtUtils.LOGIN_TOKEN_KEY + userKey);

        if (!hasKey) {

            log.info("网关鉴权效验完成耗时：【{}】毫秒！", System.currentTimeMillis() - startTime);

            return GatewayUtils.errorResponse(exchange, "token已过期");

        }

        log.info("网关鉴权效验完成耗时：【{}】毫秒！", System.currentTimeMillis() - startTime);

        return chain.filter(exchange);

    }

    

    @Override

    public int getOrder() {

        return 0;

    }

}

菀星鋶

关注

15
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
JWT（JSON Web Tokens）基础概览与应用简介

通俗地说，JWT的本质就是一个字符串，它是将用户信息保存到一个Json字符串中，然后进行编码后得到一个JWT token，并且这个JWT token带有签名信息，接收后可以校验是否被篡改，所以可以用于在各方之间安全地将信息作为Json对象传输。默认情况下JWT是未加密的，因为只是采用base64算法，拿到JWT字符串后可以转换回原本的JSON数据，任何人都可以解读其内容，因此不要构建隐私信息字段，比如用户的密码一定不能保存到JWT中。在传输的时候，会将JWT的3部分分别进行Base64编码后用。
复制链接

扫一扫