devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringSecurity + JWT 实现登录认证_springsecurity + jwt 安全验证

作者：weixin_40725706 | 2024-08-16 21:19:02

赞

踩

springsecurity + jwt 安全验证

目录

1. JWT 的组成和优势

2. JWT 的工作原理

2.1 生成 JWT

2.2 传输JWT

3. SpringSecurity + JWT 实现登录认证

3.1 配置 Spring Security 安全过滤链

3.2 自定义登录认证过滤器

3.3  实现SpringSecurity用户对象

3.4 获取当前登录用户

3.5 更加简单的获取登录用户 id 

1. JWT 的组成和优势

JWT 由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）

  1. 头部（Header）：包含了关于生成该 JWT 的信息以及所使用的算法类型。

  2. 载荷（Payload）：包含了要传递的数据，例如身份信息和其他附属数据。

  3. 签名（Signature）：使用密钥对头部和载荷进行签名，以验证其完整性。

JWT 相较于传统的 Session 认证机制，具有以下优势：

  1. 无需服务器存储状态：传统的基于 Session 认证机制需要服务器在会话中存储用户的状态信息，包括用户的登录状态、权限等。而使用 JWT，服务器无需存储任何会话状态信息，所有的认证和授权信息都包含在 JWT 中，使得系统可以更容易地进行水平扩展。

  2. 跨域支持：由于 JWT 包含了完整的认证和授权信息，因此可以轻松地在多个域之间进行传递和使用，实现跨域授权。

  3. 适应微服务架构：在微服务架构中，很多服务是独立部署并且可以横向扩展的，这就需要保证认证和授权的无状态性。使用 JWT 可以满足这种需求，每次请求携带 JWT 即可实现认证和授权。

  4. 自包含：JWT 包含了认证和授权信息，以及其他自定义的声明，这些信息都被编码在 JWT 中，在服务端解码后使用。JWT 的自包含性减少了对服务端资源的依赖，并提供了统一的安全机制。

  5. 扩展性：JWT 可以被扩展和定制，可以按照需求添加自定义的声明和数据，灵活性更高。

总结来说，使用 JWT 相较于传统的基于会话的认证机制，可以减少服务器存储开销和管理复杂性，实现跨域支持和水平扩展，并且更适应无状态和微服务架构。

2. JWT 的工作原理

JWT 工作原理包含三部分：

1. 生成 JWT

2. 传输 JWT

3. 验证 JWT

2.1 生成 JWT

在用户登录时，当服务器端验证了用户名和密码的正确性后，会根据用户的信息，如用户 ID 和用户名称，加上服务器端存储的 JWT 秘钥一起来生成一个 JWT 字符串，也就是我们所说的 Token.

  1. @Value("${jwt.secret}")
  2. private String jwtSecret;
  3.  
  4. /**
  5.  * 用户登录
  6.  *
  7.  * @return {@link ResponseEntity }
  8.  */
  9. @PostMapping("/login")
  10. public ResponseEntity login(@Validated UserDto userDto, HttpServletRequest request) {
  11.     // --- 验证图片验证码 ---
  12.    
  13.     // 验证用户名密码
  14.     LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
  15.     queryWrapper.eq(User::getUsername, userDto.getUsername());
  16.     User user = userService.getOne(queryWrapper);
  17.     if (user != null && passwordEncoder.matches(userDto.getPassword(), user.getPassword())) {
  18.         // 生成 JWT
  19.         HashMap<String, Object> payLoad = new HashMap<>() {{
  20.             put(JWTConstant.JWT_UID_KEY, user.getUid());
  21.             put(JWTConstant.JWT_USERNAME_KEY, user.getUsername());
  22.         }};
  23.         HashMap<String, String> result = new HashMap<>();
  24.         result.put(JWTConstant.JWT_KEY, JWTUtil.createToken(payLoad, jwtSecret.getBytes()));
  25.         result.put(JWTConstant.JWT_USERNAME_KEY, user.getUsername());
  26.         return ResponseEntity.success(result);
  27.     }
  28.     return ResponseEntity.fail("用户名或密码不正确!");
  29. }
  1. jwt:
  2.   secret: aicloud_springcloud_secret
  1. public class JWTConstant {
  2.  
  3.     public static final String JWT_KEY = "jwt";
  4.  
  5.     public static final String JWT_UID_KEY = "uid";
  6.  
  7.     public static final String JWT_USERNAME_KEY = "username";
  8.  
  9.     public static final String JWT_TOKEN_KEY = "Authorization";
  10. }

2.2 传输JWT

JWT 通常存储在客户端的 Cookie、LocalStorage、SessionStorage 等位置，客户端在每次请求时把 JWT 放在 Header 请求头中传递给服务器端.

存储 JWT 到 LocalStorage 

  1. $.ajax({
  2.     url: '/user/login',
  3.     type: 'POST',
  4.     data: field,
  5.     success: function (res) {
  6.         if (res.code === 200) {
  7.             layui.data(localStorage_jwt_key, {
  8.                 // 将生成的 jwt 存储到 LocalStorage
  9.                 key: jwt_token_key,
  10.                 value: res.data.jwt,
  11.             });
  12.             layui.data(localStorage_username_key, {
  13.                 // 存储 username
  14.                 key: login_username_key,
  15.                 value: res.data.username,
  16.             });
  17.             // 刷新父页面 (登录页是个弹窗)
  18.             window.parent.location.href = window.parent.location.href
  19.         } else {
  20.             layer.msg("登录失败：" + res.msg);
  21.         }
  22.     }
  23. });
  1. var localStorage_username_key = "login_username_key"
  2. var localStorage_jwt_key = "jwt_token_key"
  3. var login_username_key = "username"
  4. var jwt_token_key = "authorization"

 登录成功后，其他请求的 header 中带上 token

  1. function authAjax($, url, data, callback) {
  2.     $.ajax({
  3.         url: url,
  4.         type: 'POST',
  5.         headers: {
  6.             'Authorization': layui.data("jwt_token_key").authorization
  7.         },
  8.         data: data,
  9.         success: callback,
  10.     });
  11. }

3. SpringSecurity + JWT 实现登录认证

3.1 配置 Spring Security 安全过滤链

  1. @Configuration
  2. @EnableWebSecurity
  3. public class SecurityConfig {
  4.  
  5.     @Resource
  6.     private LoginAuthenticationFilter loginAuthenticationFilter;
  7.  
  8.     /**
  9.      * 加盐加密
  10.      *
  11.      * @return {@link PasswordEncoder }
  12.      */
  13.     @Bean
  14.     public PasswordEncoder passwordEncoder() {
  15.         return new BCryptPasswordEncoder();
  16.     }
  17.  
  18.     /**
  19.      * 配置 Spring Security 安全过滤链
  20.      *
  21.      * @param http
  22.      * @return {@link SecurityFilterChain }
  23.      * @throws Exception
  24.      */
  25.     @Bean
  26.     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
  27.         return http
  28.                 // 禁用明文验证
  29.                 .httpBasic(AbstractHttpConfigurer::disable)
  30.                 // 禁用 CSRF 验证
  31.                 .csrf(AbstractHttpConfigurer::disable)
  32.                 // 禁用默认登录页
  33.                 .formLogin(AbstractHttpConfigurer::disable)
  34.                 // 禁用默认 header，支持 iframe 访问页面
  35.                 .headers(AbstractHttpConfigurer::disable)
  36.                 // 禁用默认注销页
  37.                 .logout(AbstractHttpConfigurer::disable)
  38.                 // 禁用 Session (默认使用 JWT 认证)
  39.                 .sessionManagement(session ->
  40.                         session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
  41.                 .authorizeHttpRequests(auth -> auth
  42.                         // 允许访问的资源
  43.                         .requestMatchers(
  44.                                 "/layui/**",
  45.                                 "/js/**",
  46.                                 "/image/**",
  47.                                 "/login.html",
  48.                                 "/index.html",
  49.                                 "/reg.html",
  50.                                 "/user/login",
  51.                                 "/user/reg",
  52.                                 "/captcha/create",
  53.                                 "/discuss/delete",
  54.                                 "/discuss/detail",
  55.                                 "/kafka/**",
  56.                                 "/swagger-ui/**",
  57.                                 "/v3/**",
  58.                                 "/doc.html",
  59.                                 "/webjars/**"
  60.                         ).permitAll()
  61.                         // 其他请求都需要认证拦截
  62.                         .anyRequest().authenticated()
  63.                 )
  64.                 // 添加自定义认证过滤器
  65.                 .addFilterBefore(loginAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
  66.                 .build();
  67.     }
  68. }

3.2 自定义登录认证过滤器

  1. @Component
  2. public class LoginAuthenticationFilter extends OncePerRequestFilter {
  3.  
  4.     @Value("${jwt.secret}")
  5.     private String jwtSecret;
  6.  
  7.     @Override
  8.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  9.         // 1.获取 JWT 令牌
  10.         String token = request.getHeader(JWTConstant.JWT_TOKEN_KEY);
  11.         if (!StringUtils.isBlank(token)) {
  12.             // 2.判断 JWT 令牌正确性
  13.             if (JWTUtil.verify(token, jwtSecret.getBytes())) {
  14.                 // 3.获取用户信息，存储 Security 中
  15.                 JWT jwt = JWTUtil.parseToken(token);
  16.                 if (ObjectUtil.isNotNull(jwt) && jwt.getPayload(JWTConstant.JWT_UID_KEY) != null
  17.                         && jwt.getPayload(JWTConstant.JWT_USERNAME_KEY) != null) {
  18.                     Long uid = Long.parseLong(jwt.getPayload(JWTConstant.JWT_UID_KEY).toString());
  19.                     String username = jwt.getPayload(JWTConstant.JWT_USERNAME_KEY).toString();
  20.                     // 4.创建用户对象
  21.                     SecurityUserDetails userDetails = new SecurityUserDetails(uid, username, EMPTY);
  22.                     UsernamePasswordAuthenticationToken authentication =
  23.                             new UsernamePasswordAuthenticationToken(userDetails,
  24.                                     null,
  25.                                     userDetails.getAuthorities());
  26.                     // 绑定 request 对象
  27.                     authentication.setDetails(new WebAuthenticationDetailsSource()
  28.                             .buildDetails(request));
  29.                     SecurityContextHolder.getContext().setAuthentication(authentication);
  30.                 }
  31.             }
  32.         }
  33.         filterChain.doFilter(request, response);
  34.     }
  35. }

3.3  实现SpringSecurity用户对象

  1. @Data
  2. @Builder
  3. public class SecurityUserDetails implements UserDetails {
  4.     @Serial
  5.     private static final long serialVersionUID = -829716430599304080L;
  6.     
  7.     private Long uid;
  8.     private String username;
  9.     private String password;
  10.  
  11.     public SecurityUserDetails(Long uid, String username, String password) {
  12.         this.uid = uid;
  13.         this.username = username;
  14.         this.password = password;
  15.     }
  16.  
  17.     /**
  18.      * 权限
  19.      *
  20.      * @return {@link Collection }<{@link ? } {@link extends } {@link GrantedAuthority }>
  21.      */
  22.     @Override
  23.     public Collection<? extends GrantedAuthority> getAuthorities() {
  24.         return null;
  25.     }
  26.  
  27.     /**
  28.      * 密码
  29.      *
  30.      * @return {@link String }
  31.      */
  32.     @Override
  33.     public String getPassword() {
  34.         return "";
  35.     }
  36.  
  37.     /**
  38.      * 用户名
  39.      *
  40.      * @return {@link String }
  41.      */
  42.     @Override
  43.     public String getUsername() {
  44.         return "";
  45.     }
  46.  
  47.     /**
  48.      * 账户是否过期
  49.      *
  50.      * @return boolean
  51.      */
  52.     @Override
  53.     public boolean isAccountNonExpired() {
  54.         return false;
  55.     }
  56.  
  57.     /**
  58.      * 账号是否锁定
  59.      *
  60.      * @return boolean
  61.      */
  62.     @Override
  63.     public boolean isAccountNonLocked() {
  64.         return false;
  65.     }
  66.  
  67.     /**
  68.      * 密码是否过期
  69.      *
  70.      * @return boolean
  71.      */
  72.     @Override
  73.     public boolean isCredentialsNonExpired() {
  74.         return false;
  75.     }
  76.  
  77.     /**
  78.      * 账号是否可用
  79.      *
  80.      * @return boolean
  81.      */
  82.     @Override
  83.     public boolean isEnabled() {
  84.         return true;
  85.     }
  86. }

3.4 获取当前登录用户

  1. public class SecurityUtil {
  2.  
  3.     /**
  4.      * 获取当前登录用户
  5.      *
  6.      * @return {@link SecurityUserDetails }
  7.      */
  8.     public static SecurityUserDetails getCurrentUser() {
  9.         SecurityUserDetails userDetails = null;
  10.         try {
  11.             userDetails = (SecurityUserDetails) SecurityContextHolder.getContext()
  12.                     .getAuthentication().getPrincipal();
  13.         } catch (Exception e) {
  14.         }
  15.         return userDetails;
  16.     }
  17. }

得到当前登录对象后，想要获取当前登录对象的 uid，就可以通过如下代码来获取：

Long uid = ObjectUtil.isNotNull(userDetails) ? userDetails.getUid() : NumberUtils.LONG_ZERO;

3.5 更加简单的获取登录用户 id 

使用 ThreadLocal 可以更加简单的存取当前用户的 id，并且客户端的一次请求用的是同一个线程 id，多次请求线程 id 也不同，也不会出现线程安全问题。

① 创建 ThreadLocal 工具类 BaseContext

  1. public class BaseContext {
  2.  
  3.     public static ThreadLocal<Long> threadLocal = new ThreadLocal<>();
  4.  
  5.     public static void setCurrentId(Long id) {
  6.         threadLocal.set(id);
  7.     }
  8.  
  9.     public static Long getCurrentId() {
  10.         return threadLocal.get();
  11.     }
  12.  
  13.     public static void removeCurrentId() {
  14.         threadLocal.remove();
  15.     }
  16.  
  17. }

② 在登录认证过滤器，令牌通过后，存储 uid

  1. @Component
  2. public class LoginAuthenticationFilter extends OncePerRequestFilter {
  3.  
  4.     @Value("${jwt.secret}")
  5.     private String jwtSecret;
  6.  
  7.     @Override
  8.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  9.         // 1.获取 JWT 令牌
  10.         String token = request.getHeader(JWTConstant.JWT_TOKEN_KEY);
  11.         if (!StringUtils.isBlank(token)) {
  12.             // 2.判断 JWT 令牌正确性
  13.             if (JWTUtil.verify(token, jwtSecret.getBytes())) {
  14.                 // 3.获取用户信息，存储 Security 中
  15.                 JWT jwt = JWTUtil.parseToken(token);
  16.                 if (ObjectUtil.isNotNull(jwt) && jwt.getPayload(JWTConstant.JWT_UID_KEY) != null
  17.                         && jwt.getPayload(JWTConstant.JWT_USERNAME_KEY) != null) {
  18.                     Long uid = Long.parseLong(jwt.getPayload(JWTConstant.JWT_UID_KEY).toString());
  19.                     String username = jwt.getPayload(JWTConstant.JWT_USERNAME_KEY).toString();
  20.  
  21.                     // ---------   使用 ThreadLocal 存储当前用户 ID ---------
  22.                      BaseContext.setCurrentId(uid);
  23.                 }
  24.             }
  25.         }
  26.         filterChain.doFilter(request, response);
  27.     }
  28. }

③ 在需要使用 uid 的地方获取 uid

Long uid = BaseContext.getCurrentId(); // 使用 ThreadLocal 获取身份 id

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/989879
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号