【SpringSecurity】SpringSecurity安全框架认证流程

最新推荐文章于 2025-03-07 17:34:44 发布

一二¬

最新推荐文章于 2025-03-07 17:34:44 发布

阅读量1.1k

点赞数 32

分类专栏： # 框架文章标签： SpringSecurity 安全框架 java

本文链接：https://blog.youkuaiyun.com/m0_66584716/article/details/145135769

版权

框架专栏收录该内容

19 篇文章

订阅专栏

文章目录

SpringSecurity安全框架
- 认证流程

SpringSecurity安全框架

认证流程

通常情况下，用户通过提交用户名和密码来进行认证。 UsernamePasswordAuthenticationFilter 过滤器会捕获这些信息。如果用户已经通过认证，请求会继续传递到下一个过滤器。

在这里插入图片描述

原理及准备工作

提交用户名和密码：用户通过客户端（如浏览器）提交用户名和密码。
过滤器拦截：Spring Security的UsernamePasswordAuthenticationFilter会拦截这些凭证。
创建认证对象Authentication：过滤器内部创建一个未授权的Authentication对象，其中包含了用户名和密码等信息。
ProviderManager调用DaoAuthenticationProvider进行身份验证：
- 使用authenticate方法开始身份验证过程。
DaoAuthenticationProvider加载 UserDetails：
- 调用loadUserByUsername来获取用户信息。
- 通过UserDetailsService实现类（例如InMemoryUserDetailsManager）查询数据库或内存中的用户数据。
返回UserDetails对象：从服务中获取到包含用户权限信息的UserDetails对象。
密码校验：通过PasswordEncoder比较输入的密码与存储的密码是否一致。+
设置授权信息：如果密码正确，将权限信息设置到Authentication对象中。
返回Authentication对象：经过身份验证后，返回已授权的Authentication对象。
保存Authentication对象：最后将这个对象保存在安全上下文（SecurityContext）中以供后续请求使用。

引入依赖

<dependencies>
    <!-- redis依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- fastjson依赖 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.33</version>
    </dependency>
    <!-- jwt依赖：生成token -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.0</version>
    </dependency>
    <!-- security依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <!-- Mybatis-Plus包 -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.1</version>
    </dependency>
    <!-- MySQL驱动包 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- lombok包 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

yml 配置

# 数据库连接
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/hz_test?useUnicode=true&characterEncoding=UTF-8&useSSL=false
    username: root
    password: root
mybatis-plus:
  type-aliases-package: com.hz.pojo #类型别名所在的包
  #控制台打印sql语句
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true # 驼峰映射

启动类扫包

@SpringBootApplication
@MapperScan("com.hz.dao")
public class Springsecurity02Application {
    public static void main(String[] args) {
        SpringApplication.run(Springsecurity02Application.class, args);
    }
}

项目结构如下

在这里插入图片描述

FastJsonRedisSerializer：Redis 使用 FastJson 序列化

/**
 * Redis 使用 FastJson 序列化
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    private Class<T> clazz;
    static {ParserConfig.getGlobalInstance().setAutoTypeSupport(true);}
    public FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }
    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {return new byte[0];}
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {return null;}
        String str = new String(bytes, DEFAULT_CHARSET);
        return JSON.parseObject(str, clazz);
    }
    protected JavaType getJavaType(Class<?> clazz){
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

RedisConfig：Redis 工具类

@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}

ResultJSON：结果返回类

@Data
@AllArgsConstructor
@ToString
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
public class ResultJSON<T> {
    private Integer code;
    private String msg;
    private Long count;
    private T data;
    public ResultJSON(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
    public static ResultJSON successLayui(Long count, Object data){
        return  new ResultJSON(0,"操作成功",count,data);
    }
    public static ResultJSON successOrError(boolean bool){
        if (bool) {
            return  ResultJSON.success();
        } else {
            return  ResultJSON.error();
        }
    }
    public static ResultJSON success(){
        return  new ResultJSON(0,"操作成功",null);
    }
    public static ResultJSON success(Integer code, String msg){
        return  new ResultJSON(code,msg,null);
    }
    public static <R> ResultJSON success(R data){
        return  new ResultJSON(0,"操作成功",data);
    }
    public static ResultJSON error(){
        return  new ResultJSON(1,"操作失败",null);
    }
    public static ResultJSON error(Integer code,String msg){
        return  new ResultJSON(code,msg,null);
    }
    public static ResultJSON error(String msg){
        return  new ResultJSON(1,msg,null);
    }
}

JwtUti：JWT 工具类

/**
 * JWT 工具类
 */
public class JwtUtil {
    // 有效期
    public static final Long JWT_TTL = 60*60*1000L;// 60 * 60 *1000  一个小时
    // 设置秘钥明文 盐 对称加密
    public static final String JWT_KEY = "hongzhuo";
    public static String getUUID(){
        String token = UUID.randomUUID().toString().replaceAll("-", "");
        return token;
    }
    /**
     * 生成jtw
     * @param subject token中要存放的数据（json格式）
     * @return
     */
    public static String createJWT(String subject) {
        JwtBuilder builder = getJwtBuilder(subject, JWT_TTL, getUUID());// 设置过期时间
        return builder.compact();
    }
    /**
     * 生成jtw
     * @param subject token中要存放的数据（json格式）
     * @param ttlMillis token超时时间
     * @return
     */
    public static String createJWT(String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, 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)              //唯一的ID
                .setSubject(subject)   // 主题  可以是JSON数据
                .setIssuer("wzy")     // 签发者
                .setIssuedAt(now)      // 签发时间
                .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
                .setExpiration(expDate);
    }

    /**
     * 创建token
     * @param id
     * @param subject
     * @param ttlMillis
     * @return
     */
    public static String createJWT(String id, String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
        return builder.compact();
    }
    
    /**
     * 生成加密后的秘钥 secretKey
     * @return
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }

    /**
     * 解析
     * @param jwt
     * @return
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

public static void main(String[] args) throws Exception {
    String jwt = createJWT("1");
    // System.out.println(jwt);
    // 解析 token
    Claims claims = parseJWT(jwt);
    // System.out.println(claims.getSubject());
}

RedisCache：Redis 缓存

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache {
    @Autowired
    public RedisTemplate redisTemplate;
    /**
     * 缓存基本的对象，Integer、String、实体类等
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }
    /**
     * 缓存基本的对象，Integer、String、实体类等
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
    /**
     * 设置有效时间
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }
    /**
     * 设置有效时间
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }
    /**
     * 获得缓存的基本对象。
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }
    /**
     * 删除单个对象
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }
    /**
     * 删除集合对象
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }
    /**
     * 缓存List数据
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }
    /**
     * 获得缓存的list对象
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }
    /**
     * 缓存Set
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {setOperation.add(it.next());}
        return setOperation;
    }
    /**
     * 获得缓存的set
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }
    /**
     * 缓存Map
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }
    /**
     * 获得缓存的Map
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }
    /**
     * 往Hash中存入数据
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }
    /**
     * 获取Hash中的数据
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }
    /**
     * 删除Hash中的数据
     * @param key
     * @param hkey
     */
    public void delCacheMapValue(final String key, final String hkey) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hkey);
    }
    /**
     * 获取多个Hash中的数据
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }
    /**
     * 获得缓存的基本对象列表
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }
}

WebUtils：Web工具类

public class WebUtils {
    /**
     * 将字符串渲染到客户端
     * @param response 渲染对象
     * @param string 待渲染的字符串
     * @return null
     */
    public static String renderString(HttpServletResponse response, String string) {
        try {
            response.setStatus(200);
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            PrintWriter out = response.getWriter();
            out.print(string);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

核心逻辑

建表

CREATE TABLE `sys_user` (
`id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
`nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
`password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
`status` CHAR(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
`email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱',
`phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号',
`sex` CHAR(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
`avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像',
`user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
`create_by` BIGINT(20) DEFAULT NULL COMMENT '创建人的用户id',
`create_time` DATETIME DEFAULT NULL COMMENT '创建时间',
`update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人',
`update_time` DATETIME DEFAULT NULL COMMENT '更新时间',
`del_flag` INT(11) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表'

创建实体类和数据持久层

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "sys_user")
public class SysUser implements Serializable {
    @TableId(value = "id", type = IdType.AUTO)
    private Long id; // 主键
    private String userName; // 用户名
    private String nickName; // 昵称
    private String password; // 密码
    private String status; // 状态（0正常 1停用）
    private String email; // 邮箱
    private String phonenumber; // 手机号
    private String sex; // 性别（0男，1女，2未知）
    private String avatar; // 头像
    private String userType; // 用户类型（0管理员，1普通用户）
    private Long createBy; // 创建人
    private String createTime; // 创建时间
    private Long updateBy; // 更新人
    private String updateTime; // 更新时间
    private Integer delFlag; // 删除标志（0代表未删除，1代表已删除）
}

public interface SysUserDao extends BaseMapper<SysUser> {
}

核心代码实现

创建一个类实现 UserDetailsService 接口，重写其中的方法。更加用户名从数据库中查询用户信息。

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Resource
    private SysUserDao sysUserDao;
    @Override
    public UserDetails loadUserByUsername(String username)
            throws UsernameNotFoundException {
        // 根据用户名查询用户信息
        SysUser sysUser = sysUserDao.selectOne(new QueryWrapper<SysUser>()
                .eq("user_name", username));
        if (Objects.isNull(sysUser)) {
            throw new RuntimeException("用户名或密码错误");
        }
        // 返回用户信息
        return new LoginUser(sysUser);
    }
}

因为 UserDetailsService 方法的返回值是 UserDetails 类型，所以需要定义一个类，实现该接口，把用户信息封装在其中。security 登录对象：

/**
 * @Description: security 登录对象
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {
    private SysUser sysUser;
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }
    @Override
    public String getPassword() {
        return sysUser.getPassword();
    }
    @Override
    public String getUsername() {
        return sysUser.getUserName();
    }
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    @Override
    public boolean isEnabled() {
        return true;
    }
}

编写 controller 测试，随便写一个接口（如果要测试，需要往用户表中写入用户数据，若让用户的密码是明文存储，需要在密码前加 {noop}）

@RestController
@RequestMapping("/index")
public class IndexController {
    @RequestMapping("/info")
    public ResultJSON index() {
        return ResultJSON.success();
    }
}

进入我们的接口测试：http://localhost:8080/index/info

输入账号 / 密码：admin / 123456

成功返回 ResultJSON，登录认证成功。

在这里插入图片描述

但是实际项目中我们不会把密码明文存储在数据库中。

密码加密存储

默认使用的 PasswordEncoder 要求数据库中的密码格式为：{id}password 。它会根据 id 去判断密码的加密方式。但是我们一般不会采用这种方式。所以需替换 SpringSecurity 为我们提供的 BCryptPasswordEncoder。把 BCryptPasswordEncoder 对象注入Spring容器中，SpringSecurity 就会使用该 PasswordEncoder 来进行密码校验。

定义一个 SpringSecurity 的配置类，SpringSecurity 要求这个配置类要继承 WebSecurityConfigurerAdapter。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    public static void main(String[] args) {
        System.out.println(new BCryptPasswordEncoder().encode("123456"));
    }
}

运行 main 方法获得加密后的密码

$2a $10$ ct/RaYQseHK6QhIPMEmIhedQqiz9tQxVmBkZK65jiJZ5yH/uwHtTK

将这串密码写入数据库，再次测试，亦成功返回 ResultJSON。

登录接口

自定义登录接口，让 SpringSecurity 对这个接口放行，让用户访问这个接口的时候不用登录也能访问。

在接口中我们通过 AuthenticationManager 的 authenticate 方法来进行用户认证，所以需要在 SecurityConfig 中配置把 AuthenticationManager 注入容器。

认证成功要生成一个 jwt，放入响应中返回。并且为了让用户下次请求时能通过 jwt 识别出具体的用户，因此需要把用户信息存入 redis，把用户 id 作为 key。

@RestController
@RequestMapping("/user")
public class SysUserController {
    @Resource
    private SysUserService sysUserService;
    @PostMapping("/login")
    public ResultJSON login(@RequestBody SysUser sysUser) {
        return sysUserService.login(sysUser);
    }
}

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //关闭csrf
        http.csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问
                .antMatchers("/user/login").anonymous()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
    }
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserDao, SysUser>
        implements SysUserService {
    @Resource
    private RedisCache redisCache;
    @Resource
    private AuthenticationManager authenticationManager;
    @Override
    public ResultJSON login(SysUser sysUser) {
        // 判断登录是否成功
        UsernamePasswordAuthenticationToken authenticationToken = new
                UsernamePasswordAuthenticationToken(sysUser.getUserName(),sysUser.getPassword());
        Authentication authenticate =
                authenticationManager.authenticate(authenticationToken);
        if(Objects.isNull(authenticate)){
            throw new RuntimeException("用户名或密码错误");
        }
        //使用userid生成token
        LoginUser user = (LoginUser) authenticate.getPrincipal(); // 获取登录对象
        Long userId = user.getSysUser().getId();
        String token = JwtUtil.createJWT(userId.toString());
        //存储redis
        redisCache.setCacheObject("login:"+userId, user, 1, TimeUnit.HOURS);
        return ResultJSON.success(token);
    }
}

认证过滤器

token 校验过滤器

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    @Resource
    private RedisCache redisCache;
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token
        String token = request.getHeader("token");
        if (!StringUtils.hasText(token)) {
            //放行
            filterChain.doFilter(request, response);
            return;
        }
        //解析token
        String userid;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userid = claims.getSubject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("token非法,解析失败");
        }
        //从redis中获取用户信息
        LoginUser loginUser = redisCache.getCacheObject("login:" + userid);
        if(Objects.isNull(loginUser)){
            throw new RuntimeException("用户未登录");
        }
        //存入SecurityContextHolder
        //TODO 获取权限信息封装到Authentication中
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginUser,null,null);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        //放行
        filterChain.doFilter(request, response);
    }
}

把 token 校验过滤器添加到过滤器链中

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    // ......
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 关闭csrf
        // ......
        // 把 token 校验过滤器添加到过滤器链中
        http.addFilterBefore(jwtAuthenticationTokenFilter,
                UsernamePasswordAuthenticationFilter.class);
    }
    // ......
}

退出登录

@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserDao, SysUser>
        implements SysUserService {
    @Resource
    private RedisCache redisCache;
    @Resource
    private AuthenticationManager authenticationManager;
    @Override
    public ResultJSON login(SysUser sysUser) {
        // 登录......
    }
    @Override
    public ResultJSON logout() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        Long userid = loginUser.getSysUser().getId();
        redisCache.deleteObject("login:"+userid);
        return ResultJSON.success(200,"退出成功");
    }
}

@RestController
@RequestMapping("/user")
public class SysUserController {
    @Resource
    private SysUserService sysUserService;
    
    @GetMapping("/logout")
    public ResultJSON logout() {
        return sysUserService.logout();
    }
}