【JavaWeb】SpringBootWeb登录认证

港控/mmm° 2024-04-26 01:58 156阅读 0赞

? 本文由 程序喵正在路上 原创，CSDN首发！
? 系列专栏：JavaWeb开发
? 首发时间：2024年3月18日
? 欢迎关注?点赞?收藏?留言?

目录

  • 登录功能
  • 登录校验 (重点)
    • 会话技术
    • JWT令牌
    • 过滤器Filter
    • 拦截器Interceptor
  • 异常处理

登录功能

需求

在这里插入图片描述

在这里插入图片描述

思路

在这里插入图片描述

实现

LoginController.java

  1. @Slf4j
  2. @RestController
  3. public class LoginController {
  6.     @Autowired
  7.     private EmpService empService;
  9.     @PostMapping("/login")
  10.     public Result login(@RequestBody Emp emp) {
  12.         log.info("员工登录，{}", emp);
  13.         Emp e = empService.login(emp);
  14.         return e != null ? Result.success() : Result.error("用户名或密码错误");
  15.     }
  16. }

EmpServiceImpl.java

  1. @Override
  2. public Emp login(Emp emp) {
  4.     return empMapper.getByUsernameAndPassword(emp);
  5. }

EmpMapper.java

  1. /**
  2.  * 根据用户名和密码查询员工
  3.  * @param emp
  4.  * @return
  5.  */
  6. @Select("select * from emp where username = #{username} and password = #{password}")
  7. Emp getByUsernameAndPassword(Emp emp);

测试

在这里插入图片描述

在这里插入图片描述

前后端联调，先退出到登录界面：

在这里插入图片描述

失败的情况：

在这里插入图片描述

成功的情况：

在这里插入图片描述

登录校验 (重点)

问题分析

执行启动类，直接点击 http://localhost:90/#/system/emp 进入，然后我们就访问到了员工管理的页面，但是我们并没有登录，这显然是有问题的，这是因为我们在写查询等功能时没有考虑到去校验用户是否已登录的情况

解决思路

在这里插入图片描述
登录标记

  • 用户登录成功之后，每一次请求中，都可以获取到该标记

统一拦截

  • 过滤器Filter
  • 拦截器Interceptor

会话技术

  • 会话：用户打开浏览器，访问web服务器的资源，会话建立，直到有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应。
  • 会话跟踪：一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。

  • 会话跟踪方案：

    • 客户端会话跟踪技术：Cookie
    • 服务端会话跟踪技术：Session
    • 令牌技术

在这里插入图片描述

会话跟踪方案对比

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

JWT令牌

  • 全称：JSON Web Token （https://jwt.io/）
  • 定义了一种简洁的、自包含的格式，用于在通信双方以json数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的。

  • 组成：

    • 第一部分：Header(头）， 记录令牌类型、签名算法等。 例如：{"alg":"HS256","type":"JWT"}
    • 第二部分：Payload(有效载荷），携带一些自定义信息、默认信息等。 例如：{"id":"1","username":"Tom"}
    • 第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来。

    在这里插入图片描述

令牌的前两部分通过 Base64 进行编码

  • Base64：是一种基于64个可打印字符（A-Z a-z 0-9 + /）来表示二进制数据的编码方式。

典型应用场景：登录认证

  • 登录成功后，生成令牌
  • 后续每个请求，都要携带JWT令牌，系统在每次请求处理之前，先校验令牌，通过后，再处理

JWT-生成

在测试类中，我们来写 JWT 生成的程序，执行前可以先把 @SpringBootTest 注释掉，这样不用加载整个工程，因为整个测试程序和工程无关

  1. /**
  2.  * 生成JWT
  3.  */
  4. @Test
  5. public void testGenJwt() {
  7.     Map<String, Object> claims = new HashMap<>();
  8.     claims.put("id", 1);
  9.     claims.put("name", "Tom");
  10.     String jwt = Jwts.builder()
  11.             .signWith(SignatureAlgorithm.HS256, "xixi") //签名算法
  12.             .setClaims(claims)  //自定义内容（载荷）
  13.             .setExpiration(new Date(System.currentTimeMillis() + 3600 * 1000))  //设置有效期为1小时
  14.             .compact();
  15.     System.out.println(jwt);
  16. }

在这里插入图片描述

JWT-校验

  1. /**
  2.  * 校验JWT
  3.  */
  4. @Test
  5. public void testParseJwt() {
  7.     Claims claims = Jwts.parser()
  8.             .setSigningKey("xixi")
  9.             .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiVG9tIiwiaWQiOjEsImV4cCI6MTcxMDIyODExNX0.bATiIimrJ_SD2Nbow30ErqBBtEDZgugbv96L0SXJtrs")
  10.             .getBody();
  11.     System.out.println(claims);
  12. }

在这里插入图片描述

注意事项

  • JWT校验时使用的签名秘钥，必须和生成JWT令牌时使用的秘钥是配套的。
  • 如果JWT令牌解析校验时报错，则说明JWT令牌被篡改或失效了，令牌非法。

登录后下发令牌

令牌生成和校验思路

  • 令牌生成：登录成功后，生成JWT令牌，并返回给前端。
  • 令牌校验：在请求到达服务端后，对令牌进行统一拦截、校验。

登录-生成令牌步骤

  • 引入JWT令牌操作工具类。
  • 登录完成后，调用工具类生成JWT令牌，并返回。

工具类 JwtUtils

  1. import io.jsonwebtoken.Claims;
  2. import io.jsonwebtoken.Jwts;
  3. import io.jsonwebtoken.SignatureAlgorithm;
  4. import java.util.Date;
  5. import java.util.Map;
  7. public class JwtUtils {
  10.     private static String signKey = "xixi";
  11.     private static Long expire = 43200000L;
  13.     /**
  14.      * 生成JWT令牌
  15.      * @param claims JWT第二部分负载 payload 中存储的内容
  16.      * @return
  17.      */
  18.     public static String generateJwt(Map<String, Object> claims){
  20.         String jwt = Jwts.builder()
  21.                 .addClaims(claims)
  22.                 .signWith(SignatureAlgorithm.HS256, signKey)
  23.                 .setExpiration(new Date(System.currentTimeMillis() + expire))
  24.                 .compact();
  25.         return jwt;
  26.     }
  28.     /**
  29.      * 解析JWT令牌
  30.      * @param jwt JWT令牌
  31.      * @return JWT第二部分负载 payload 中存储的内容
  32.      */
  33.     public static Claims parseJWT(String jwt){
  35.         Claims claims = Jwts.parser()
  36.                 .setSigningKey(signKey)
  37.                 .parseClaimsJws(jwt)
  38.                 .getBody();
  39.         return claims;
  40.     }
  41. }

修改 LoginController.java

  1. @Slf4j
  2. @RestController
  3. public class LoginController {
  6.     @Autowired
  7.     private EmpService empService;
  9.     @PostMapping("/login")
  10.     public Result login(@RequestBody Emp emp) {
  12.         log.info("员工登录，{}", emp);
  13.         Emp e = empService.login(emp);
  15.         //登录成功，生成令牌，下发令牌
  16.         if (e != null) {
  18.             Map<String, Object> claims = new HashMap<>();
  19.             claims.put("id", e.getId());
  20.             claims.put("name", e.getName());
  21.             claims.put("username", e.getUsername());
  23.             String jwt = JwtUtils.generateJwt(claims);
  24.             return Result.success(jwt);
  25.         }
  27.         //登录失败，返回错误信息
  28.         return Result.error("用户名或密码错误");
  29.     }
  30. }

测试：

在这里插入图片描述

过滤器Filter

  • 概念：Filter 过滤器，是 JavaWeb 三大组件(Servlet、Filter、Listener)之一
  • 过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能
  • 过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等

在这里插入图片描述

快速入门

  1. 定义Filter：定义一个类，实现 Filter 接口，并重写其所有方法。

    在这里插入图片描述

  2. 配置Filter：Filter类上加 @WebFilter 注解，配置拦截资源的路径。引导类上加 @ServletComponentScan 开启Servlet组件支持。

    在这里插入图片描述

详解

Filter执行流程

  • 放行后，程序访问对应的资源，资源访问完成后，程序会回到 Filter 中继续执行放行后面的内容

Filter拦截路径

  • Filter 可以根据需求，配置不同的拦截资源路径：

    在这里插入图片描述

过滤器链

  • 介绍：一个web应用中，可以配置多个过滤器，这多个过滤器就形成了一个过滤器链。
  • 顺序：注解配置的Filter，优先级是按照过滤器类名（字符串）的自然排序。

在这里插入图片描述

登录校验-Filter

注意

  • 所有的请求，拦截到了之后，除了登录操作外，都需要校验令牌
  • 拦截到请求后，有令牌，且令牌校验通过（合法）才可以放行，执行业务操作；否则都返回未登录错误结果

步骤

  1. 获取请求url。
  2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行。
  3. 获取请求头中的令牌（token）。
  4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）。
  5. 解析token，如果解析失败，返回错误结果（未登录）。
  6. 放行。

在这里插入图片描述

创建一个 LoginCheckFilter.java

  1. import com.alibaba.fastjson.JSONObject;
  2. import com.xixi.pojo.Result;
  3. import com.xixi.utils.JwtUtils;
  4. import jakarta.servlet.*;
  5. import jakarta.servlet.annotation.WebFilter;
  6. import jakarta.servlet.http.HttpServletRequest;
  7. import jakarta.servlet.http.HttpServletResponse;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.springframework.util.StringUtils;
  11. import java.io.IOException;
  13. @Slf4j
  14. @WebFilter(urlPatterns = "/*")
  15. public class LoginCheckFilter implements Filter {
  17.     @Override
  18.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  20.         HttpServletRequest req = (HttpServletRequest) servletRequest;
  21.         HttpServletResponse resp = (HttpServletResponse) servletResponse;
  23.         //获取请求url
  24.         String url = req.getRequestURL().toString();
  25.         log.info("请求的url：{}", url);
  27.         //判断请求url中是否包含login，如果包含，说明是登录操作，放行
  28.         if (url.contains("login")) {
  30.             log.info("登录操作，放行...");
  31.             filterChain.doFilter(servletRequest, servletResponse);
  32.             return;
  33.         }
  35.         //获取请求头中的令牌（token）
  36.         String jwt = req.getHeader("token");
  38.         //判断令牌是否存在，如果不存在，返回错误结果（未登录）
  39.         if (!StringUtils.hasLength(jwt)) {
  41.             log.info("请求token为空，返回未登录的信息");
  43.             Result error = Result.error("NOT_LOGIN");
  44.             //手动将错误信息转换为json格式，需要引入阿里巴巴的fastJSON依赖
  45.             String notLogin = JSONObject.toJSONString(error);
  46.             resp.getWriter().write(notLogin);
  47.             return;
  48.         }
  50.         //解析token，如果解析失败，返回错误结果（未登录）
  51.         try {
  53.             JwtUtils.parseJWT(jwt);
  54.         } catch (Exception e) {
  55.      //jwt解析失败
  56.             e.printStackTrace();
  57.             log.info("解析令牌失败，返回未登录错误信息");
  59.             Result error = Result.error("NOT_LOGIN");
  60.             //手动将错误信息转换为json格式，需要引入阿里巴巴的fastJSON依赖
  61.             String notLogin = JSONObject.toJSONString(error);
  62.             resp.getWriter().write(notLogin);
  63.             return;
  64.         }
  66.         //放行
  67.         log.info("令牌合法，放行");
  68.         filterChain.doFilter(servletRequest, servletResponse);
  69.     }
  70. }

需要的依赖：

  1. <!--        fastJSON-->
  2. <dependency>
  3.     <groupId>com.alibaba</groupId>
  4.     <artifactId>fastjson</artifactId>
  5.     <version>1.2.76</version>
  6. </dependency>

这时候，除了登录外的请求，我们都无法访问到信息：

在这里插入图片描述

先登录获取令牌：

在这里插入图片描述

发起其它请求时在请求头中将获取到的令牌传递过去，这样才能成功：

在这里插入图片描述

拦截器Interceptor

简介

  • 概念：是一种动态拦截方法调用的机制，类似于过滤器。Spring框架中提供的，用来动态拦截控制器方法的执行。
  • 作用：拦截请求，在指定的方法调用前后，根据业务需要执行预先设定的代码。

在这里插入图片描述
快速入门

  1. 定义拦截器，实现HandlerInterceptor接口，并重写其所有方法

    创建包 interceptor，在包下创建类 LoginCheckInterceptor，按住 Ctrl + O 可以选择实现接口的方法：

    1. import jakarta.servlet.http.HttpServletRequest;
    2. import jakarta.servlet.http.HttpServletResponse;
    3. import org.springframework.web.servlet.HandlerInterceptor;
    4. import org.springframework.web.servlet.ModelAndView;
    5. import org.springframework.stereotype.Component;
    7. @Component
    8. public class LoginCheckInterceptor implements HandlerInterceptor {
    10.     @Override   //目标资源方法执行前执行，返回true: 放行；返回false: 不放行
    11.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    13.         System.out.println("preHandle...");
    14.         return true;
    15.     }
    17.     @Override   //目标资源方法执行后执行
    18.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    20.         System.out.println("postHandle...");
    21.     }
    23.     @Override   //视图渲染完毕后执行，最后执行
    24.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    26.         System.out.println("afterCompletion...");
    27.     }
    28. }

  2. 注册拦截器

    创建包 config，在包下创建类 WebConfig：

    1. import com.xixi.interceptor.LoginCheckInterceptor;
    2. import org.springframework.beans.factory.annotation.Autowired;
    3. import org.springframework.context.annotation.Configuration;
    4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    7. @Configuration    //表示这是一个配置类
    8. public class WebConfig implements WebMvcConfigurer {
  1.         @Autowired
  2.         private LoginCheckInterceptor loginCheckInterceptor;
  4.         @Override
  5.         public void addInterceptors(InterceptorRegistry registry) {
  7.             registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**");  //拦截路径为所有
  8.         }
  9.     }

详解

拦截器——拦截路径

  • 拦截器可以根据需求，配置不同的拦截路径：

    在这里插入图片描述
    在这里插入图片描述

拦截器-执行流程

如果同时存在过滤器和拦截器，它们的执行顺序是这样的：

在这里插入图片描述

Filter 与 Interceptor 的不同点

  • 接口规范不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口。
  • 拦截范围不同：过滤器Filter会拦截所有的资源，而Interceptor只会拦截Spring环境中的资源。

登录校验- Interceptor

步骤

  • 获取请求url
  • 判断请求url中是否包含login，如果包含，说明是登录操作，放行
    获取请求头中的令牌（token）
  • 判断令牌是否存在，如果不存在，返回错误结果（未登录）
  • 解析token，如果解析失败，返回错误结果（未登录）
  • 放行

因为只有 preHandle 方法是 Controller 执行之前执行的，所以我们的登录校验要在 preHandle 方法中进行

首先将过滤器注释掉：

在这里插入图片描述

因为登录校验的逻辑是一样的，所以我们可以复制前面使用过滤器登录校验的代码，再稍微修改一下即可：

  1. import com.alibaba.fastjson.JSONObject;
  2. import com.xixi.pojo.Result;
  3. import com.xixi.utils.JwtUtils;
  4. import jakarta.servlet.http.HttpServletRequest;
  5. import jakarta.servlet.http.HttpServletResponse;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.util.StringUtils;
  9. import org.springframework.web.servlet.HandlerInterceptor;
  10. import org.springframework.web.servlet.ModelAndView;
  12. @Slf4j
  13. @Component
  14. public class LoginCheckInterceptor implements HandlerInterceptor {
  16.     @Override   //目标资源方法执行前执行，返回true: 放行；返回false: 不放行
  17.     public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception {
  19.         //获取请求url
  20.         String url = req.getRequestURL().toString();
  21.         log.info("请求的url：{}", url);
  23.         //判断请求url中是否包含login，如果包含，说明是登录操作，放行
  24.         if (url.contains("login")) {
  26.             log.info("登录操作，放行...");
  27.             return true;
  28.         }
  30.         //获取请求头中的令牌（token）
  31.         String jwt = req.getHeader("token");
  33.         //判断令牌是否存在，如果不存在，返回错误结果（未登录）
  34.         if (!StringUtils.hasLength(jwt)) {
  36.             log.info("请求token为空，返回未登录的信息");
  38.             Result error = Result.error("NOT_LOGIN");
  39.             //手动将错误信息转换为json格式，需要引入阿里巴巴的fastJSON依赖
  40.             String notLogin = JSONObject.toJSONString(error);
  41.             resp.getWriter().write(notLogin);
  42.             return false;
  43.         }
  45.         //解析token，如果解析失败，返回错误结果（未登录）
  46.         try {
  48.             JwtUtils.parseJWT(jwt);
  49.         } catch (Exception e) {
  50.      //jwt解析失败
  51.             e.printStackTrace();
  52.             log.info("解析令牌失败，返回未登录错误信息");
  54.             Result error = Result.error("NOT_LOGIN");
  55.             //手动将错误信息转换为json格式，需要引入阿里巴巴的fastJSON依赖
  56.             String notLogin = JSONObject.toJSONString(error);
  57.             resp.getWriter().write(notLogin);
  58.             return false;
  59.         }
  61.         //放行
  62.         log.info("令牌合法，放行");
  63.         return true;
  64.     }
  66.     @Override   //目标资源方法执行后执行
  67.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  69.         System.out.println("postHandle...");
  70.     }
  72.     @Override   //视图渲染完毕后执行，最后执行
  73.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  75.         System.out.println("afterCompletion...");
  76.     }
  77. }

接下来我们进行测试，先测试登录功能，成功获取到令牌：

在这里插入图片描述

在不传递令牌的情况下查询部门：

在这里插入图片描述

给出令牌再次查询，成功：

在这里插入图片描述

控制台：

在这里插入图片描述

异常处理

程序开发过程中不可避免的会遇到类似下面的异常现象：

在这里插入图片描述

出现这种错误信息是因为我们没有对异常进行处理，异常一直向上层抛去，直到抛到 spring 框架，它给我们返回了这样一个错误信息：

在这里插入图片描述

那么出现这种异常，该如何处理?

  • 方案一：在 Controller 的每个方法中进行 try…catch 处理（代码臃肿，不推荐）
  • 方案二：使用全局异常处理器（简单、优雅、推荐）

全局异常处理器

在这里插入图片描述

创建包 exception，在包下创建类 GlobalExceptionHandler：

  1. import com.xixi.pojo.Result;
  2. import org.springframework.web.bind.annotation.ExceptionHandler;
  3. import org.springframework.web.bind.annotation.RestControllerAdvice;
  5. @RestControllerAdvice
  6. public class GlobalExceptionHandler {
  9.     //定义一个方法来捕获所有异常
  10.     @ExceptionHandler(Exception.class)
  11.     public Result ex(Exception ex) {
  13.         ex.printStackTrace();
  14.         return Result.error("对不起，操作失败，请联系管理员");
  15.     }
  16. }

测试：

打开前端页面，添加一个已经存在的部门：

在这里插入图片描述

点击确定，会出现我们写的错误信息：

在这里插入图片描述

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，156人围观）

还没有评论，来说两句吧...

相关阅读

    相关 网络认证自动登录

    问题 公司最近一段时间更新网络架构, 新增了网络认证的流程, 并且每周日都会强制用户下线, 每周一来到公司都要重新登录, 一两次无所谓, 有时候忘记了, 直接打开网页打不

    野性酷女野性酷女/ 0 赞/ 277 阅读

    相关 安全登录认证

    用户登录是任何一个应用系统的基本功能，特别是对于网上银行系统来说，用户登录的安全性尤为重要。如何设计一个网站的安全登录认证程序，是本文主要讨论的问题。 　　静态密码存在着比较

    心已赠人心已赠人/ 0 赞/ 473 阅读