SpringSecurity6.0+Redis+JWT - 实现用户注册/登录/认证流程

已于 2024-09-12 10:33:15 修改
阅读量1.1k 收藏 15
点赞数 26
分类专栏： Java 文章标签： redis 数据库 缓存 spring boot java mysql
于 2024-09-12 10:18:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y_xianlin/article/details/142167949
版权

前言

本项目Security6登录设计参考CSDN博客(侵删)

SpringSecurity6.0+Redis+JWT+MP基于token认证功能开发（源码级剖析可用于实际生产项目）_springsecurity redis管理token-CSDN博客

因为SpringBoot3与Security6更新后, 部分方法被标为弃用,

经过更改后, 已全部更改为最新用法

  • 代码辅助: ChatGPT-4o/智谱清言GLM-4
  • 使用数据库: Mysql/Redis
  • 使用关键模块: MybatisPlus/java-jwt/lombok
  • 项目基础: SpringBoot3.3.3/Security6

源码地址千寻云/ChatZenBackend

语雀原文 语雀 - Security6 开发文档

接口测试文档 测试Get请求 - 千寻轻语阁(Security-1)

下图为Security默认认证流程, 我们要重写部分方法, 用于实现自己的认证方式

Spring Security原始认证流程

与上图非对应关系

Spring Security的原始认证流程通常涉及以下步骤：

  1. 用户发送登录请求。
  2. 请求被一个认证过滤器（例如 UsernamePasswordAuthenticationFilter）拦截。
  3. 认证过滤器使用 AuthenticationManager 进行认证。
  4. AuthenticationManager 使用 UserDetailsService 加载用户详情。
  5. 密码验证。
  6. 如果认证成功，创建一个认证对象并设置到 SecurityContextHolder。
  7. 用户被重定向到原始请求或登录成功页面。

数据库结构

用户账号密码表

全称t_user_account

create_time 默认为 NOW() 添加时间

create table chat_zen.t_user_account
    (
      id            int unsigned auto_increment
      primary key,
      username      varchar(255)                       not null comment '用户账号-唯一',
      password_hash varchar(255)                       not null comment '用户密码-加密',
      create_time   datetime default CURRENT_TIMESTAMP not null comment '账号创建时间',
      constraint t_user_account_pk_2
      unique (username)
    );

安全配置

yml配置文件

chat-zen:
  security:
    # Security认证白名单
    permit-all-path:
      - /http-test/**
      - /auth/**
  jwt:
    # jwt加密key
    key: chatzen-key
    expiration: 172800000 # 48 hour - *ms

Security配置

  1. 配置类定义：
    • 该类使用了 @Configuration 和 @EnableWebSecurity 注解，表示这是一个Spring Security的配置类。
    • 类中定义了多个 @Bean 方法，用于创建和配置Spring Security的相关组件。
  1. 认证异常处理器：
    • 通过 @Resource 注入了一个 AuthenticationExceptionHandler 对象，用于处理认证过程中的异常。
  1. JWT认证过滤器：
    • 同样通过 @Resource 注入了一个 JWTAuthenticationFilter 对象，这个过滤器用于拦截请求，并验证请求中的JWT令牌。
  1. 权限配置：
    • 通过 security 对象获取了不需要认证的路径（白名单路径），并在 securityFilterChain 方法中配置了这些路径。
    • 配置了其他所有请求都需要认证。
  1. CSRF保护：
    • 关闭了CSRF保护，因为该系统不使用Session，而是使用JWT令牌。
  1. 会话管理：
    • 配置了不通过Session获取SecurityContext，而是使用无状态的会话策略。
  1. 异常处理：
    • 配置了异常处理，当认证过程中出现异常时，会调用 AuthenticationExceptionHandler 进行处理。
  1. 密码编码器：
    • 配置了一个 BCryptPasswordEncoder 作为密码编码器，用于对密码进行哈希处理。
  1. 身份认证管理器：
    • 通过 AuthenticationConfiguration 创建了一个 AuthenticationManager 对象，用于处理身份认证。
// 放行接口
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
  List<String> permitAllPaths = security.getPermitAllPath();
  // 配置不需要认证的请求(这里所有的路径可以写在配置文件上修改时就不用改代码)
  if (!CollectionUtils.isEmpty(permitAllPaths)) {
    permitAllPaths.forEach(path -> {
      try {
        // 放行白名单路径
        http.authorizeHttpRequests(auth -> auth
                                   .requestMatchers(path).permitAll()); // 放行白名单路径
      } catch (Exception e) {
        log.error("放行白名单路径失败", e);
      }
    });
  }
  http    // 关闭csrf保护, 因为无需Session
  .csrf(AbstractHttpConfigurer::disable)
  // 其他所有请求都需要认证
  .authorizeHttpRequests(auth -> auth.anyRequest().authenticated())
  // 不通过Session获取SecurityContext
  .sessionManagement(session -> session
                     .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                    )// 配置异常处理
  .exceptionHandling(exception -> exception
                     .authenticationEntryPoint(authenticationExceptionHandler)
                    );
  // 配置token过滤器
  http.addFilterBefore(tokenFilter, UsernamePasswordAuthenticationFilter.class);
  return http.build();
}

// 配置密码编码器
@Bean
public PasswordEncoder passwordEncoder() {
  return new BCryptPasswordEncoder();
}

/**
 * 身份认证管理器，调用authenticate()方法完成认证
 */
@Bean
public AuthenticationManager authenticationManager
            (AuthenticationConfiguration authenticationConfiguration) throws Exception {
  return authenticationConfiguration.getAuthenticationManager();
}

认证流程

登录接口流程

  1. 客户端发起登录请求：
    • 客户端通过HTTP POST请求发送用户名和密码到服务器的 /auth/login 端点。

  1. 认证端点处理请求 (AuthController.java)：
    • AuthController 的 login 方法接收请求。
    • 方法从请求体中提取用户名和密码。
    • 如果用户名或密码为空，返回错误响应。
@RestController
@RequestMapping("/auth")
public class AuthController {
  @Resource
  private IAuthService authService;

  @PostMapping("/login")
  public Result<String > login(@RequestBody JSONObject params){
    String username  = params.getString("username");
    String password = params.getString("password");
    if (!StringUtils.hasText(username) || !StringUtils.hasText(password)) {
      return Result.fail(500, "用户名或密码为空！",null);
    }
    String token = authService.login(username, password); // 执行登录验证流程
    return Result.succ(token);
  }
}
  1. 执行认证服务 (AuthServiceImpl.java)：
    • login 方法使用提取的用户名和密码创建一个 UsernamePasswordAuthenticationToken。
    • 调用 AuthenticationManager 的 authenticate 方法进行认证。
@Override
public String login(String username, String password) {
  UsernamePasswordAuthenticationToken authenticationToken = 
      new UsernamePasswordAuthenticationToken(username, password);
  // 调用AuthenticationManager的authenticate方法进行认证
  // 该方法会调用UserDetailsService的loadUserByUsername方法进行认证
  Authentication authenticate = 
      authenticationManager.authenticate(authenticationToken);
  // 认证完成后会返回Authentication对象, 该对象中包含了认证成功的用户信息
  // 如果认证失败, 则authenticate方法会抛出AuthenticationException异常
  // 我已经配置了处理异常的类
  if (null == authenticate) {
    log.error("认证失败 {username:{}, password:{}}", username, password);
    return null;
  }
  /**
  认证成功后续流程
  **/
}
  1. 用户详情加载 (UserDetailsServiceImpl.java)：
    • 如果 AuthenticationManager 需要用户详情，它会调用 UserDetailsService 的 loadUserByUsername 方法。
    • UserDetailsServiceImpl 从数据库加载与用户名关联的用户详情。
@Override
public UserDetails loadUserByUsername(String username) 
                                      throws UsernameNotFoundException {
  // 通过MybatisPlus查询用户信息
  QueryWrapper<UserAccount> wrapper = new QueryWrapper<>();
  wrapper.lambda().eq(UserAccount::getUsername, username);
  UserAccount userAccount = userAccountService.getOne(wrapper);
  // 如果用户不存在则抛出异常
  if (userAccount == null) {
    throw new UsernameNotFoundException("用户名不存在");
  }
  // 返回封装UserDetails对象
  return new SecurityUser(userAccount);
}
  1. 密码验证：
    • AuthenticationManager 使用 UserDetailsService 提供的用户详情来验证密码。
  1. 生成JWT令牌 (AuthServiceImpl.java)：
    • 如果认证成功，AuthServiceImpl 使用 JwtUtil 生成一个JWT令牌。
    • 令牌包含用户ID作为主题，并设置一个过期时间。
/**
 * 生成JWT Token
 * @param userId 用户ID
 * @return 生成的JWT Token
 */
public String generateToken(String userId) {
return JWT.create()
                .withSubject(userId) // 设置主题 - 用户id
                .withIssuedAt(new Date())   // 设置签发时间 - 现在
                // 设置过期时间 - 配置文件
                .withExpiresAt(new Date(System.currentTimeMillis()+EXPIRATION_TIME))
                .sign(algorithm); // 设置算法与签名秘钥 - 配置文件
}
  1. 存储令牌和用户信息到Redis (AuthServiceImpl.java)：
    • 生成令牌后，将其与用户信息一起存储在Redis中，并设置过期时间。
@Override
public String login(String username, String password) {
  /**
  认证流程
  **/
  // 获取从loadUserByUsername方法获取的用户对象
  SecurityUser user = (SecurityUser) authenticate.getPrincipal();
  UserAccount userEntity = user.getUserAccount();
  // 生成token
  String token = jwtUtil.generateToken(userEntity.getId().toString());
  // 存入Redis
  redisTemplate.opsForValue().set(
      String.format(Const.REDIS_KEY, userEntity.getId()), // 设置Redis Key - 常量
      JSON.toJSONString(user),    // 存入Redis的值 - SecurityUser封装对象
      jwtUtil.getEXPIRATION_TIME(),   // 设置数据过期时间 - jwt过期时间
      TimeUnit.MILLISECONDS); // 设置过期时间的单位 - ms
  return token;
}
  1. 返回JWT令牌 (AuthController.java)：
    • AuthServiceImpl 将生成的JWT令牌返回给 AuthController。
    • AuthController 将令牌包装在成功响应中返回给客户端。
@RestController
@RequestMapping("/auth")
public class AuthController {
  @Resource
  private IAuthService authService;

  @PostMapping("/login")
  public Result<String > login(@RequestBody JSONObject params){
    String username  = params.getString("username");
    String password = params.getString("password");
    if (!StringUtils.hasText(username) || !StringUtils.hasText(password)) {
      return Result.fail(500, "用户名或密码为空！",null);
    }
    String token = authService.login(username, password);
    return Result.succ(token); // 验证成功, 返回响应
  }
}
  1. 客户端接收响应：
    • 客户端接收到包含JWT令牌的响应，并可以将其用于随后的请求。

需要认证的接口流程

从登录端点获取到的JwtToken

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIyIiwiZXhwIjoxNzI2Mjc2OTMwLCJpYXQiOjE3MjYxMDQxMzB9.YfdxPXnCl_GGwK08vy2umicr-p1l-yakW_BjwuLdSfE

有效期48小时, 用户test, 用户Id 2

发送需要鉴权的请求时, 需要在请求头中添加AuthorizationHeaders, 格式为Bearer JwtToken

  1. 客户端发起需要认证的请求：
    • 客户端发送请求到一个需要认证的端点，并在请求头中携带JWT令牌。

  1. JWT认证过滤器拦截请求 (JWTAuthenticationFilter.java)：
    • JWTAuthenticationFilter 拦截请求并从请求头中提取JWT令牌。
@Override
protected void doFilterInternal(HttpServletRequest request,
                                HttpServletResponse response,
                                FilterChain filterChain) throws ServletException, IOException {
  // 从请求头中获取Authorization信息
  String header = request.getHeader("Authorization");

  // 判断是否是放行请求
  if (isFilterRequest(request)) {
    // 如果是放行请求，则直接放行
    logger.info("放行路径 {}", request.getRequestURI());
    filterChain.doFilter(request, response);
    return;
  }
  logger.info("拦截路径 {}", request.getRequestURI());
  if (StringUtils.hasText(header) && header.startsWith("Bearer ")) {
    String token = header.substring(7);
    /**
    JwtToken 验证流程
    **/
  }
}
  1. 验证JWT令牌 (JWTAuthenticationFilter.java)：
    • JWTAuthenticationFilter 使用 JwtUtil 验证JWT令牌的有效性。
    • 如果令牌有效，JWTAuthenticationFilter 从令牌中提取用户信息，并创建一个认证对象。
    • 认证对象被设置到 SecurityContextHolder 中。
@Override
protected void doFilterInternal(HttpServletRequest request,
                                HttpServletResponse response,
                                FilterChain filterChain) 
                                throws ServletException, IOException {
  /**
  拦截路径, 提取JwtToken流程
  **/
  if (StringUtils.hasText(header) && header.startsWith("Bearer ")) {
    String token = header.substring(7);
    try{
      // 验证JWTToken是否有效并在有效期
      boolean tokenExpired = jwtUtil.isTokenExpired(token);
      if (tokenExpired) {
        // 验证失败
        logger.error("Token已过期, 请重新登录");
        fallback("Token失效, 请重新登录", response);
        return;
      }
    } catch (Exception e){
      logger.error(e.getMessage());
      fallback("Token解析失败, 请重新获取", response);
      return;
    }
    // 验证成功
    String userId = jwtUtil.extractUserId(token);
    String cache = (String) redisTemplate.opsForValue()
                    .get(String.format(Const.REDIS_KEY, userId));
    SecurityUser securityUser = JSON.parseObject(cache, SecurityUser.class);
    if (securityUser == null) {
      fallback("用户信息解析失败, 请重新登录", response);
      return;
    }
    logger.info("用户{}验证成功", securityUser.getUserAccount().getUsername());
    // 将用户信息存入SecurityContextHolder
    UsernamePasswordAuthenticationToken authenticationToken = 
                    new UsernamePasswordAuthenticationToken(securityUser, null, null);
    SecurityContextHolder.getContext().setAuthentication(authenticationToken);
    // 放行
    filterChain.doFilter(request, response);
  }
}
  1. 访问受保护资源：
    • 如果认证成功，客户端可以访问受保护的资源。
@GetMapping("auth-test")
public Result<SecurityUser> authTest() {
  // 从SecurityContextHolder获取Authentication对象, 然后获取SecurityUser封装用户信息
  Authentication authentication = 
                          SecurityContextHolder.getContext().getAuthentication();
  SecurityUser user = (SecurityUser) authentication.getPrincipal();
  // 获取用户信息, 直接返回用户实体类型会将所有信息都返回, 包括账号密码
  return Result.succ(user);
}
  1. 客户端接收响应：
    • 客户端接收到来自服务器的响应。

羡林i
关注
专栏目录
SpringSecurity6 | 基于数据库实现登录认证
分享思想，留下痕迹。
07-02 5381
大家好，我是Leo哥🫣🫣🫣，通过前面几节的学习，我们知道了如果通过内存进行登录认证以及如何获取登录用户的认证信息。但是在实际开发中，我们的用户都是存储在数据库中，并非直接存放在本地内存中。接下来，我们这篇博客将基于数据库的用户来实现我们的登录认证。其实用户进行认证，最常见的认证方式就是用户名+密码，认证服务需要根据用户名从存储中查询用户信息，然后判断输入的密码和存储中的密码是否匹配。对用户名、密码存储，内存JDBC关系型数据库使用的自定义数据存储使用LDAP认证的LDAP存储。
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
csweldn520的专栏
03-24 8448
一、 单点登录 1、单点登录技术方案 二、 第三方认证 1、 Oauth2认证 2、 Oauth2的应用场景 三、 Spring security Oauth2认证 1、 JWT （一） 、令牌结构 （二） 、生成私钥和公钥 （1）、生成密钥证书 （2）、查询证书信息 （3）、删除别名 （4）、导出公钥 2、 搭建Spring security认证服务器 （一）、导入Spring Security...
6.Spring Security-认证实现过程
oPeiJie1的博客
02-12 330
Spring Security 认证实现过程
使用Spring Security+jwt+redis实现登录注册逻辑
最新发布
qq_45791526的博客
10-10 616
使用Spring Security+jwt+redis实现登录注册逻辑
spring-boot mybaits spring security redis整合
05-14
主要功能如下： ===== 1、数据库 ====== Druid数据库连接池，监控数据库访问性能，详细统计SQL的执行性能，这对于线上分析数据库访问性能有帮助。 数据库密码加密。 2、持久层 ====== mybatis持久化，PageHelper分页。Transtraction注解Jta事务。 3、MVC ====== 基于spring mvc注解。Exception统一管理。 spring security权限管理。 aop日志记录。 4、调度 ====== Spring task, 可以查询已经注册的任务。立即执行一次任务。 5、缓存和Session =========== 注解redis缓存数据，Spring-session和redis实现分布式session同步(建议按功能模块划分系统)。 6、日志 =========== logback打印日志，业务日志和调试日志分开打印。同时基于时间和文件大小分割日志文件。 9、项目构建 =========== mybatis generator生成mybatis映射文件。 请先安装eclipse mybatis－generator插件。 10、其它 =========== >####说明：启动项目前请安装Redis，并启动服务，系统中均使用默认配置。 打war包：（dev、test、prod）指定配置文件 mvn clean package -Dmaven.test.skip=true -P test
SpringSecurity6.0+Redis+JWT+MP基于token认证功能开发（源码级剖析可用于实际生产项目）
laizhenghua的博客
06-25 6147
引子：最近做项目时遇到了一个特殊的需求，需要写共享接口把本系统的一些业务数据共享给各地市的自建系统，为了体现公司的专业性以及考虑到程序的扩展性（通过各地市的行政区划代码做限制），决定要把接口做的高级一些，而不是简单的传个用户名和密码对比数据库里面的，那样真的很low。于是写了基于token的认证功能，在这里分享出来供大家学习与探讨。
Spring Security+Redis实现登录
sky2019116的博客
02-03 1473
Spring Security是一个基于Spring框架的安全框架，它提供了一套完整的认证和授权机制，可以方便地实现登录功能需要实现UserDetails接口，并重写其中方法和定义一下自己需要用到的属性。@Data/** 用户唯一标识 *//** 登陆时间 *//** 过期时间 *//** 登录IP地址 *//** 浏览器类型 *//** 操作系统 *//** 用户信息 */@Override@Override/*** 账户是否未过期,过期无法验证*/
【实战运用】SpringSecurity+Redis+Jwt实现用户认证授权
k123456kah的博客
01-19 2304
Spring Security是一个强大且灵活的身份验证和访问控制框架，用于Java应用程序。它是基于Spring框架的一个子项目，旨在为应用程序提供安全性。Spring Security致力于为Java应用程序提供认证和授权功能。开发者可以轻松地为应用程序添加强大的安全性，以满足各种复杂的安全需求。
Spring Security 6 JWT身份验证
weixin_52019286的博客
01-26 929
基于JWT 实现身份认证和授权，是当前流行的一种技术解决方案。使用这种方案，要求用户先发来用户名与密码，当用户名与密码校验通过时，服务器端返回一个JWT给客户端。客户端拿到JWT之后，将其放到HTTP 请求名为Authorization的Header 中，随后继请求一起发给服务端服务端先校验JWT的有效性，有效之后，开放资源给客户端访问。public static final String JWT_KEY="这是我的一个私有密钥，用于生成JWT";//设置放在HTTP请求Header的名字。
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证
08-26
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或...
Springboot3 + SpringSecurity + JWT + OpenApi3 实现认证授权
m0_71777195的博客
06-07 5787
目前全网最新的 Spring Security + JWT 实现双 Token 的案例！此项目由作者个人创作，可以供大家学习和项目实战使用，创作不易，转载请注明出处！该项目使用目前最新的 Sprin Boot3 版本，采用目前市面上最主流的 JWT 认证方式，实现双token刷新。温馨提示：SpringBoot3 版本必须要使用 JDK11 或 JDK19。
springSecurity JWT验证机制
xiaoxiaoxiaopb的博客
07-16 570
文章目录一、springSecurity是什么？二、具体使用总结 一、springSecurity是什么？ 官网原话：Spring Security 是一个功能强大且高度可定制的身份验证和访问控制框架。它是保护基于 Spring 的应用程序的事实上的标准。Spring Security 是一个专注于为 Java 应用程序提供身份验证和授权的框架。与所有 Spring 项目一样，Spring Security 的真正强大之处在于它可以轻松扩展以满足自定义要求 二、具体使用 1. 基础使用在这里不在赘述，.
Spring Security 6.x 系列【44】微服务篇之统一身份认证实现方案
记录知识、锤炼自我
05-26 1740
在微服务架构中，前后端分离基于JSON进行数据交互，前端不仅有浏览器，还会有APP、H5、小程序等。 微服务中的后台应用一般都会按功能职责拆分为很多个独立应用，比如一个电商系统，会拆分为用户、订单、商品、库存、支付、商家管理等。一个大型项目后台应用可能有成千上万个，每个独立服务的职责都是单一的，对于登录认证来说，也是需要一个独立的服务，不可能每个服务实例都提供登录功能。
SpringSecurity6+JWT实现前后端分离
Huonzy的博客
09-17 3703
本文使用mybatis-plus作为ORM框架，然后使用springsecurity6作为安全框架，采用JWT作为权限确认的方式。其实我现在就刚入门这个springsecurity6而已，有许多都没有摸清它的使用，写下这篇文章只是想记录一下，下次想用的时候来看看。
SpringSecurity权限管理系统实战—六、SpringSecurity整合JWT
CoderMy的博客
08-01 5634
最近是真的懒。。。
Spring Security 6.0尝鲜
时雨吹雪的博客
01-19 3984
Spring Security 6.0
使用JWT保护你的Spring Boot应用 - Spring Security实战
weixin_34099526的博客
06-07 154
作者 freewolf 原创文章转载请标明出处 关键词 Spring Boot、OAuth 2.0、JWT、Spring Security、SSO、UAA 写在前面 最近安静下来，重新学习一些东西，最近一年几乎没写过代码。整天疲于奔命的日子终于结束了。坐下来，弄杯咖啡，思考一些问题，挺好。这几天有人问我Spring Boot结...
spring security6.0版本入门解析
Mr.xu的博客
03-06 5220
spring security ​6.0.0的入门详解,不看可惜了......
Spring Security 6.0(spring boot 3.0) 下认证配置流程
热门推荐
hjg719的博客
12-13 2万+
Spring Security 6.0(spring boot 3.0) 下认证配置流程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值