SSM-SpringMVC-结果封装、异常、拦截器

已于 2025-01-14 14:16:37 修改
阅读量622 收藏 30
点赞数 12
文章标签： java 拦截器 异常
于 2025-01-06 18:42:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2302_78946634/article/details/144967131
版权

目录

一、统一结果封装

步骤

（1）创建Result类

（2）定义返回码code类

（3）修改Controller的返回值

二、统一异常处理

2.1 异常处理器的使用

@RestControllerAdvice 的功能

@ExceptionHandler 的功能

@ExceptionHandler 的用法

1. 用于单个控制器

2. 用于全局异常处理

2.2 项目异常处理方案

2.2.1 异常分类

2.2.2异常解决方案

三 拦截器

3.1 浏览器请求处理流程

3.2 拦截器的作用

3.3 过滤器与拦截器的区别

3.4 拦截器开发

3.5 拦截器参数

3.5.1 前置处理方法

3.5.2 完成处理方法afterCompletion

3.5.3 配置多个拦截器

一、统一结果封装

为了封装返回的结果数据:创建结果模型类，封装数据到data属性中

为了封装返回的数据是何种操作及是否操作成功:封装操作结果到code属性中

操作失败后为了封装返回的错误信息:封装特殊消息到message(msg)属性中  

设置统一数据返回结果类 

public class Result{
 private Object data;
 private Integer code;
 private String msg;
}

步骤

（1）创建Result类

public class Result {
    //描述统一格式中的数据
    private Object data;
    //描述统一格式中的编码，用于区分操作，可以简化配置0或1表示成功失败
    private Integer code;
    //描述统一格式中的消息，可选属性
    private String msg;
    public Result() {
   }
 //构造方法是方便对象的创建
    public Result(Integer code,Object data) {
        this.data = data;
        this.code = code;
   }
 //构造方法是方便对象的创建
    public Result(Integer code, Object data, String msg) {
        this.data = data;
        this.code = code;
        this.msg = msg;
   }
 //setter...getter...省略
}

（2）定义返回码code类

//状态码
public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;
 
    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

（3）修改Controller的返回值

//统一每一个控制器方法返回值
@RestController
@RequestMapping("/books")
public class BookController {
 
    @Autowired
    private BookService bookService;
 
    @PostMapping
    public Result save(@RequestBody Book book) {
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);
   }
 
    @PutMapping
    public Result update(@RequestBody Book book) {
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK:Code.UPDATE_ERR,flag);
   }
 
    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK:Code.DELETE_ERR,flag);
   }
 
    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "数据查询失败，请重试！";
        return new Result(code,book,msg);
   }
 
    @GetMapping
    public Result getAll() {
        List<Book> bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "" : "数据查询失败，请重试！";
        return new Result(code,bookList,msg);
   }
}

二、统一异常处理

在我们开发的任何一个位置都有可能出现异常，而且这些 异常是不能避免的。所以我们就得将异常进行处理。

2.1 异常处理器的使用

创建异常处理器

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public void doException(Exception ex){
     System.out.println("嘿嘿,异常你哪里跑！")
   }
}

当出现异常，异常能被拦截并执行doException方法。

如果想要按照特定格式返回给前端

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doException(Exception ex){
     System.out.println("嘿嘿,异常你哪里跑！")
        return new Result(666,null,"嘿嘿,异常你哪里跑！");
   }
}

@RestControllerAdvice 的功能

  1. 全局异常处理

    • 可以捕获所有 @RestController 中抛出的异常（包括自定义异常和系统异常）。
    • 使用 @ExceptionHandler 注解，在一个地方集中处理所有异常，避免每个控制器重复写异常处理逻辑。
@RestControllerAdvice
public class GlobalExceptionHandler {

    // 处理自定义业务异常
    @ExceptionHandler(BusinessException.class)
    public Response handleBusinessException(BusinessException ex) {
        return new Response(false, ex.getMessage(), null);
    }

    // 处理通用异常（如 NullPointerException）
    @ExceptionHandler(Exception.class)
    public Response handleException(Exception ex) {
        return new Response(false, "服务器内部错误", null);
    }
}

@ExceptionHandler 的功能

  1. 捕获指定类型的异常

    • 捕获当前控制器方法或全局的某些特定异常，例如 NullPointerException、IllegalArgumentException 或自定义异常。
    • 不需要每个控制器都写 try-catch，大大简化代码。

  2. 返回自定义响应

    • 可以定义返回值格式，通常用于构造统一的异常响应体（例如 JSON 格式）。

  3. 提高代码可读性

    • 将异常处理逻辑集中到一个地方，便于维护和修改。

@ExceptionHandler 的用法

1. 用于单个控制器

如果只想处理当前控制器中的异常，可以直接在控制器类中使用 @ExceptionHandler。

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public String getUserById(@PathVariable int id) {
        if (id <= 0) {
            throw new IllegalArgumentException("用户ID不能小于等于0");
        }
        return "用户信息";
    }

    @ExceptionHandler(IllegalArgumentException.class)
    public Map<String, Object> handleIllegalArgumentException(IllegalArgumentException ex) {
        Map<String, Object> response = new HashMap<>();
        response.put("success", false);
        response.put("message", ex.getMessage());
        return response;
    }
}
2. 用于全局异常处理

如果要处理所有控制器的异常，建议使用 @ControllerAdvice 或 @RestControllerAdvice，将异常处理逻辑集中在一个地方。

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 处理非法参数异常
    @ExceptionHandler(IllegalArgumentException.class)
    public Map<String, Object> handleIllegalArgumentException(IllegalArgumentException ex) {
        Map<String, Object> response = new HashMap<>();
        response.put("success", false);
        response.put("message", ex.getMessage());
        return response;
    }

    // 处理通用异常
    @ExceptionHandler(Exception.class)
    public Map<String, Object> handleException(Exception ex) {
        Map<String, Object> response = new HashMap<>();
        response.put("success", false);
        response.put("message", "服务器内部错误，请稍后重试");
        return response;
    }
}

2.2 项目异常处理方案

2.2.1 异常分类

业务异常（BusinessException）

系统异常（SystemException）

其他异常（Exception） 

将异常分类以后，针对不同类型的异常，要提供具体的解决方案

2.2.2异常解决方案

（1）自定义异常处理器

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class SystemException extends RuntimeException{
    private Integer code;
 
    public Integer getCode() {
        return code;
   }
 
    public void setCode(Integer code) {
        this.code = code;
   }
 
    public SystemException(Integer code, String message) {
        super(message);
        this.code = code;
   }
 
    public SystemException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
   }
 
}
 
//自定义异常处理器，用于封装异常信息，对异常进行分类
public class BusinessException extends RuntimeException{
    private Integer code;
 
    public Integer getCode() {
        return code;
   }
 
    public void setCode(Integer code) {
        this.code = code;
   }
 
    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
   }
 
    public BusinessException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
   }
 
}

让自定义异常类继承RuntimeException的好处是，后期在抛出这两个异常的时候，就不用在 try...catch...或throws了

自定义异常类中添加code属性的原因是为了更好的区分异常是来自哪个业务的

 （2）将其他异常包成自定义异常

public Book getById(Integer id) {
    //模拟业务异常，包装成自定义异常
    if(id == 1){
        throw new BusinessException(Code.BUSINESS_ERR,"请不要使用你的技术挑战我的
耐性!");
   }
    //模拟系统异常，将可能出现的异常进行包装，转换成自定义异常
    try{
        int i = 1/0;
   }catch (Exception e){
        throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请重
试!",e);
   }
    return bookDao.getById(id);
}

（3）处理器中处理自定义异常

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //@ExceptionHandler用于设置当前处理器类对应的异常类型
    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
   }
 
    @ExceptionHandler(BusinessException.class)
    public Result doBusinessException(BusinessException ex){
        return new Result(ex.getCode(),null,ex.getMessage());
   }
 
    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doOtherException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试！");
   }
}

三 拦截器

3.1 浏览器请求处理流程

  1. 浏览器发送请求到 Tomcat：

    • 静态资源（如 HTML、CSS、JS 等）：Tomcat 直接返回项目部署目录中的资源。
    • 动态资源（如接口请求）：将请求交给项目后台代码处理。

  2. 后台动态资源处理流程：

    1. 过滤器（Filter）：
      • 按照配置的顺序，依次执行多个过滤器（如果有）。
      • 过滤器可对所有请求进行拦截与处理。
    2. SpringMVC 中央处理器：
      • 根据请求路径匹配规则，定位到对应的 Controller 方法。
      • 如果找到匹配的 Controller 方法，则执行方法并返回结果。
      • 如果没有匹配的规则，则请求不会被处理。
    3. 拦截器（Interceptor）：
      • 拦截器可在请求进入 Controller 前、执行 Controller 方法后、或返回响应时，对请求进行增强或中断。

3.2 拦截器的作用

  • 核心功能：对 Controller 方法 的执行进行动态拦截和增强。
  • 执行阶段：
    1. 方法执行前（预处理）：
      • 检查请求是否满足条件（如权限验证、参数校验）。
      • 不符合条件可中断请求，不再执行目标方法。
    2. 方法执行后（后置处理）：
      • 对结果进行加工处理（如日志记录、响应值修改）。
    3. 返回响应时：
      • 进一步处理返回值或添加额外逻辑。
  • 使用场景：
    • 用户权限校验。
    • 参数或请求头的统一处理。
    • 日志记录。

 3.3 过滤器与拦截器的区别

过滤器（Filter）和拦截器（Interceptor）的区别：

  1. 技术归属不同：

    • 过滤器是属于Servlet规范的一部分，是 Java Web 技术的一部分。
    • 拦截器是SpringMVC框架提供的功能，只能在 Spring 环境下工作。

  2. 拦截范围不同：

    • 过滤器对所有请求都会生效，包括静态资源（比如 HTML、JS、CSS）和动态资源（比如后端接口请求）。
    • 拦截器只针对 SpringMVC 的控制器（Controller）方法生效，和具体的业务逻辑关联更紧密。

  3. 触发时机不同：

    • 过滤器是在请求到达 Servlet 容器时执行的，优先级高于拦截器。
    • 拦截器是在 SpringMVC 中，定位到控制器方法之前或之后执行的。

  4. 用途不同：

    • 过滤器多用于通用处理，比如请求的编码设置、跨域处理、权限验证等全局性的操作。
    • 拦截器多用于和业务逻辑有关的增强，比如登录验证、日志记录、业务数据的预处理等。

  5. 总结：

    • 过滤器更偏向于底层、全局性的拦截。
    • 拦截器更贴近业务层，与控制器方法密切相关。

示例对比：

  • 如果公司要求对所有请求都统一设置编码格式，比如 UTF-8，这种通用性功能用过滤器。
  • 如果需要对某些接口进行用户登录权限验证，这种业务逻辑就用拦截器。

3.4 拦截器开发

（1）创建拦截器类

让类实现HandlerInterceptor接口，重写接口中的三个方法。

@Component
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    @Override
    //原始方法调用前执行的内容
    public boolean preHandle(HttpServletRequest request, HttpServletResponse 
response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;
   }
 
    @Override
    //原始方法调用后执行的内容
    public void postHandle(HttpServletRequest request, HttpServletResponse 
response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
   }
 
    @Override
    //原始方法调用完成后执行的内容
    public void afterCompletion(HttpServletRequest request, 
HttpServletResponse response, Object handler, Exception ex) throws Exception 
{
        System.out.println("afterCompletion...");
   }
}

拦截器类要被SpringMVC容器扫描到。

 （2）配置拦截器类

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Autowired
    private ProjectInterceptor projectInterceptor;
 
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
       
 registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
   }
 
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        //配置拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books" 
);
   }
}

（3）简化SpringMvcSupport的编写

直接写在config里，此后就不用再写SpringMvcSupport类了。

@Configuration
@ComponentScan({"com.itheima.controller"})
@EnableWebMvc
//实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性
public class SpringMvcConfig implements WebMvcConfigurer {
    @Autowired
    private ProjectInterceptor projectInterceptor;
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //配置多拦截器
       
 registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books
/*");
   }
}

3.5 拦截器参数

3.5.1 前置处理方法

public boolean preHandle(HttpServletRequest request,
                         HttpServletResponse response,
                         Object handler) throws Exception {
    System.out.println("preHandle");
    return true;
}

request:请求对象

response:响应对象

handler:被调用的处理器对象，本质上是一个方法对象，对反射中的Method对象进行了再包装

使用request对象可以获取请求数据中的内容，如获取请求头的Content-Type

public boolean preHandle(HttpServletRequest request, HttpServletResponse 
response, Object handler) throws Exception {
    String contentType = request.getHeader("Content-Type");
    System.out.println("preHandle..."+contentType);
    return true;
}

 使用handler参数，可以获取方法的相关信息

public boolean preHandle(HttpServletRequest request, HttpServletResponse 
response, Object handler) throws Exception {
    HandlerMethod hm = (HandlerMethod)handler;
    String methodName = hm.getMethod().getName();//可以获取方法的名称
    System.out.println("preHandle..."+methodName);
    return true;
}

后置同前置

3.5.2 完成处理方法afterCompletion

拦截器最后执行的方法，无论原始方法是否执行

3.5.3 配置多个拦截器

当配置多个拦截器时，形成拦截器链

拦截器链的运行顺序参照拦截器添加顺序为准

当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作

starrismq
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值