JWT

这里写目录标题

JWT
一级目录
- 二级目录
- - 三级目录
  - 1.什么是JWT
- 2.JWT的组成部分
- 3.编码/解码
- 4.特点
- 5. 为什么使用JWT
- - 5.1传统的验证方式
- 5.2基于JWT的验证方式
- 6.JWT进行登录验证
- - 6.1依赖安装
  - 6.2编写UserDetailServiceImpl类
  - 6.3编写UserDetailsImpl类
  - 6.4 实现config.SecurityConfig类
  - 6.5实现utils.JwtUtil类
  - 6.6实现config.filter.JwtAuthenticationTokenFilter类
  - 6.7配置config.SecurityConfig类
- 7.常见的面试题

一级目录

二级目录

三级目录

1.什么是JWT

全称 JSON Web Token，简称JWT,是一个基于RFC7519的爱看i发数据标准，定义了一种宽松且紧凑的数据组合方式
是一种加密后的数据载体，可在各应用之间进行数据传输
最常应用于授权认证，一旦用户登录，每个请求都将包含JWT，系统每次处理用户请求都会及逆行JWT安全检验，通过之后在进行处理

2.JWT的组成部分

JWT由3部分组成，使用.拼接

Header
- 声明类型，默认JWT
- 声明加密算法，HMAC,RSA,ECDSA等常用算法
```
{
"alg": "HS256",
"typ": "JWT"
}
```
- alg:表示签名的算法，默认HMAC SHA256（写成HS256）
- type：表示声明类型，默认JWT
使用Base64编码后构成JWT,的第一部分
```
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
```

Payload

存放有效信息的地方

标准载荷

建议但不强制使用

标准载荷介绍
iss (issuer) 签发人（谁签发的）
exp (expiration time) 过期时间，必须要大于签发时间
sub (subject) 主题（用来做什么）
aud (audience) 受众(给谁用的)比如：http://www.xxx.com
nbf (Not Before) 生效时间
iat (Issued At) 签发时间
jti (JWT ID) 编号，JWT 的唯一身份标识

标准载荷	介绍
iss (issuer)	签发人（谁签发的）
exp (expiration time)	过期时间，必须要大于签发时间
sub (subject)	主题（用来做什么）
aud (audience)	受众(给谁用的)比如：http://www.xxx.com
nbf (Not Before)	生效时间
iat (Issued At)	签发时间
jti (JWT ID)	编号，JWT 的唯一身份标识

自定义载荷

可以添加任何信息，一般添加用户的相关信息或业务所需要的必要信息。但不建议添加敏感信息

{
 //第一部分用户信息
 "user_info": [
   {
     "id": "1"//id
   },
   {
     "name": "dafei"//姓名
   },
   {
     "age": "18"//年龄
   }
 ],
 "iat": 1681571257,//签发时间
 "exp": 1682783999,//过期时间
 "aud": "xiaofei",//受众
 "iss": "dafei",//签发人
 "sub": "alluser"//主题
}

使用Base64编码后构成了第二部分

eyJ1c2VyX2luZm8iOlt7ImlkIjoiMSJ9LHsibmFtZSI6ImRhZmVpIn0seyJhZ2UiOiIxOCJ9XSwiaWF0IjoxNjgxNTcxMjU3LCJleHAiOjE2ODI3ODM5OTksImF1ZCI6InhpYW9mZWkiLCJpc3MiOiJkYWZlaSIsInN1YiI6ImFsbHVzZXIifQ

signature
- 私钥：只有服务器才知道
- 公钥：按照以下算法产生
```
signature = HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)
```
用Base64编码，构成第三部分

将三部分拼接成一个字符串，便是jwt了

由于密钥的存在，即使调用方修改了前两部分内容，在验证不放呢会出现签名不一致的情况，保证了全性

3.编码/解码

编码工具

https://tooltt.com/jwt-encode/

解码工具

https://tool.box3.cn/jwt.html

4.特点

优点

无状态

JWT 不需要在服务端存储任何状态，客户端可以携带 JWT 来访问服务端，从而使服务端变得无状态。这样，服务端就可以更轻松地实现扩展和负载均衡。
自定义

JWT 的载荷部分可以自定义，可以存储任何 JSON 格式的数据。这意味着我们可以使用 JWT 来实现一些自定义的功能，例如存储用户喜好、配置信息等等。
扩展性强

JWT 有一套标准规范，因此很容易在不同平台和语言之间共享和解析。此外，开发人员可以根据需要自定义声明（claims）来实现更加灵活的功能。
调试性好

由于 JWT 的内容是以 Base64 编码后的字符串形式存在的，因此非常容易进行调试和分析。

缺点

安全性取决于密钥管理

JWT 的安全性取决于密钥的管理。如果密钥被泄露或者被不当管理，那么 JWT 将会受到攻击。因此，在使用 JWT 时，一定要注意密钥的管理，包括生成、存储、更新、分发等等。
无法撤销

由于 JWT 是无状态的，一旦 JWT 被签发，就无法撤销。如果用户在使用 JWT 认证期间被注销或禁用，那么服务端就无法阻止该用户继续使用之前签发的 JWT。因此，开发人员需要设计额外的机制来撤销 JWT，例如使用黑名单或者设置短期有效期等等。
需要缓存到客户端

由于 JWT 包含了用户信息和授权信息，一般需要客户端缓存，这意味着 JWT 有被窃取的风险。
载荷大小有限制

由于 JWT 需要传输到客户端，因此载荷大小也有限制。一般不建议载荷超过 1KB，会影响性能。

5. 为什么使用JWT

5.1传统的验证方式

传统的认证方式，是基于Session的认证

Cookie和Session

Cookie：一种让程序员在本地存储数据的能力，让数据在客户端这边更持久化
Cookie里面存的是键值对的格式数据，键值对用“；”分割，键和值之间用“，”分割

登录的认证

Session

session是在服务器的一种机制，因为cookie是客户端保存的数据，而这些数据又是跟用户强烈相关联的，显然保存在客户端这边就不太合适（太多，也占资源），所以把数据都保存在服务器这边就比较的合适；保存的方式就是通过session的方式来进行保存的。键值对结构
使用之后,客户端只需要保存 sessionId就可以了，后续的请求带上 sessionId，服务器就会根据 sessionId 就会找到对应的用户数据详细的信息。

认证流程

客户端：发起一个认证请求
服务器端：认证通过存储一个session的用户信息；把sessionid写入客户端cookie
客户端再次访问：自动携带sessionid，找到对应session

问题分析

通常来说session保存在服务器的内存中，随着认证用户增多，会加大服务器的开销
因为session保存在服务器内存中，所以对于分布式应用来说，限制了应用的扩展能力
cookie被截取，会容易受造跨站请求伪造攻击
在前后端分离的系统中更加痛苦，比如后端是集群分布，需要设计共享机制、

5.2基于JWT的验证方式

客户端：发起一个请求认证，带有用户名，密码
服务器：认证通过，生成JWT，响应给客户端
客户端：将Token保存到本地

日后客户端再次认证

客户端：携带JWT发送给服务器
服务器：进行验证，通过，展示数据；否则返回错误信息

6.JWT进行登录验证

6.1依赖安装

spring-boot-starter-security
jjwt-api
jjwt-impl
jjwt-jackson

meaven仓库地址：Maven Repository: Search/Browse/Explore (mvnrepository.com)

6.2编写UserDetailServiceImpl类

继承UserDetailsService接口
作用：接入数据库信息，主要是用来根据用户名查找用户

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("username",username);
        User user=userMapper.selectOne(queryWrapper);
        if(user==null){
            throw new RuntimeException("用户不存在");
        }
        return new UserDetailsImpl(user);
    }
}

6.3编写UserDetailsImpl类

使用户的一个接口类，用来判断用户的密码，权限是否失效，过期。

package com.kob.backend.service.impl.utils;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;
import  com.kob.backend.pojo.User;

@Data
@AllArgsConstructor
@NoArgsConstructor

public class UserDetailsImpl implements UserDetails {
    private User user;
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return null;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

6.4 实现config.SecurityConfig类

用来实现用户密码的加密存储

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

6.5实现utils.JwtUtil类

是jwt工具类的一种
作用：用来创建，解析jwt token

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.UUID;

@Component
public class JwtUtil {
    public static final long JWT_TTL = 60 * 60 * 1000L * 24 * 14;  // 有效期14天
    public static final String JWT_KEY = "SDFGjhdsfalshdfHFdsjkdsfds121232131afasdfac";

    public static String getUUID() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }

    public static String createJWT(String subject) {
        JwtBuilder builder = getJwtBuilder(subject, null, getUUID());
        return builder.compact();
    }

    private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        SecretKey secretKey = generalKey();
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        if (ttlMillis == null) {
            ttlMillis = JwtUtil.JWT_TTL;
        }

        long expMillis = nowMillis + ttlMillis;
        Date expDate = new Date(expMillis);
        return Jwts.builder()
                .setId(uuid)
                .setSubject(subject)
                .setIssuer("sg")
                .setIssuedAt(now)
                .signWith(signatureAlgorithm, secretKey)
                .setExpiration(expDate);
    }

    public static SecretKey generalKey() {
        byte[] encodeKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        return new SecretKeySpec(encodeKey, 0, encodeKey.length, "HmacSHA256");
    }

    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parserBuilder()
                .setSigningKey(secretKey)
                .build()
                .parseClaimsJws(jwt)
                .getBody();
    }
}

6.6实现config.filter.JwtAuthenticationTokenFilter类

进行jwt token的验证，如果成功，将用户信息注入上下文中

import com.kob.backend.mapper.UserMapper;
import com.kob.backend.pojo.User;
import com.kob.backend.service.impl.utils.UserDetailsImpl;
import com.kob.backend.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    @Autowired
    private UserMapper userMapper;

    @Override
    protected void doFilterInternal(HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull FilterChain filterChain) throws ServletException, IOException {
        String token = request.getHeader("Authorization");

        if (!StringUtils.hasText(token) || !token.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return;
        }

        token = token.substring(7);

        String userid;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userid = claims.getSubject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        User user = userMapper.selectById(Integer.parseInt(userid));

        if (user == null) {
            throw new RuntimeException("用户名未登录");
        }

        UserDetailsImpl loginUser = new UserDetailsImpl(user);
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginUser, null, null);

        SecurityContextHolder.getContext().setAuthentication(authenticationToken);

        filterChain.doFilter(request, response);
    }
}

6.7配置config.SecurityConfig类

放行登录，注册页面

import com.kob.backend.config.filter.JwtAuthenticationTokenFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
            //在这里方形的登录注册页面，填写访问地址
                .antMatchers("/user/account/token/", "/user/account/register/").permitAll()
                .antMatchers(HttpMethod.OPTIONS).permitAll()
                .anyRequest().authenticated();

        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }
}