• 【SpringBoot】统一功能处理

    目录

    🎃1 拦截器

    🎀1.1 拦截器的代码实现

    🎨1.2 拦截器的实现原理

    🧶2 拦截器应用——登录验证

    🦺3 异常统一处理

    🎭4 统一数据返回格式

    🧤4.1 为什么需要统一数据返回格式

    🧣4.2 统一返回对象

    👘4.3 统一数据处理(强制执行)

    本篇文章介绍 Spring Boot 的统一功能处理模块，也就是 AOP 的实战环节。

    1 拦截器

    没有登录的情况下，会跳转到登录页面。

    1.1 拦截器的代码实现

    Spring 提供了具体的实现拦截器：HandlerInterceptor，拦截器的实现分为以下两个步骤：

    1. 创建自定义拦截器，实现 HandlerInterceptor 接口，重写 preHandle 方法。（执行具体方法之前的预处理）。

    2. 将自定义拦截器加入 WebMvcConfigurer 的 addInterceptors 方法中。

    1. package com.example.demo.configuration;
    2.  
    3. import com.example.demo.common.AppVar;
    4. import org.springframework.stereotype.Component;
    5. import org.springframework.web.servlet.HandlerInterceptor;
    6.  
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9. import javax.servlet.http.HttpSession;
    10.  
    11. /**
    12.  * 自定义拦截器
    13.  */
    14. @Component
    15. public class UserInterceptor implements HandlerInterceptor {
    16.  
    17.     /**
    18.      * 返回 true -> 拦截器验证成功，继续执行后续的方法
    19.      *     false -> 拦截器验证失败，不会执行后续的目标方法
    20.      * @param request
    21.      * @param response
    22.      * @param handler
    23.      * @return
    24.      * @throws
    25.      */
    26.     @Override
    27.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    28.         System.out.println("do UserInterceptor"); // 拦截时候会打印
    29.  
    30.         // 业务方法
    31.         HttpSession session = request.getSession(false);
    32.         if(session != null &&
    33.         session.getAttribute(AppVar.SESSION_KEY) != null){
    34.             // 用户已经登录了
    35.             return true; // 继续执行后续流程
    36.         }
    37.         // 未登录的情况，跳转到 百度
    38.         response.sendRedirect("https://www.baidu.com");
    39.         return false;
    40.     }
    41. }
    1. package com.example.demo.common;
    2.  
    3. /**
    4.  * 全局变量
    5.  */
    6. public class AppVar {
    7.     // Session Key
    8.     public static final String SESSION_KEY = "SESSION_KEY";
    9. }

    1. package com.example.demo.configuration;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    7.  
    8. /**
    9.  * 将自定义拦截器加入到系统配置
    10.  * 有两种写法
    11.  * 一是 new 一个 UserInterceptor 对象
    12.  * 二是 注入的方式
    13.  */
    14. @Configuration
    15. public class AppConfig implements WebMvcConfigurer {
    16.  
    17.     @Autowired
    18.     private UserInterceptor userInterceptor;
    19.  
    20.     @Override
    21.     public void addInterceptors(InterceptorRegistry registry) {
    22.         // registry.addInterceptor(new UserInterceptor());
    23.  
    24.         registry.addInterceptor(userInterceptor)
    25.                 .addPathPatterns("/**") // 拦截所有请求
    26.                 .excludePathPatterns("/user/reg") // 登录页面不拦截
    27.                 .excludePathPatterns("/user/login") // 注册页面不拦截
    28.         ;
    29.     }
    30. }

     * 一级路由，** 所有路由。

    /user 就是一级路由，/user/reg 是二级路由。

    addPathPatterns 表示需要拦截的 URL，** 表示拦截所有方法

    excludePathPattern 表示需要排除的 URL 

    1. package com.example.demo.controller;
    2.  
    3. import org.springframework.web.bind.annotation.RequestMapping;
    4. import org.springframework.web.bind.annotation.RestController;
    5.  
    6. @RestController
    7. @RequestMapping("/user")
    8. public class UserController {
    9.     @RequestMapping("/getuser")
    10.     public String getUser(){
    11.         System.out.println("do getUser()");
    12.         return "getuser";
    13.     }
    14.  
    15.     @RequestMapping("/reg")
    16.     public String reg(){
    17.         System.out.println("do reg()");
    18.         return "reg";
    19.     }
    20.  
    21.     @RequestMapping("/login")
    22.     public String getlogin(){
    23.         System.out.println("do login()");
    24.         return "login";
    25.     }
    26. }

    输出：

    do UserInterceptor
    do reg()
    do login()

    1.2 拦截器的实现原理

    正常情况下的调用顺序：

    有了拦截器之后，在调用 controller 之前，会执行拦截器，如果为 true，则继续执行后续程序，如果为 false，则跳转相关页面。

    2 拦截器应用——登录验证

    1. package com.example.demo.configuration;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    7.  
    8. /**
    9.  * 将自定义拦截器加入到系统配置
    10.  * 有两种写法
    11.  * 一是 new 一个 UserInterceptor 对象
    12.  * 二是 注入的方式
    13.  */
    14. @Configuration
    15.  
    16. public class AppConfig implements WebMvcConfigurer {
    17.  
    18.     @Autowired
    19.     private UserInterceptor userInterceptor;
    20.  
    21.     @Override
    22.     public void addInterceptors(InterceptorRegistry registry) {
    23.         // registry.addInterceptor(new UserInterceptor());
    24.  
    25.         registry.addInterceptor(userInterceptor)
    26.                 .addPathPatterns("/**") // 拦截所有请求
    27.                 .excludePathPatterns("/user/reg") // 登录页面不拦截
    28.                 .excludePathPatterns("/reg.html")
    29.                 .excludePathPatterns("/login.html")
    30.                 .excludePathPatterns("/css/**")
    31.                 .excludePathPatterns("/editor.md/**")
    32.                 .excludePathPatterns("/img/**")
    33.                 .excludePathPatterns("/js/**")
    34.                 .excludePathPatterns("/user/login") // 注册页面不拦截
    35.                 .excludePathPatterns("/image/**") // image 文件下所有的图片格式拦截
    36.         ;
    37.     }
    38. }

    除了注册页面、登录页面之外，其余页面都会跳转到百度。

    3 异常统一处理

    1.     @RequestMapping("/reg")
    2.     public String reg(){
    3.         System.out.println("do reg()");
    4.         Object obj = null;
    5.         System.out.println(obj.hashCode());
    6.         return "reg";
    7.     }

    如果每个页面都出现异常，可不可以统一处理呢？

    出现的所有异常按照统一的格式返回： 

    1. package com.example.demo.common;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 统一返回对象
    7.  */
    8. @Data
    9. public class ResultAjax {
    10.     private int code;  // 状态码
    11.     private String msg; // 状态码的描述信息
    12.     private Object data; // 返回数据
    13. }

    异常统一处理时，需要两个注解。一个是 @ControllerAdvice / @RestControllerAdvice ，另一个是 @ExceptionHandler(Exception.class) 统一返回对象。

    1. package com.example.demo.configuration;
    2.  
    3. import com.example.demo.common.ResultAjax;
    4. import org.springframework.web.bind.annotation.ExceptionHandler;
    5. import org.springframework.web.bind.annotation.RestControllerAdvice;
    6.  
    7. @RestControllerAdvice
    8. public class ExceptionAdvice {
    9.     @ExceptionHandler(NullPointerException.class)
    10.     public ResultAjax doNullPointerException(NullPointerException e){
    11.         ResultAjax resultAjax = new ResultAjax();
    12.         resultAjax.setCode(-1);
    13.         resultAjax.setMsg("空指针异常："+e.getMessage());
    14.         resultAjax.setData(null);
    15.         return resultAjax;
    16.     }
    17. }

    再举一个算术异常的例子：

    由于所有的异常都继承自 Exception，所以  @ExceptionHandler(Exception.class) 里面的异常类不用写那么详细也可以：

    1.     @RequestMapping("/login")
    2.     public String login(){
    3.         System.out.println("do login()");
    4.         int num = 10 / 0;
    5.         return "login";
    6.     }
    1.     @ExceptionHandler(Exception.class)
    2.     public ResultAjax doException(Exception e){
    3.         ResultAjax resultAjax = new ResultAjax();
    4.         resultAjax.setCode(-1);
    5.         resultAjax.setMsg("异常："+e.getMessage());
    6.         resultAjax.setData(null);
    7.         return resultAjax;
    8.     }

    4 统一数据返回格式

    4.1 为什么需要统一数据返回格式

    统⼀数据返回格式的优点有很多，⽐如以下⼏个：

    1. ⽅便前端程序员更好的接收和解析后端数据接⼝返回的数据。

    2. 降低前端程序员和后端程序员的沟通成本，按照某个格式实现就⾏了，因为所有接⼝都是这样返回 的。

    3. 有利于项⽬统⼀数据的维护和修改。

    4. 有利于后端技术部⻔的统⼀规范的标准制定，不会出现稀奇古怪的返回内容。

    4.2 统一返回对象

    对 ResultAjax 这个类进行改造，添加两种方法，一是成功之后返回的数据，二是失败之后返回的数据。

    1. package com.example.demo.common;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 统一返回对象
    7.  */
    8. @Data
    9. public class ResultAjax {
    10.     private int code;  // 状态码
    11.     private String msg; // 状态码的描述信息
    12.     private Object data; // 返回数据
    13.  
    14.     /**
    15.      * 成功时返回
    16.      * @param data
    17.      * @return
    18.      */
    19.     public static ResultAjax success(Object data){
    20.         ResultAjax resultAjax = new ResultAjax();
    21.         resultAjax.setCode(200);
    22.         resultAjax.setMsg("");
    23.         resultAjax.setData(data);
    24.         return resultAjax;
    25.     }
    26.  
    27.     public static ResultAjax success(String msg, Object data){
    28.         ResultAjax resultAjax = new ResultAjax();
    29.         resultAjax.setCode(200);
    30.         resultAjax.setMsg(msg);
    31.         resultAjax.setData(data);
    32.         return resultAjax;
    33.     }
    34.     
    35.     public static ResultAjax fail(int code, String msg){
    36.         ResultAjax resultAjax = new ResultAjax();
    37.         resultAjax.setCode(code);
    38.         resultAjax.setMsg(msg);
    39.         resultAjax.setData(null);
    40.         return resultAjax;
    41.     }
    42.  
    43.     public static ResultAjax fail(int code, String msg, Object data){
    44.         ResultAjax resultAjax = new ResultAjax();
    45.         resultAjax.setCode(code);
    46.         resultAjax.setMsg(msg);
    47.         resultAjax.setData(data);
    48.         return resultAjax;
    49.     }
    50.     
    51. }
    1. package com.example.demo.controller;
    2.  
    3. import com.example.demo.common.ResultAjax;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. @RestController
    8. @RequestMapping("/user")
    9. public class UserController {
    10.     @RequestMapping("/getuser")
    11.     public ResultAjax getUser(){
    12.         System.out.println("do getUser()");
    13.         return ResultAjax.success("getuser");
    14.     }
    15.  
    16.     @RequestMapping("/reg")
    17.     public ResultAjax reg(){
    18.         System.out.println("do reg()");
    19.         return ResultAjax.success("reg");
    20.     }
    21.  
    22.     @RequestMapping("/login")
    23.     public ResultAjax login(){
    24.         System.out.println("do login()");
    25.         return ResultAjax.success("login");
    26.     }
    27. }

    4.3 统一数据处理(强制执行)

    如果就是有人不按要求返回 ResultAjax 这一格式呢？比如下面这样：

    1.     @RequestMapping("getnum")
    2.     public int getNum(){
    3.         System.out.println("getNum()");
    4.         return 1;
    5.     }

    这时就可以对返回的数据进行统一处理，这是强制执行的。

    使用：

    1. @ControllerAdvice 

    2. 实现 ResponseBodyAdvice 接口，并重写它的两个方法，supports 必须返回 true，beforeBodyWrite 方法中进行重新判断和重写操作。

    1. package com.example.demo.configuration;
    2.  
    3. import com.example.demo.common.ResultAjax;
    4. import org.springframework.core.MethodParameter;
    5. import org.springframework.http.MediaType;
    6. import org.springframework.http.server.ServerHttpRequest;
    7. import org.springframework.http.server.ServerHttpResponse;
    8. import org.springframework.web.bind.annotation.ControllerAdvice;
    9. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    10.  
    11. @ControllerAdvice
    12. public class ResponAdvice implements ResponseBodyAdvice {
    13.     @Override
    14.     public boolean supports(MethodParameter returnType, Class converterType) {
    15.         return true;
    16.     }
    17.  
    18.     @Override
    19.     public Object beforeBodyWrite(Object body, MethodParameter returnType,
    20.                                   MediaType selectedContentType,
    21.                                   Class selectedConverterType,
    22.                                   ServerHttpRequest request,
    23.                                   ServerHttpResponse response) {
    24.         // 已经包装好的对象
    25.         // body 是 ResultAjax 的格式
    26.         if(body instanceof ResultAjax){
    27.             return body;
    28.         }
    29.  
    30.         // 对字符串进行判断和处理
    31.         // 重新封装成 ResultAjax 的格式
    32.         return ResultAjax.success(body);
    33.  
    34.     }
    35. }

    1.     @RequestMapping("/getstr")
    2.     public String getStr(){
    3.         System.out.println("getStr()");
    4.         return "whoooooo~~";
    5.     }

     如果返回的是 String，而不是 int 类型，会报错。在把 String 转化成 json格式的时候报错了。所以对于返回类型是 String 的话，需要单独处理。不使用 String 解析引擎，而是手动转成 json。

    1. package com.example.demo.configuration;
    2.  
    3. import com.example.demo.common.ResultAjax;
    4. import com.fasterxml.jackson.core.JsonProcessingException;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.core.MethodParameter;
    8. import org.springframework.http.MediaType;
    9. import org.springframework.http.server.ServerHttpRequest;
    10. import org.springframework.http.server.ServerHttpResponse;
    11. import org.springframework.web.bind.annotation.ControllerAdvice;
    12. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    13.  
    14. @ControllerAdvice
    15. public class ResponAdvice implements ResponseBodyAdvice {
    16. //    springboot 框架自动注入
    17.     @Autowired
    18.     private ObjectMapper objectMapper;
    19.     
    20.     @Override
    21.     public boolean supports(MethodParameter returnType, Class converterType) {
    22.         return true;
    23.     }
    24.  
    25.     @Override
    26.     public Object beforeBodyWrite(Object body, MethodParameter returnType,
    27.                                   MediaType selectedContentType,
    28.                                   Class selectedConverterType,
    29.                                   ServerHttpRequest request,
    30.                                   ServerHttpResponse response) {
    31.         // 已经包装好的对象
    32.         // body 是 ResultAjax 的格式
    33.         if(body instanceof ResultAjax){
    34.             return body;
    35.         }
    36.  
    37.         // 对字符串进行判断和处理
    38.         // 手动转换成 json 格式
    39.         if(body instanceof String){
    40.             ResultAjax resultAjax = ResultAjax.success(body);
    41.             try {
    42.                 return objectMapper.writeValueAsString(resultAjax);
    43.             } catch (JsonProcessingException e) {
    44.                 e.printStackTrace();
    45.             }
    46.  
    47.         }
    48.         
    49.         return ResultAjax.success(body);
    50.  
    51.     }
    52. }

    如果返回的是对象呢？ 

    1.     @RequestMapping("/usermsg")
    2.     public User usermsg(){
    3.         User user = new User();
    4.         user.setId(263);
    5.         user.setName("柳飘飘");
    6.         user.setPassword("96134");
    7.         return user;
    8.     }

  • 相关阅读:
    Linux ❀ 进程出现process information unavailable时的消除方法
    高空抛物检测方案设计（使用SOM进行轨迹分类）
    vulnhub DriftingBlues: 6
    CVE-2023-32315：Openfire管理控制台身份验证绕过到RCE的复现
    基于VTD自带的场景 进行场景搭建
    linux系统Jenkins工具介绍
    基于python的pulp库使用，从基础模型到复杂模型，从一维变量到二维变量
    matlab相机标定求得相机内参
    Jvm上如何运行其他语言？JSR223规范最详细讲解
    【代码源每日一题】饿饿 饭饭「二分答案」
  • 原文地址：https://blog.csdn.net/qq_41233305/article/details/132639139