• Springboot实现登录功能（token、redis、登录拦截器、全局异常处理）

    登录流程： 

            1、前端调用登录接口，往接口里传入账号，密码

            2、根据账号判断是否有这个用户，如果有则继续判断密码是否正确

            3、验证成功后，则是根据账号，登录时间生成token（用JWT）

            4、将token存入Redis当中，用于token过期策略

            5、将token和用户信息返回给前端

            6、此后调用后端任何接口都会先判断发来请求里token是否存在、有效(拦截器实现)

            7、然后继续接下来的正常调用

     具体思路：

            1、再登录接口中实现账号、密码的验证和token创建

            2、实现一个拦截器，拦截除登录接口外的其他所有接口

            3、再拦截器中从请求头中取出token对其进行正确性的验证

            4、然后从redis里取出属于这个账号的token，如果取的出来则说明这个用户登录状态没有过期，然后和取出来的token进行对比，如果不一样则说明同一账号再其他地方进行了登录，则被挤出登录状态。

            5、再这整个判断过程中所产生的异常(没有登录状态，不存在这个用户....)都是由全局异常处理器进行捕获然后返回给前端。

     pom文件要引的依赖：

    1.       <!--版本-->  
    2.     <properties>
    3.         <java.version>1.8</java.version>
    4.         <lombok.version>1.18.12</lombok.version>
    5.         <hutool.version>5.8.8</hutool.version>
    6.         <mybatis-plus.version>3.5.2</mybatis-plus.version>
    7.         <JWT.version>6.0</JWT.version>
    8.         </properties>
    9.  
    10.  
    11.  
    12.         <!--JWT-->
    13.         <dependency>
    14.             <groupId>com.nimbusds</groupId>
    15.             <artifactId>nimbus-jose-jwt</artifactId>
    16.             <version>${JWT.version}</version>
    17.         </dependency>
    18.  
    19.         <dependency>
    20.             <groupId>com.qcby</groupId>
    21.             <artifactId>qcby-common</artifactId>
    22.             <version>1.0-SNAPSHOT</version>
    23.         </dependency>
    24.  
    25.         <!--redis-->
    26.         <dependency>
    27.             <groupId>org.springframework.boot</groupId>
    28.             <artifactId>spring-boot-starter-data-redis</artifactId>
    29.         </dependency>
    30.  
    31.         <dependency>
    32.             <groupId>org.projectlombok</groupId>
    33.             <artifactId>lombok</artifactId>
    34.             <version>${lombok.version}</version>
    35.         </dependency>
    36.         
    37.         <!--hutool-->
    38.         <dependency>
    39.             <groupId>cn.hutool</groupId>
    40.             <artifactId>hutool-all</artifactId>
    41.             <version>${hutool.version}</version>
    42.         </dependency>

    对于token我使用了JWT，有一个token的工具类用于token的创建和 验证。(这个类里使用的redisUtil类大家可以从网上随便找一个redis工具类，绑定上自己的reids)

    1. import com.nimbusds.jose.*;
    2. import com.nimbusds.jose.crypto.MACSigner;
    3. import com.nimbusds.jose.crypto.MACVerifier;
    4. import com.nimbusds.jwt.JWTClaimsSet;
    5. import com.nimbusds.jwt.SignedJWT;
    6. import com.qcby.framework.common.exception.ServiceException;
    7. import org.springframework.stereotype.Component;
    8.  
    9. import javax.annotation.Resource;
    10. import java.text.ParseException;
    11. import java.util.Date;
    12. import java.util.Objects;
    13. import java.util.concurrent.TimeUnit;
    14.  
    15. @Component
    16. public class TokenUtil {
    17.     @Resource
    18.     RedisUtil redisUtil;
    19.  
    20.     /**
    21.      * 创建秘钥
    22.      */
    23.     private static final byte[] SECRET = "qngChengBoYa-realtimeWuIngWangJiaQiZhangYv".getBytes();
    24.  
    25.     /**
    26.      * 生成token
    27.      * @param account
    28.      * @return {@link String}
    29.      */
    30.     public  String buildToken(String account) {
    31.  
    32.         try {
    33.             /**
    34.              * 1.创建一个32-byte的密匙
    35.              */
    36.             MACSigner macSigner = new MACSigner(SECRET);
    37.             /**
    38.              * 2. 建立payload 载体
    39.              */
    40.             JWTClaimsSet claimsSet = new JWTClaimsSet.Builder()
    41.                     .subject("login")
    42.                     .claim("ACCOUNT",account)
    43.                     .issueTime(new Date())
    44.                     .build();
    45.  
    46.             /**
    47.              * 3. 建立签名
    48.              */
    49.             SignedJWT signedJWT = new SignedJWT(new JWSHeader(JWSAlgorithm.HS256), claimsSet);
    50.             signedJWT.sign(macSigner);
    51.  
    52.             /**
    53.              * 4. 生成token
    54.              */
    55.             String token = signedJWT.serialize();
    56.             redisUtil.setEx(account,token,10,TimeUnit.MINUTES);
    57.             return token;
    58.         } catch (KeyLengthException e) {
    59.             e.printStackTrace();
    60.         } catch (JOSEException e) {
    61.             e.printStackTrace();
    62.         }
    63.         return null;
    64.     }
    65.  
    66.     /**
    67.      * 校验token
    68.      * @param token
    69.      * @return
    70.      */
    71.     public  boolean verifyToken(String token) {
    72.  
    73.         try {
    74.             SignedJWT jwt = SignedJWT.parse(token);
    75.             JWSVerifier verifier = new MACVerifier(SECRET);
    76.  
    77.             /**
    78.              * 校验是否有效
    79.              */
    80.             if (!jwt.verify(verifier)) {
    81.                 return false;
    82.             }
    83.             /**
    84.              * 获取载体中的数据
    85.              */
    86.             String account = (String) jwt.getJWTClaimsSet().getClaim("ACCOUNT");
    87.             //是否有
    88.             if (Objects.isNull(account)){
    89.  
    90.                 return false;
    91.             }
    92.             /**
    93.              * 判断redis里是否有account为key的值，如果有
    94.              * 判断token是否和redis里存的是是否一样，
    95.              * 如果不一样说明已经有其他账号登录了，则回到登录页面
    96.              * 如果一样，则给token续期
    97.              */
    98.             if (redisUtil.hasKey(account)){
    99.                 String s = redisUtil.get(account);
    100.                 if (s.equals(token)){
    101.                     redisUtil.expire(account,10,TimeUnit.MINUTES);
    102.                     return true;
    103.                 }
    104.                 throw new ServiceException("422","有其他设备登录");
    105.             }
    106.         } catch (ParseException e) {
    107.             e.printStackTrace();
    108.         } catch (JOSEException e) {
    109.             e.printStackTrace();
    110.         }
    111.         return false;
    112.     }
    113.  
    114.  
    115.  
    116. }

     登录拦截器的实现，要先创建一个类并实现HandlerInterceptor这个接口，然后再创建一个拦截器的配置类令其实现WebmvcConfigurer这个接口，重新addInterceptors方法，再这个方法中将之前实现的登录拦截器给注册进去，并配置这个拦截器的拦截路径，拦截优先级等等。

    1. /**
    2.  * 请求拦截器
    3.  * @author MI
    4.  * @date 2023/10/03
    5.  */
    6. @Component
    7. public class LoginInterceptor implements HandlerInterceptor {
    8.     private static Logger log = Logger.getLogger(LoginInterceptor.class);
    9.     /***
    10.      * 在请求处理之前进行调用(Controller方法调用之前)
    11.      @param request
    12.      @param response
    13.      @param handler
    14.      @return boolean
    15.      @throws Exception
    16.      */
    17.     @Resource
    18.     TokenUtil tokenUtil;
    19.  
    20.     @Override
    21.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    22.  
    23.         /**
    24.          * 从请求头中取出token，并判断其是否存在和合法
    25.          */
    26.             String token = request.getHeader("token");
    27.         if (token != null && tokenUtil.verifyToken(token)) {
    28.                 return true;
    29.             }else {
    30.                 throw new ServiceException("100","还未登录");
    31.             }
    32.     }
    33.  
    34.     /***
    35.      * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
    36.      @param request
    37.      @param response
    38.      @param handler
    39.      @param modelAndView
    40.      @throws Exception
    41.      */
    42.     @Override
    43.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    44.     }
    45.  
    46.     /***
    47.      * 整个请求结束之后被调用，也就是在DispatchServlet渲染了对应的视图之后执行（主要用于进行资源清理工作）
    48.      @param request
    49.      @param response
    50.      @param handler
    51.      @param ex
    52.      @throws Exception
    53.      */
    54.     @Override
    55.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    56.     }
    57. }
    58.  
    59.  
    60.  
    1. import javax.annotation.Resource;
    2. @Configuration
    3. public class MyWebMvcConfig implements WebMvcConfigurer {
    4.     @Resource
    5.     LoginInterceptor loginInterceptor;
    6.  
    7.     @Override
    8.     public void addInterceptors(InterceptorRegistry registry) {
    9.         /**
    10.          * 登录拦截器
    11.          * */
    12.       registry.addInterceptor(loginInterceptor)
    13.                 .addPathPatterns("/**")
    14.                 .excludePathPatterns("/login").
    15.               order(1);
    16.  
    17.     }
    18. }

            全局异常处理器，它能捕获到全部的异常（前提是要把异常抛出），所有异常都会在controller层反应出来，因为执行方法的原头在controller。我之前就是用try-catch处理，然后一直一直捕获不到，然后网上说正常的实现的全局异常器只能捕获到controller层的异常，所以拦截器里的异常捕获不到，这句话对也不对。拦截器里异常确实捕获不到，但只要咱把它抛出去就能再controller层显现了。

    具体实现就是我们要加@ControllerAdvice注解， @ExceptionHandler根据这个注解具体绑定处理哪个异常。

    1. /**
    2.  * 全局异常处理器
    3.  * @author MI
    4.  * @date 2023/10/02
    5.  */
    6. @Slf4j
    7. @ControllerAdvice
    8. public class GlobalExceptionHandler{
    9.     /**
    10.      * 自定义异常拦截器
    11.      * @param req
    12.      * @param e
    13.      * @return {@link Result}
    14.      */
    15.     @ResponseBody
    16.     @ExceptionHandler(value =ServiceException.class)
    17.     public Result exceptionHandler(HttpServletRequest req, ServiceException e){
    18.         log.info("发送{}异常",e.getMessage());
    19.         return Result.getBusinessException(e.getLocalizedMessage(),e.getCode());
    20.     }
    21.  
    22.  
    23.     @ResponseBody
    24.     @ExceptionHandler(value =Exception.class)
    25.     public Result exceptionHandler(HttpServletRequest req, Exception e){
    26.         log.info("发送{}异常",e.getMessage());
    27.         return Result.getBusinessException(e.getLocalizedMessage());
    28.     }
    29. }

    Server层实现：

    1. @Service
    2. @Slf4j
    3. public class LoginServiceImpl implements ILoginService {
    4.  
    5.     @Resource
    6.     UserMapper userMapper;
    7.     @Resource
    8.     TokenUtil tokenUtil;
    9.     @Resource
    10.     UserRoleMapper userRoleMapper;
    11.  
    12.     /**
    13.      * 登录实现
    14.      * @param loginDto
    15.      * @return {@link LoginVo}
    16.      */
    17.     @Override
    18.     public LoginVo login(LoginDto loginDto) {
    19.         UserPo userPo = userMapper.selectOne(new LambdaQueryWrapper<UserPo>().eq(UserPo::getAccount, loginDto.getAccount()));
    20.         if (userPo!=null){
    21.                 if (userPo.getPassword().equals(loginDto.getPassword())){
    22.                     /**
    23.                      * 构建token
    24.                      */
    25.                     String token = tokenUtil.buildToken(userPo.getAccount());
    26.                     LoginVo loginVo = new LoginVo();
    27.                     loginVo.setToken(token);
    28.                     loginVo.setRoleId(userRoleMapper.selectOne(
    29.                             new LambdaQueryWrapper<UserRolePo>().eq(UserRolePo::getUserId,userPo.getUserId())).getRoleId());
    30.                     loginVo.setAccount(userPo.getAccount());
    31.                     return loginVo;
    32.                 }else{
    33.                     throw new ServiceException("422","密码错误");
    34.                 }
    35.         }else {
    36.             throw new ServiceException("422", "用户不存在");
    37.         }
    38.     }
    39. }

    后面的Controller、Mapper、实体层大家要根据自己的需求字段来进行具体实现，我就不贴出来了。

     具体用法，像这个异常咱直接抛出来就行，全局异常处理类都能捕获，就不会继续往下执行了，它会把报错信息返回给前端：

    如图所示：

                                    

  • 相关阅读:
    Sentinel滑动时间窗口的原理及源码实现
    爬虫入门基础与Selenium反爬虫策略
    正向代理与反向代理
    OpenAI“杀疯了”，GPT–4o模型保姆级使用教程！一遍就会！
    CentOS 7.9如何禁止内核自动更新升级
    Kubernetes多租户策略的好处和挑战
    【洛谷算法题】P5707-上学迟到【入门1顺序结构】
    计算机二级WPS 选择题（模拟和解析四）
    手把手教你音乐服务器搭建
    Nginx可视化管理工具结合cpolar实现远程访问内网服务
  • 原文地址：https://blog.csdn.net/qq_64680177/article/details/133615590