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

SpringBoot整合JWT+Spring Security+Redis实现登录拦截（一）登录认证_springboot redis和jwt防止用户重复登录视频教程

作者：weixin_40725706 | 2024-07-26 14:37:54

赞

踩

springboot redis和jwt防止用户重复登录视频教程

一、JWT简介

        JWT 全称 JSON Web Token，JWT 主要用于用户登录鉴权，当用户登录之后，返回给前端一个Token，之后用户利用Token进行信息交互。

       除了JWT认证之外，比较传统的还有Session认证，如何选择可以查看之前的博文：基于token与Session身份认证对比-CSDN博客简单来说认证就是让服务器知道你是谁？就是让服务器知道你能干什么，不能干什么？那么基于身份认证我们一般有俩种方式：Session-Cookie和JWT。https://blog.csdn.net/shaogaiyue9745602/article/details/135130114?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22135130114%22%2C%22source%22%3A%22shaogaiyue9745602%22%7D

二、Spring Security简介

        Spring Security 是基于 Spring 的身份认证（Authentication）和用户授权（Authorization）框架，提供了一套 Web 应用安全性的完整解决方案。其中核心技术使用了 Servlet 过滤器、IOC 和 AOP 等。实际操作时经常需要实现XXXFilter来自定义的登录以及访问控制。

  • 什么是身份认证

        身份认证指的是用户去访问系统资源时，系统要求验证用户的身份信息，用户身份合法才访问对应资源。常见的身份认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。

  • 什么是用户授权

        当身份认证通过后，去访问系统的资源，系统会判断用户是否拥有访问该资源的权限，只允许访问有权限的系统资源，没有权限的资源将无法访问，这个过程叫用户授权。比如 会员管理模块有增删改查功能，有的用户只能进行查询，而有的用户可以进行修改、删除。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的权限。

三、登录拦截流程

     其中认证的过程还应包含 鉴权 以及 token过期 验证。 

四、认证流程流程

五、代码实现

     代码实现前需要有springboot项目有基础的用户user表，并可以实现数据的查询功能。最好有自己的统一返回配置和全局异常处理配置，若没有可参考前面的博客参考进行配置或自行配置。

  1.在pom中添加相关依赖

  1.         <!--安全框架引入, 进行权限控制-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-security</artifactId>
  5.         </dependency>
  6.  
  7.         <dependency>
  8.             <groupId>io.jsonwebtoken</groupId>
  9.             <artifactId>jjwt</artifactId>
  10.             <version>0.9.1</version>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>com.alibaba</groupId>
  14.             <artifactId>fastjson</artifactId>
  15.             <version>1.2.50</version>
  16.         </dependency>
  17.  
  18.         <dependency>
  19.             <groupId>javax.xml.bind</groupId>
  20.             <artifactId>jaxb-api</artifactId>
  21.             <version>2.3.1</version>
  22.         </dependency>

   引入依赖重新启动后，访问项目发现会出现登录页面如下：

        用户名默认为：user 

        默认密码在项目启动时会打印在控制台如下：

        也可通过在配置文件 application.properties 自定义用户名和密码

  1. spring.security.user.name=admin
  2. spring.security.user.password=admin

2.创建SecurityUser实现UserDetails

  1. package com.hng.config.jwtSecurity;
  2.  
  3. import com.alibaba.fastjson.annotation.JSONField;
  4. import com.hng.entity.SysUser;
  5. import lombok.Data;
  6. import lombok.NoArgsConstructor;
  7. import org.springframework.security.core.GrantedAuthority;
  8. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  9. import org.springframework.security.core.userdetails.UserDetails;
  10.  
  11. import java.util.Collection;
  12. import java.util.List;
  13.  
  14. /**
  15.  * @Author: 郝南过
  16.  * @Description: 
  17.  * @Date: 2023/11/29 10:26
  18.  * @Version: 1.0
  19.  */
  20. @Data
  21. @NoArgsConstructor
  22. public class SecurityUser implements UserDetails {
  23.  
  24.     private SysUser user;
  25.  
  26.     private List<String> permissions;
  27.  
  28.     @JSONField(serialize = false) // 防止存入redis时序列化出错，不进行序列化，也不存入redis中
  29.     private List<SimpleGrantedAuthority> authorities;
  30.  
  31.     public SecurityUser(SysUser user) {
  32.         this.user = user;
  33.     }
  34.  
  35.     @Override
  36.     public Collection<? extends GrantedAuthority> getAuthorities() {
  37.         return null;
  38.     }
  39.  
  40.     @Override
  41.     public String getPassword() {
  42.         return user.getPassword();
  43.     }
  44.  
  45.     @Override
  46.     public String getUsername() {
  47.         return user.getUserName();
  48.     }
  49.  
  50.     @Override
  51.     public boolean isAccountNonExpired() {
  52.         return true;
  53.     }
  54.  
  55.     @Override
  56.     public boolean isAccountNonLocked() {
  57.         return true;
  58.     }
  59.  
  60.     @Override
  61.     public boolean isCredentialsNonExpired() {
  62.         return true;
  63.     }
  64.  
  65.     @Override
  66.     public boolean isEnabled() {
  67.         return true;
  68.     }
  69. }

3.创建UserDetailsServiceImpl实现UserDetailsService

      该类主要功能是将Security拦截的用户名密码改为查询数据库中的用户名密码，以及权限的相关认证（权限认证相关本篇暂时不做添加）

  1. package com.hng.config.jwtSecurity;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.hng.entity.SysUser;
  5. import com.hng.service.SysUserService;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.security.core.userdetails.UserDetails;
  8. import org.springframework.security.core.userdetails.UserDetailsService;
  9. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  10. import org.springframework.stereotype.Service;
  11.  
  12. import javax.annotation.Resource;
  13. import java.util.Objects;
  14.  
  15. /**
  16.  * @Author: 郝南过
  17.  * @Description: 将Security拦截的用户名密码改为数据库中已有的用户名密码,Security自己校验密码，默认使用PasswordEncoder,格式为{id}password（id代表加密方式），
  18.  * 一般不采用此方式，SpringSecurity提供了BcryptPasswordEncoder,只需将此注入到spring容器中。SpringSecurity就会使用它进行替换校验
  19.  * @Date: 2023/12/11 11:29
  20.  * @Version: 1.0
  21.  */
  22. @Service
  23. @Slf4j
  24. public class UserDetailsServiceImpl implements UserDetailsService {
  25.  
  26.     @Resource
  27.     private SysUserService sysUserService;
  28.  
  29.     @Override
  30.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  31.         //查询用户信息
  32.         LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper();
  33.         queryWrapper.eq(SysUser::getUserName,username);
  34.         SysUser user = sysUserService.getOne(queryWrapper);
  35.         if(Objects.isNull(user)){
  36.             throw new RuntimeException("用户名或密码错误");
  37.         }
  38.         //TODO 查询授权信息
  39.         return new SecurityUser(user);
  40.     }
  41. }

4.创建JwtTokenUtil工具类

      该工具类用于token的创建验证等

  1. package com.hng.config.jwtSecurity;
  2.  
  3. import io.jsonwebtoken.Claims;
  4. import io.jsonwebtoken.Jwts;
  5. import io.jsonwebtoken.SignatureAlgorithm;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.security.core.userdetails.UserDetails;
  9. import org.springframework.stereotype.Component;
  10.  
  11. import javax.servlet.http.HttpServletRequest;
  12. import java.util.Date;
  13. import java.util.HashMap;
  14. import java.util.Map;
  15.  
  16. /**
  17.  * @Description JwtToken生成的工具类
  18.  * @Version 1.0
  19.  **/
  20. @Slf4j
  21. @Component
  22. public class JwtTokenUtil {
  23.  
  24.     private static final String CLAIM_KEY_USERNAME = "username";
  25.     private static final String CLAIM_KEY_CREATED = "created";
  26.     private static final String CLAIM_KEY_USER_ID = "userId";
  27.  
  28.     // 令牌自定义标识
  29.     @Value("${jwt.token.header}")
  30.     private String header;
  31.  
  32.     // 令牌秘钥
  33.     @Value("${jwt.token.secret}")
  34.     private String secret;
  35.  
  36.     // 令牌有效期（默认30分钟），也可将token的过期时间交给redis管理
  37.     @Value("${jwt.token.expireTime}")
  38.     private Long expiration;
  39.  
  40.  
  41.     /**
  42.      * 根据负责生成JWT的token
  43.      */
  44.     private String generateToken(Map<String, Object> claims) {
  45.         return Jwts.builder()
  46.                 .setClaims(claims)
  47.                 .setExpiration(generateExpirationDate())
  48.                 .signWith(SignatureAlgorithm.HS512, secret)
  49.                 .compact();
  50.     }
  51.  
  52.     /**
  53.      * 从token中获取JWT中的负载
  54.      */
  55.     public Claims getClaimsFromToken(String token) {
  56.         Claims claims = null;
  57.         try {
  58.             claims = Jwts.parser()
  59.                     .setSigningKey(secret)
  60.                     .parseClaimsJws(token)
  61.                     .getBody();
  62.         } catch (Exception e) {
  63.             log.info("JWT格式验证失败:{}",token);
  64.         }
  65.         return claims;
  66.     }
  67.  
  68.     /**
  69.      * 生成token的过期时间,返回Date
  70.      */
  71.     private Date generateExpirationDate() {
  72.         return new Date(System.currentTimeMillis() + expiration * 1000);
  73.     }
  74.  
  75.     /**
  76.      * 从token中获取登录用户名
  77.      */
  78.     public String getUserNameFromToken(String token) {
  79.         String username;
  80.         try {
  81.             Claims claims = getClaimsFromToken(token);
  82.             username =  claims.getSubject();
  83.         } catch (Exception e) {
  84.             username = null;
  85.         }
  86.         return username;
  87.     }
  88.  
  89.     /**
  90.      * 验证token是否还有效
  91.      *
  92.      * @param token       客户端传入的token
  93.      * @param userDetails 从数据库中查询出来的用户信息
  94.      */
  95.     public boolean validateToken(String token, UserDetails userDetails) {
  96.         String username = getUserNameFromToken(token);
  97.         return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
  98.     }
  99.  
  100.     /**
  101.      * 判断token是否已经失效
  102.      */
  103.     public boolean isTokenExpired(String token) {
  104.         Date expiredDate = getExpiredDateFromToken(token);
  105.         return expiredDate.before(new Date());
  106.     }
  107.  
  108.     /**
  109.      * 从token中获取过期时间
  110.      */
  111.     private Date getExpiredDateFromToken(String token) {
  112.         Claims claims = getClaimsFromToken(token);
  113.         return claims.getExpiration();
  114.     }
  115.  
  116.     /**
  117.      * 根据用户信息生成token
  118.      */
  119.     public String generateToken(UserDetails userDetails) {
  120.         Map<String, Object> claims = new HashMap<>();
  121.         claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
  122.         claims.put(CLAIM_KEY_CREATED, new Date());
  123.         return generateToken(claims);
  124.     }
  125.  
  126.     /**
  127.      * 根据用户信息生成token
  128.      */
  129.     public String generateToken(SecurityUser securityUser) {
  130.         Map<String, Object> claims = new HashMap<>();
  131.         claims.put(CLAIM_KEY_USERNAME, securityUser.getUsername());
  132.         claims.put(CLAIM_KEY_USER_ID, securityUser.getUser().getId());
  133.         claims.put(CLAIM_KEY_CREATED, new Date());
  134.         return generateToken(claims);
  135.     }
  136.  
  137.     /**
  138.      * 判断token是否可以被刷新
  139.      */
  140.     public boolean canRefresh(String token) {
  141.         return !isTokenExpired(token);
  142.     }
  143.  
  144.     /**
  145.      * 刷新token
  146.      */
  147.     public String refreshToken(String token) {
  148.         Claims claims = getClaimsFromToken(token);
  149.         claims.put(CLAIM_KEY_CREATED, new Date());
  150.         return generateToken(claims);
  151.     }
  152.  
  153.     /**
  154.      * 获取请求token
  155.      *
  156.      * @param request
  157.      * @return token
  158.      */
  159.     public String getToken(HttpServletRequest request)
  160.     {
  161.         return request.getHeader(header);
  162.     }
  163. }

5.创建RedisUtil工具类

       springboot如何集成redis可查看之前的博文

Springboot 集成Redis-CSDN博客文章浏览阅读621次，点赞9次，收藏9次。注意commons-pool2包与spring的版本一致性，若出错尝试升级或降级commons-pool2版本。https://blog.csdn.net/shaogaiyue9745602/article/details/134669420?spm=1001.2014.3001.5501

      记得在配置文件application.properties中添加redis配置信息

  1. spring.redis.host=127.0.0.1
  2. spring.redis.host.port=6379
  3. #spring.redis.host.name=
  4. #spring.redis.host.password=
  RedisUtil.java
  1. package com.hng.config.redis;
  2.  
  3. import org.springframework.core.annotation.Order;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.stereotype.Component;
  6. import org.springframework.util.CollectionUtils;
  7.  
  8. import javax.annotation.Resource;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Set;
  12. import java.util.concurrent.TimeUnit;
  13.  
  14. @Component
  15. @Order(-1)
  16. public final class RedisUtil {
  17.  
  18.     @Resource
  19.     private RedisTemplate redisTemplate;
  20.  
  21.     /**
  22.      * 指定缓存失效时间
  23.      *
  24.      * @param key  键
  25.      * @param time 时间(秒)
  26.      * @return 0
  27.      */
  29.     public boolean expire(String key, long time) {
  30.         try {
  31.             if (time > 0) {
  32.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  33.             }
  34.             return true;
  35.         } catch (Exception e) {
  36.             e.printStackTrace();
  37.             return false;
  38.         }
  39.     }
  40.  
  41.     /**
  42.      * 根据key 获取过期时间
  43.      *
  44.      * @param key 键 不能为null
  45.      * @return 时间(秒) 返回0代表为永久有效
  46.      */
  47.     public long getExpire(String key) {
  48.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  49.     }
  50.  
  51.     /**
  52.      * 判断key是否存在
  53.      *
  54.      * @param key 键
  55.      * @return true 存在 false不存在
  56.      */
  57.     public boolean hasKey(String key) {
  58.         try {
  59.             return redisTemplate.hasKey(key);
  60.         } catch (Exception e) {
  61.             e.printStackTrace();
  62.             return false;
  63.         }
  64.     }
  65.  
  66.     /**
  67.      * 删除缓存
  68.      *
  69.      * @param key 可以传一个值 或多个
  70.      */
  71.     @SuppressWarnings("unchecked")
  72.     public void del(String... key) {
  73.  
  74.         if (key != null && key.length > 0) {
  75.             if (key.length == 1) {
  76.                 redisTemplate.delete(key[0]);
  77.             } else {
  78.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  79.             }
  80.         }
  81.     }
  82.  
  83.     // ============================String=============================
  84.  
  85.     /**
  86.      * 普通缓存获取
  87.      *
  88.      * @param key 键
  89.      * @return 值
  90.      */
  91.     public Object get(String key) {
  92.         return key == null ? null : redisTemplate.opsForValue().get(key);
  93.     }
  94.  
  95.     /**
  96.      * 普通缓存放入
  97.      *
  98.      * @param key   键
  99.      * @param value 值
  100.      * @return true成功 false失败
  101.      */
  102.     public boolean set(String key, Object value) {
  103.         try {
  104.             redisTemplate.opsForValue().set(key, value);
  105.             return true;
  106.         } catch (Exception e) {
  107.             e.printStackTrace();
  108.             return false;
  109.         }
  110.     }
  111.  
  112.     /**
  113.      * 普通缓存放入并设置时间
  114.      *
  115.      * @param key   键
  116.      * @param value 值
  117.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  118.      * @return true成功 false 失败
  119.      */
  120.     public boolean set(String key, Object value, long time) {
  121.         try {
  122.             if (time > 0) {
  123.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  124.             } else {
  125.                 set(key, value);
  126.             }
  127.             return true;
  128.         } catch (Exception e) {
  129.             e.printStackTrace();
  130.             return false;
  131.         }
  132.     }
  133.  
  134.  
  135.     /**
  136.      * 递增
  137.      *
  138.      * @param key   键
  139.      * @param delta 要增加几(大于0)
  140.      * @return
  141.      */
  142.     public long incr(String key, long delta) {
  143.  
  144.         if (delta < 0) {
  145.             throw new RuntimeException("递增因子必须大于0");
  146.         }
  147.         return redisTemplate.opsForValue().increment(key, delta);
  148.     }
  149.  
  150.  
  151.     /**
  152.      * 递减
  153.      *
  154.      * @param key   键
  155.      * @param delta 要减少几(小于0)
  156.      * @return
  157.      */
  158.     public long decr(String key, long delta) {
  159.  
  160.         if (delta < 0) {
  161.             throw new RuntimeException("递减因子必须大于0");
  162.         }
  163.         return redisTemplate.opsForValue().increment(key, -delta);
  164.     }
  165.  
  166.     // ================================Map=================================
  167.  
  168.     /**
  169.      * HashGet
  170.      *
  171.      * @param key  键 不能为null
  172.      * @param item 项 不能为null
  173.      * @return 值
  174.      */
  176.     public Object hget(String key, String item) {
  177.         return redisTemplate.opsForHash().get(key, item);
  178.     }
  179.  
  180.  
  181.     /**
  182.      * 获取hashKey对应的所有键值
  183.      *
  184.      * @param key 键
  185.      * @return 对应的多个键值
  186.      */
  188.     public Map<Object, Object> hmget(String key) {
  189.         return redisTemplate.opsForHash().entries(key);
  190.     }
  191.  
  192.     /**
  193.      * HashSet
  194.      *
  195.      * @param key 键
  196.      * @param map 对应多个键值
  197.      * @return true 成功 false 失败
  198.      */
  200.     public boolean hmset(String key, Map<String, Object> map) {
  201.         try {
  202.             redisTemplate.opsForHash().putAll(key, map);
  203.             return true;
  204.         } catch (Exception e) {
  205.             e.printStackTrace();
  206.             return false;
  207.         }
  208.     }
  209.  
  210.     /**
  211.      * HashSet 并设置时间
  212.      *
  213.      * @param key  键
  214.      * @param map  对应多个键值
  215.      * @param time 时间(秒)
  216.      * @return true成功 false失败
  217.      */
  218.     public boolean hmset(String key, Map<String, Object> map, long time) {
  219.         try {
  220.             redisTemplate.opsForHash().putAll(key, map);
  221.             if (time > 0) {
  222.                 expire(key, time);
  223.             }
  224.             return true;
  225.         } catch (Exception e) {
  226.             e.printStackTrace();
  227.             return false;
  228.         }
  229.     }
  230.  
  231.     /**
  232.      * 向一张hash表中放入数据,如果不存在将创建
  233.      *
  234.      * @param key   键
  235.      * @param item  项
  236.      * @param value 值
  237.      * @return true 成功 false失败
  238.      */
  239.     public boolean hset(String key, String item, Object value) {
  240.         try {
  241.             redisTemplate.opsForHash().put(key, item, value);
  242.             return true;
  243.         } catch (Exception e) {
  244.             e.printStackTrace();
  245.             return false;
  246.         }
  247.     }
  248.  
  249.     /**
  250.      * 向一张hash表中放入数据,如果不存在将创建
  251.      * 0
  252.      *
  253.      * @param key   键
  254.      * @param item  项
  255.      * @param value 值
  256.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  257.      * @return true 成功 false失败
  258.      */
  259.     public boolean hset(String key, String item, Object value, long time) {
  260.         try {
  261.             redisTemplate.opsForHash().put(key, item, value);
  262.             if (time > 0) {
  263.                 expire(key, time);
  264.             }
  265.             return true;
  266.         } catch (Exception e) {
  267.             e.printStackTrace();
  268.             return false;
  269.         }
  270.     }
  271.  
  272.     /**
  273.      * 删除hash表中的值
  274.      *
  275.      * @param key  键 不能为null
  276.      * @param item 项 可以使多个 不能为null
  277.      */
  278.     public void hdel(String key, Object... item) {
  279.         redisTemplate.opsForHash().delete(key, item);
  280.     }
  281.  
  282.     /**
  283.      * 判断hash表中是否有该项的值
  284.      *
  285.      * @param key  键 不能为null
  286.      * @param item 项 不能为null
  287.      * @return true 存在 false不存在
  288.      */
  289.     public boolean hHasKey(String key, String item) {
  290.         return redisTemplate.opsForHash().hasKey(key, item);
  291.     }
  292.  
  293.     /**
  294.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  295.      *
  296.      * @param key  键
  297.      * @param item 项
  298.      * @param by   要增加几(大于0)
  299.      * @return
  300.      */
  301.     public double hincr(String key, String item, double by) {
  302.         return redisTemplate.opsForHash().increment(key, item, by);
  303.     }
  304.  
  305.     /**
  306.      * hash递减
  307.      *
  308.      * @param key  键
  309.      * @param item 项
  310.      * @param by   要减少记(小于0)
  311.      * @return
  312.      */
  313.     public double hdecr(String key, String item, double by) {
  314.         return redisTemplate.opsForHash().increment(key, item, -by);
  315.     }
  316.  
  317.     // ============================set=============================
  318.  
  319.     /**
  320.      * 根据key获取Set中的所有值
  321.      *
  322.      * @param key 键
  323.      * @return
  324.      */
  325.     public Set<Object> sGet(String key) {
  326.         try {
  327.             return redisTemplate.opsForSet().members(key);
  328.         } catch (Exception e) {
  329.             e.printStackTrace();
  330.             return null;
  331.         }
  332.     }
  333.  
  334.     /**
  335.      * 根据value从一个set中查询,是否存在
  336.      *
  337.      * @param key   键
  338.      * @param value 值
  339.      * @return true 存在 false不存在
  340.      */
  341.     public boolean sHasKey(String key, Object value) {
  342.  
  343.         try {
  344.             return redisTemplate.opsForSet().isMember(key, value);
  345.         } catch (Exception e) {
  346.             e.printStackTrace();
  347.             return false;
  348.         }
  349.     }
  350.  
  351.     /**
  352.      * 将数据放入set缓存
  353.      *
  354.      * @param key    键
  355.      * @param values 值 可以是多个
  356.      * @return 成功个数
  357.      */
  358.     public long sSet(String key, Object... values) {
  359.         try {
  360.             return redisTemplate.opsForSet().add(key, values);
  361.         } catch (Exception e) {
  362.             e.printStackTrace();
  363.             return 0;
  364.         }
  365.     }
  366.  
  367.     /**
  368.      * 将set数据放入缓存
  369.      *
  370.      * @param key    键
  371.      * @param time   时间(秒)
  372.      * @param values 值 可以是多个
  373.      * @return 成功个数
  374.      */
  375.     public long sSetAndTime(String key, long time, Object... values) {
  376.  
  377.         try {
  378.             Long count = redisTemplate.opsForSet().add(key, values);
  379.             if (time > 0)
  380.                 expire(key, time);
  381.             return count;
  382.         } catch (Exception e) {
  383.             e.printStackTrace();
  384.             return 0;
  385.         }
  386.     }
  387.  
  388.     /**
  389.      * 获取set缓存的长度
  390.      *
  391.      * @param key 键
  392.      * @return
  393.      */
  394.     public long sGetSetSize(String key) {
  395.         try {
  396.             return redisTemplate.opsForSet().size(key);
  397.         } catch (Exception e) {
  398.             e.printStackTrace();
  399.             return 0;
  400.         }
  401.     }
  402.  
  403.  
  404.     /**
  405.      * 移除值为value的
  406.      *
  407.      * @param key    键
  408.      * @param values 值 可以是多个
  409.      * @return 移除的个数
  410.      */
  411.     public long setRemove(String key, Object... values) {
  412.         try {
  413.             Long count = redisTemplate.opsForSet().remove(key, values);
  414.             return count;
  415.         } catch (Exception e) {
  416.             e.printStackTrace();
  417.             return 0;
  418.         }
  419.     }
  420.  
  421.     // ===============================list=================================
  422.  
  423.     /**
  424.      * 获取list缓存的内容
  425.      *
  426.      * @param key   键
  427.      * @param start 开始
  428.      * @param end   结束 0 到 -代表所有值
  429.      * @return
  430.      */
  431.     public List<Object> lGet(String key, long start, long end) {
  432.  
  433.         try {
  434.             return redisTemplate.opsForList().range(key, start, end);
  435.         } catch (Exception e) {
  436.             e.printStackTrace();
  437.             return null;
  438.         }
  439.     }
  440.  
  441.     /**
  442.      * 获取list缓存的长度
  443.      *
  444.      * @param key 键
  445.      * @return 0
  446.      */
  447.     public long lGetListSize(String key) {
  448.         try {
  449.             return redisTemplate.opsForList().size(key);
  450.         } catch (Exception e) {
  451.             e.printStackTrace();
  452.             return 0;
  453.         }
  454.     }
  455.  
  456.     /**
  457.      * 通过索引 获取list中的值
  458.      *
  459.      * @param key   键
  460.      * @param index 索引 index>=0时， 0 表头， 第二个元素，依次类推；index<0时，-，表尾，-倒数第二个元素，依次类推
  461.      * @return 0
  462.      */
  463.     public Object lGetIndex(String key, long index) {
  464.         try {
  465.             return redisTemplate.opsForList().index(key, index);
  466.         } catch (Exception e) {
  467.             e.printStackTrace();
  468.             return null;
  469.         }
  470.     }
  471.  
  472.     /**
  473.      * 将list放入缓存
  474.      *
  475.      * @param key   键
  476.      * @param value 值
  477.      * @return
  478.      */
  479.     public boolean lSet(String key, Object value) {
  480.         try {
  481.             redisTemplate.opsForList().rightPush(key, value);
  482.             return true;
  483.         } catch (Exception e) {
  484.             e.printStackTrace();
  485.             return false;
  486.         }
  487.     }
  488.  
  489.     /**
  490.      * 将list放入缓存
  491.      *
  492.      * @param key   键
  493.      * @param value 值
  494.      * @param time  时间(秒)
  495.      * @return
  496.      */
  497.     public boolean lSet(String key, Object value, long time) {
  498.         try {
  499.             redisTemplate.opsForList().rightPush(key, value);
  500.             if (time > 0)
  501.                 expire(key, time);
  502.             return true;
  503.         } catch (Exception e) {
  504.             e.printStackTrace();
  505.             return false;
  506.         }
  507.     }
  508.  
  509.     /**
  510.      * 将list放入缓存
  511.      *
  512.      * @param key   键
  513.      * @param value 值
  514.      * @return
  515.      */
  516.     public boolean lSet(String key, List<Object> value) {
  517.         try {
  518.             redisTemplate.opsForList().rightPushAll(key, value);
  519.             return true;
  520.         } catch (Exception e) {
  521.             e.printStackTrace();
  522.             return false;
  523.         }
  524.     }
  525.  
  526.     /**
  527.      * 将list放入缓存
  528.      *
  529.      * @param key   键
  530.      * @param value 值
  531.      * @param time  时间(秒)
  532.      * @return 0
  533.      */
  534.     public boolean lSet(String key, List<Object> value, long time) {
  535.         try {
  536.             redisTemplate.opsForList().rightPushAll(key, value);
  537.             if (time > 0)
  538.                 expire(key, time);
  539.             return true;
  540.         } catch (Exception e) {
  541.             e.printStackTrace();
  542.             return false;
  543.         }
  544.     }
  545.  
  546.     /**
  547.      * 根据索引修改list中的某条数据
  548.      *
  549.      * @param key   键
  550.      * @param index 索引
  551.      * @param value 值
  552.      * @return 0
  553.      */
  554.     public boolean lUpdateIndex(String key, long index, Object value) {
  555.         try {
  556.             redisTemplate.opsForList().set(key, index, value);
  557.             return true;
  558.         } catch (Exception e) {
  559.             e.printStackTrace();
  560.             return false;
  561.         }
  562.     }
  563.  
  564.     /**
  565.      * 移除N个值为value
  566.      *
  567.      * @param key   键
  568.      * @param count 移除多少个
  569.      * @param value 值
  570.      * @return 移除的个数
  571.      */
  572.     public long lRemove(String key, long count, Object value) {
  573.         try {
  574.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  575.             return remove;
  576.         } catch (Exception e) {
  577.             e.printStackTrace();
  578.             return 0;
  579.         }
  580.     }
  581. }
  582.

6. 创建JwtAuthenticationTokenFilter实现OncePerRequestFilter

        该类为登录授权过滤器

  1. package com.hng.config.jwtSecurity;
  2.  
  3. import com.hng.config.redis.RedisUtil;
  4. import io.jsonwebtoken.Claims;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  7. import org.springframework.security.core.context.SecurityContextHolder;
  8. import org.springframework.stereotype.Component;
  9. import org.springframework.util.StringUtils;
  10. import org.springframework.web.filter.OncePerRequestFilter;
  11. import org.springframework.web.servlet.HandlerExceptionResolver;
  12.  
  13. import javax.annotation.Resource;
  14. import javax.servlet.FilterChain;
  15. import javax.servlet.ServletException;
  16. import javax.servlet.http.HttpServletRequest;
  17. import javax.servlet.http.HttpServletResponse;
  18. import java.io.IOException;
  19. import java.util.Objects;
  20.  
  21. /**
  22.  * @Author: 郝南过
  23.  * @Description: JWT 登录授权过滤器
  24.  * @Date: 2023/11/28 16:19
  25.  * @Version: 1.0
  26.  */
  27. @Component
  28. public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
  29.  
  30.     @Resource
  31.     private RedisUtil redisUtil;
  32.  
  33.     // JWT 工具类
  34.     @Resource
  35.     private JwtTokenUtil jwtTokenUtil;
  36.  
  37.     @Resource
  38.     @Qualifier("handlerExceptionResolver")
  39.     private HandlerExceptionResolver resolver;
  40.  
  41.     /**
  42.      * 从请求中获取 JWT 令牌，并根据令牌获取用户信息，最后将用户信息封装到 Authentication 中，
  43.      * 方便后续校验（只会执行一次）
  44.      * @param request
  45.      * @param response
  46.      * @param filterChain
  47.      * @throws ServletException
  48.      * @throws IOException
  49.      */
  50.     @Override
  51.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  52.         //获取token
  53.         String token = request.getHeader("token");
  54.         if (!StringUtils.hasText(token)) {
  55.             //token为空的话, 就不管它, 让SpringSecurity中的其他过滤器处理请求，请求放行
  56.             filterChain.doFilter(request, response);
  57.             return;
  58.         }
  59.         //token不为空时, 解析token
  60.         String userId = null;
  61.         try {
  62.             Claims claims = jwtTokenUtil.getClaimsFromToken(token);
  63.             //解析出userId
  64.             userId = claims.get("userId", String.class);
  65.         } catch (Exception e) {
  66.             e.printStackTrace();
  67.             // 交给全局异常处理类处理
  68.             throw new RuntimeException("token非法");
  69. //            resolver.resolveException(request, response, null,new RuntimeException("token非法"));
  70.         }
  71.         //使用userId从Redis缓存中获取用户信息
  72.         String redisKey = "login:" + userId;
  73.         SecurityUser securityUser = (SecurityUser)redisUtil.get(redisKey);
  74.         if (Objects.isNull(securityUser)) {
  75.             throw new RuntimeException("用户未登录");
  76.             // 交给全局异常处理类处理
  77. //            resolver.resolveException(request, response, null,new RuntimeException("用户未登录"));
  78.         }
  79.         //将用户安全信息存入SecurityContextHolder, 在之后SpringSecurity的过滤器就不会拦截
  80.         UsernamePasswordAuthenticationToken authenticationToken =
  81.                 new UsernamePasswordAuthenticationToken(securityUser, null, securityUser.getAuthorities());
  82.         SecurityContextHolder.getContext().setAuthentication(authenticationToken);
  83.         //放行
  84.         filterChain.doFilter(request, response);
  85.     }
  86. }

7.创建SecurityConfig继承WebSecurityConfigurerAdapter

        该类主要为Security配置类

  1. package com.hng.config.jwtSecurity;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.security.authentication.AuthenticationManager;
  7. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
  8. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  9. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  10. import org.springframework.security.config.http.SessionCreationPolicy;
  11. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  12. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  13.  
  14. import javax.annotation.Resource;
  15.  
  16. /**
  17.  * @Author: 郝南过
  18.  * @Description: TODO
  19.  * @Date: 2023/11/28 16:24
  20.  * @Version: 1.0
  21.  */
  22. @Configuration //注册为SpringBoot的配置类
  23. @Slf4j
  24. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  25.  
  26.     //注入Jwt认证拦截器.
  27.     @Resource
  28.     private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
  29.  
  30.     /**
  31.      * 将BCryptPasswordEncoder加密器注入SpringSecurity中,
  32.      * SpringSecurity的DaoAuthenticaionProvider会调用该加密器中的match()方法进行密码比对, 密码比对过程不需要我们干涉
  33.      * @return
  34.      */
  35.     @Bean
  36.     public BCryptPasswordEncoder bcryptPasswordBean(){
  37.         return new BCryptPasswordEncoder();
  38.     }
  39.  
  40.     /**
  41.      * 注入身份验证管理器, 直接继承即可.
  42.      * @return
  43.      * @throws Exception
  44.      */
  45.     @Bean
  46.     @Override
  47.     public AuthenticationManager authenticationManagerBean() throws Exception {
  48.         return super.authenticationManagerBean();
  49.     }
  50.  
  51.     /**
  52.      * 配置
  53.      * @param http
  54.      * @throws Exception
  55.      */
  56.     @Override
  57.     protected void configure(HttpSecurity http) throws Exception {
  58.         http
  59.                 //禁用跨站请求伪造
  60.                 .csrf().disable()
  61.                 //禁用Session，使用token作为信息传递介质
  62.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  63.                 .and()
  64.                 //把token校验过滤器添加到过滤器链中, 添加在UsernamePasswordAuthenticationFilter之前是因为只要用户携带token,
  65.                 //就不需要再去验证是否有用户名密码了 (而且我们不使用表单登入, UsernamePasswordAuthenticationFilter是无法解析Json的, 相当于它没用了)
  66.                 //UsernamePasswordAuthenticationFilter是SpringSecurity默认配置的表单登录拦截器
  67.                 .addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class)
  68.                 // 认证请求的配置
  69.                 .authorizeRequests()
  70.                 // 将登入和注册的接口放开
  71.                 .antMatchers("/sys/login").anonymous()
  72.                 .antMatchers("/sys/register").anonymous()
  73.                 //除了上面的那些, 剩下的任何接口请求都需要经过认证
  74.                 .anyRequest().authenticated()
  75.                 .and()
  76.                 //允许跨域请求
  77.                 .cors();
  78.     }
  79.  
  80. }

8.在配置文件application.properties中添加相关的JWT配置信息

  1. # 令牌自定义标识
  2. jwt.token.header=token
  3. # 令牌秘钥
  4. jwt.token.secret=ZmQ0ZGI5NjQ0MDQwY2I4MjMxY2Y3ZmI3MjdhN2ZmMjNhODViOTg1ZGE0NTBjMGM4NDA5NzYxMjdjOWMwYWRmZTBlZjlhNGY3ZTg4Y2U3YTE1ODVkZDU5Y2Y3OGYwZWE1NzUzNWQ2YjFjZDc0NGMxZWU2MmQ3MjY1NzJmNTE0MzI=
  5. # 令牌有效期（默认30分钟）
  6. jwt.token.expireTime=1800

9.创建LoginController 

  1. package com.hng.controller;
  2.  
  3. import com.hng.config.redis.RedisUtil;
  4. import com.hng.config.jwtSecurity.JwtTokenUtil;
  5. import com.hng.config.jwtSecurity.SecurityUser;
  6. import com.hng.entity.SysUser;
  7. import com.hng.service.SysUserService;
  8. import io.swagger.annotations.Api;
  9. import io.swagger.annotations.ApiOperation;
  10. import lombok.extern.slf4j.Slf4j;
  11. import org.springframework.http.HttpStatus;
  12. import org.springframework.http.ResponseEntity;
  13. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  14. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  15. import org.springframework.security.core.Authentication;
  16. import org.springframework.security.core.context.SecurityContextHolder;
  17. import org.springframework.security.crypto.password.PasswordEncoder;
  18. import org.springframework.web.bind.annotation.*;
  19.  
  20. import javax.annotation.Resource;
  21. import java.util.HashMap;
  22. import java.util.Map;
  23.  
  24. /**
  25.  * @Author: 郝南过
  26.  * @Description: TODO
  27.  * @Date: 2023/11/29 10:20
  28.  * @Version: 1.0
  29.  */
  30. @Slf4j
  31. @RestController
  32. @RequestMapping("/sys/")
  33. @Api(value = "LoginController", tags = "LoginController")
  34. public class LoginController {
  35.  
  36.     @Resource
  37.     private PasswordEncoder passwordEncoder;
  38.     @Resource
  39.     private AuthenticationManagerBuilder authenticationManagerBuilder;
  40.     @Resource
  41.     private JwtTokenUtil jwtTokenUtil;
  42.     @Resource
  43.     private RedisUtil redisUtil;
  44.     @Resource
  45.     private SysUserService sysUserService;
  46.  
  47.     @ApiOperation("用户登录")
  48.     @PostMapping("/login")
  49.     @ResponseBody
  50.     public ResponseEntity<Object> userLogin(@RequestBody SysUser user) {
  51.  
  52.         UsernamePasswordAuthenticationToken authenticationToken =
  53.                 new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword());
  54.         Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);
  55.         SecurityContextHolder.getContext().setAuthentication(authentication);
  56.         //生成token
  57.         SecurityUser securityUser = (SecurityUser) authentication.getPrincipal();
  58.         String userId = securityUser.getUser().getId();
  59.         String jwtToken = jwtTokenUtil.generateToken(securityUser);
  60.         //redis保存用户信息
  61.         boolean resultRedis = redisUtil.set("login:" + userId, securityUser);
  62.         if(!resultRedis){
  63.             throw new RuntimeException("redis连接不上，登录失败");
  64.         }
  65.         // 返回 token 与 用户信息
  66.         Map<String, Object> authInfo = new HashMap<String, Object>(2) {{
  67.             put("token", jwtToken);
  68.             put("user", securityUser);
  69.         }};
  70.         return ResponseEntity.ok(authInfo);
  71.     }
  72.  
  73.     @ApiOperation("用户注册")
  74.     @PostMapping("/register")
  75.     @ResponseBody
  76.     public ResponseEntity<Object> userRegister(@RequestBody SysUser user){
  77.         user.setPassword(passwordEncoder.encode("123456"));
  78.         sysUserService.addSysUser(user);
  79.         return new ResponseEntity<>(HttpStatus.CREATED);
  80.     }
  81.  
  82.     @ApiOperation("退出登录")
  83.     @GetMapping(value = "/logout")
  84.     public ResponseEntity<Object> logout() {
  85.         UsernamePasswordAuthenticationToken authenticationToken = (UsernamePasswordAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
  86.         SecurityUser securityUser = (SecurityUser)authenticationToken.getPrincipal();
  87.         redisUtil.del("login:" + securityUser.getUser().getId());
  88.         return new ResponseEntity<>(HttpStatus.OK);
  89.     }
  90. }
  91.

六、测试

        使用postman进行测试

      1.login登录获取token

2.getList获取数据

        将login中获取的token复制到headers中，请求测试

到此登录拦截已经可以正常使用了

七 、配置登录异常处理器

  1.创建JwtAuthenticationEntryPoint实现AuthenticationEntryPoint

        该类主要用来处理认证失败异常

  1. package com.hng.config.security;
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.hng.config.response.ResponseResult;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.http.HttpStatus;
  7. import org.springframework.security.core.AuthenticationException;
  8. import org.springframework.security.web.AuthenticationEntryPoint;
  9. import org.springframework.stereotype.Component;
  10.  
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.IOException;
  14.  
  15. /**
  16.  * @Author: 郝南过
  17.  * @Description: 认证失败处理器
  18.  * @Date: 2023/12/19 17:17
  19.  * @Version: 1.0
  20.  */
  21. @Component
  22. @Slf4j
  23. public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
  24.     @Override
  25.     public void commence(HttpServletRequest request,
  26.                          HttpServletResponse response,
  27.                          AuthenticationException authException) throws IOException {
  28.         // 当用户尝试访问安全的REST资源而不提供任何凭据时，将调用此方法发送401 响应
  29.         response.setContentType("application/json;charset=UTF-8");
  30.         response.setStatus(HttpStatus.OK.value());
  31.         response.getWriter().write(JSONObject.toJSONString(ResponseResult.fail(HttpStatus.UNAUTHORIZED.value(),"认证失败")));
  32.         response.getWriter().flush();
  33.     }
  34. }

2.创建JwtAccessDeniedHandler实现AccessDeniedHandler

        该类主要用于处理鉴权失败异常

  1. package com.hng.config.security;
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.hng.config.response.ResponseResult;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.http.HttpStatus;
  7. import org.springframework.security.access.AccessDeniedException;
  8. import org.springframework.security.web.access.AccessDeniedHandler;
  9. import org.springframework.stereotype.Component;
  10.  
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.IOException;
  14.  
  15. /**
  16.  * @Author: 郝南过
  17.  * @Description: 鉴权失败处理
  18.  * @Date: 2023/12/19 17:26
  19.  * @Version: 1.0
  20.  */
  21. @Component
  22. @Slf4j
  23. public class JwtAccessDeniedHandler implements AccessDeniedHandler {
  24.     @Override
  25.     public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException {
  26.         //当用户在没有授权的情况下访问受保护的REST资源时，将调用此方法发送403 Forbidden响应
  27.         response.setContentType("application/json;charset=UTF-8");
  28.         response.setStatus(HttpStatus.OK.value());
  29.         response.getWriter().write(JSONObject.toJSONString(ResponseResult.fail(HttpStatus.FORBIDDEN.value(),"鉴权失败")));
  30.         response.getWriter().flush();
  31.     }
  32. }

3.全局异常处理器GlobalExceptionHandler中配置以上俩个异常

  1.     /**
  2.      * 全局捕获security的权限不足异常
  3.      */
  4.     @ExceptionHandler(value = AccessDeniedException.class)
  5.     public void accessDeniedException(AccessDeniedException e) {
  6.         log.error("权限不足异常！原因是：[{}]", e.getMessage());
  7.         throw e;
  8.     }
  9.  
  10.     /**
  11.      * 全局捕获security的认证失败异常
  12.      */
  13.     @ExceptionHandler(value = AuthenticationException.class)
  14.     public void authenticationException(AuthenticationException e) {
  15.         log.error("用户认证失败异常！原因是：[{}]", e.getMessage());
  16.         throw e;
  17.     }

4.在SecurityConfig中配置以上俩个异常

  1.     @Resource
  2.     private JwtAuthenticationEntryPoint authenticationEntryPoint;
  3.  
  4.     @Resource
  5.     private JwtAccessDeniedHandler accessDeniedHandler;
  1.             //配置异常处理器
  2.             .exceptionHandling()
  3.             //认证失败处理器
  4.             .authenticationEntryPoint(authenticationEntryPoint)
  5.             //鉴权失败处理器
  6.             .accessDeniedHandler(accessDeniedHandler)

5.测试

        认证失败异常可使用错误的用户名密码登录进行测试

        鉴权失败异常，暂时不能测试，需要补全权限代码后才可以进行测试

【demo示例代码】

https://download.csdn.net/download/shaogaiyue9745602/88661442icon-default.png?t=N7T8https://download.csdn.net/download/shaogaiyue9745602/88661442

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

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

  

闽ICP备14008679号