• ssm中项目异常处理

    一、异常处理器 

     

     思考1：

     思考2：

     其实，spring已经早早就帮我们解决好处理异常的问题了，不用我们再写AOP代码了，但是我们要按照spring处理异常的格式进行书写

    模拟一下前端发送访问资源请求后，收到的是异常信息（此时后端还没有做异常处理器）：

     前端访问增加功能的资源路径后，收到的信息如下：（这时前端就懵逼了，我TM访问的是增加功能，这tm返回的是什么东西~）

    因此我们后端就需要做异常处理了（这里演示的就是其他异常，不需要向系统异常和业务异常一样还需要创建个类，用来封装提示用户信息到属性中）：

    后端处理完异常后客户端再次访问增加功能资源后，会接收到什么信息：

     因此客户端又事B了说，我什么数据都没有接收啊，我这是咋回事啊，

    因此我们后端在处理完异常之后，可以返回一些数据给前端用户，那么用户就知道了，哦原来是后端出异常了啊~

     前端用户接收的信息如下所示：

    二、项目中不同种类异常的处理方式

    项目中出现的不同种类异常形式：

     那么如何处理上面三种类型的异常呢：

    代码演示如下所示：

    第一步：先把系统异常类、业务异常类写出来：（实际开发中业务中只出现系统异常的会，那么就写一个系统异常类就可以了，我这里是把三种情况（系统异常、业务异常、其他异常都写出来了），实际开发中出现哪个异常就写哪个异常类，然后通过异常处理器进行处理并且返回给用户提示信息就可以了）

    系统异常类：

    1. package com.itheima.exception;
    2.  
    3. /**
    4.  *  业务异常类
    5.  *
    6.  *  注：继承RuntimeException运行时异常类的目的就是运行时出现异常的时候不再手动往上抛了，自动帮我们往上抛
    7.  *
    8.  */
    9. public class SystemException extends RuntimeException{
    10.  
    11.     private Integer code;    // 加个code编号属性，来标注以后出现的是哪一种异常
    12.  
    13.     /**
    14.      *  把构造方法最好都写出来
    15.      */
    16.  
    17.     public SystemException(Integer code) {
    18.         this.code = code;
    19.     }
    20.  
    21.     public SystemException(String message, Integer code) {
    22.         super(message);
    23.         this.code = code;
    24.     }
    25.  
    26.     public SystemException(String message, Throwable cause, Integer code) {
    27.         super(message, cause);
    28.         this.code = code;
    29.     }
    30.  
    31.     public SystemException(Throwable cause, Integer code) {
    32.         super(cause);
    33.         this.code = code;
    34.     }
    35.  
    36.     public SystemException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, Integer code) {
    37.         super(message, cause, enableSuppression, writableStackTrace);
    38.         this.code = code;
    39.     }
    40.  
    41.     /**
    42.      *  getter and setter方法
    43.      */
    44.     public Integer getCode() {
    45.         return code;
    46.     }
    47.  
    48.     public void setCode(Integer code) {
    49.         this.code = code;
    50.     }
    51. }

    业务异常类：

    1. package com.itheima.exception;
    2.  
    3. /**
    4.  *  系统异常类
    5.  *
    6.  *  注：继承RuntimeException运行时异常类的目的就是运行时出现异常的时候不再手动往上抛了，自动帮我们往上抛
    7.  *
    8.  */
    9. public class BusinessException extends RuntimeException{
    10.  
    11.     private Integer code;    // 加个code编号属性，来用状态码标注以后出现的是哪一种异常
    12.  
    13.     /**
    14.      *  把构造方法最好都写出来
    15.      */
    16.  
    17.  
    18.     public BusinessException(Integer code) {
    19.         this.code = code;
    20.     }
    21.  
    22.     public BusinessException(String message, Integer code) {
    23.         super(message);
    24.         this.code = code;
    25.     }
    26.  
    27.     public BusinessException(String message, Throwable cause, Integer code) {
    28.         super(message, cause);
    29.         this.code = code;
    30.     }
    31.  
    32.     public BusinessException(Throwable cause, Integer code) {
    33.         super(cause);
    34.         this.code = code;
    35.     }
    36.  
    37.     public BusinessException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, Integer code) {
    38.         super(message, cause, enableSuppression, writableStackTrace);
    39.         this.code = code;
    40.     }
    41.  
    42.     /**
    43.      *  getter and setter方法
    44.      */
    45.     public Integer getCode() {
    46.         return code;
    47.     }
    48.  
    49.     public void setCode(Integer code) {
    50.         this.code = code;
    51.     }
    52. }

    第二步：假设业务端通过id查询功能的时候出现了系统异常（比如说：服务器宕机了）：

    那么就把系统异常捕获到后，把想要返回给前端用户的信息封装到系统异常类的属性当中（通过构造方法），然后通过异常处理器返回给前端用户信息

    注意1：假设系统异常和业务异常都出现在了业务层的某个功能中，那么先捕获到哪个种类的异常，异常处理器就会获取到该异常信息，并且把提示数据返回提示给用户（下面是先捕获的系统异常，因为系统异常排第一）

    1. package com.itheima.service.impl;
    2.  
    3. import com.itheima.controller.Code;
    4. import com.itheima.dao.BookDao;
    5. import com.itheima.domain.Book;
    6. import com.itheima.exception.BusinessException;
    7. import com.itheima.exception.SystemException;
    8. import com.itheima.service.BookService;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.stereotype.Service;
    11. import java.util.List;
    12.  
    13.  
    14. @Service
    15. public class BookServiceImpl implements BookService {
    16.  
    17.     /**
    18.      *  注入dao数据层依赖 : private BookDao bookDao;
    19.      *      然后等会spring容器拿到管理的业务层BookServiceImpl对象后，又因为业务层和数据层有依赖关系
    20.      *      通过依赖关系就可以调用数据层的增删改查功能了
    21.      */
    22.  
    23.     @Autowired // 自动装配（处理依赖关系）注解
    24.     private BookDao bookDao;
    25.  
    26.     // 增
    27.     public boolean save(Book book) {
    28.  
    29.         // 调用数据层的增加功能
    30.         bookDao.save(book);
    31.         return true;
    32.     }
    33.  
    34.     // 删
    35.     public boolean delete(Integer id) {
    36.  
    37.         // 调用数据层的删除功能
    38.         bookDao.delete(id);
    39.         return true;
    40.     }
    41.  
    42.     // 改
    43.     public boolean update(Book book) {
    44.  
    45.         // 调用数据层的修改功能
    46.         bookDao.update(book);
    47.         return true;
    48.     }
    49.  
    50.     // 通过id查询
    51.     public Book getById(Integer id) {
    52.  
    53.         /**
    54.          *  模拟假定这个地方出现了 系统异常（比如说：程序运行到这里后服务器宕机了）
    55.          *
    56.          *      我们用 1/0来模拟：服务器宕机
    57.          *
    58.          */
    59.         try {
    60.             int i =1/0; // 模拟系统异常
    61.         } catch (Exception e){    // 捕获到系统异常后，把想要返回给前端的信息封装到
    62.                                    // 系统异常类的属性中（通过构造方法）
    63.             throw new SystemException("服务器访问超时~",e, Code.SYSTEM_ERR);
    64.             // 把想返回给前端的信息封装到SystemException对象的属性当中
    65.             // Code.SYSTEM_ERR :系统异常状态码标识 50001
    66.         }
    67.         
    68.         /**
    69.          *  这里模拟假设出现了 业务异常
    70.          */
    71.  
    72.         if (id==2){
    73.             throw new BusinessException("请不要用你的技术挑战我的耐性~",Code.BUSINESS_ERR);
    74.             // Code.BUSINESS_ERR : 业务异常状态码标识 60001
    75.         }
    76.  
    77.         // 调用数据层的通过id查询功能
    78.         Book books = bookDao.getById(id);
    79.         return books;
    80.     }
    81.  
    82.     // 查询所有
    83.     public List getAll() {
    84.  
    85.         // 调用数据层的查询所有功能
    86.         List list = bookDao.getAll();
    87.         return list;
    88.     }
    89. }

    第三步：通过异常处理器进行系统或者业务或者其他异常处理并且把刚才封装到系统异常类/业务异常类属性中返回给客户的数据，返回给用户：

    细节：真正开发中，我们其实可以直接把这三种异常处理器写出来，然后项目中如果出现的是系统异常，那么就直接被系统异常处理器处理并且返回给用户信息即可了，如果是其他两种，也可以直接被其他两种异常处理器捕获到然后进行处理异常

    1. package com.itheima.controller;
    2.  
    3. import com.itheima.exception.BusinessException;
    4. import com.itheima.exception.SystemException;
    5. import org.springframework.web.bind.annotation.ExceptionHandler;
    6. import org.springframework.web.bind.annotation.RestControllerAdvice;
    7.  
    8. /**
    9.  *  spring处理异常 （异常处理器类）
    10.  */
    11.  
    12. // @ControllerAdvice // 这是普通风格处理异常的注解 （只要访问路径用的不是REST风格就用这个注解）
    13. @RestControllerAdvice   // 这是REST风格的处理异常的注解 （告诉spring这是一个处理异常的类的注解）
    14. // 注1：这个@RestControllerAdvice注解需要被SpringMvcConfig类的@ComponentScan({"com.itheima.controller"})注解
    15. // 扫描到，（SpringMvcConfig类的扫描注解刚好扫到controller包下，所以能扫到，因此如果换成其他的包，记得扫一下）
    16.  
    17. public class ProjectExceptionAdvice {
    18.  
    19.     /**
    20.      *  注： 系统异常处理器
    21.      *
    22.      * @return: 返回给前端信息
    23.      */
    24.  
    25.     @ExceptionHandler(SystemException.class)    // 该注解作用： 拦截是否是系统异常，是的话就调用下面的方法进行处理异常
    26.     public Result doSystemException(SystemException sy){
    27.             // (SystemException sy)：把SystemException对象传递过来（因为刚才业务层模拟系统异常的时候，把返回给前端的信息封装到sy对象属性中了）
    28.         /**
    29.          *  拿到系统异常之后需要做以下几步骤：
    30.          *  1、记录日志
    31.          *  2、发送给运维，开发人员
    32.          *  3、安抚一下客户（客户访问资源的时候出现异常了，咱们肯定要说一些好听的给用户）
    33.          */
    34.  
    35.         return new Result(null,sy.getCode(), sy.getMessage());
    36.         // 把封装到sy系统异常类属性中的系统异常状态码信息返回给用户
    37.     }
    38.  
    39.     /**
    40.      *  注： 业务异常处理器  （和系统异常处理器方式是一样的）
    41.      *
    42.      * @return: 返回给前端信息
    43.      */
    44.  
    45.     @ExceptionHandler(BusinessException.class)   //  拦截是否是业务异常，是的话就调用下面的方法进行处理异常
    46.     public Result doBusinessException(BusinessException bs){
    47.  
    48.  
    49.         return new Result(null,bs.getCode(),bs.getMessage());
    50.     }
    51.  
    52.     /**
    53.      *  注： 其他异常处理器 （可以理解为除了业务异常和系统异常之外的所有异常）
    54.      */
    55.  
    56.     @ExceptionHandler(Exception.class)    //  拦截是否是其他异常，是的话就调用下面的方法进行处理异常
    57.     public Result doException(){
    58.  
    59.         return new Result(null,0,"出现异常了铁子~");
    60.     }
    61. }

    假设客户端进行访问有系统异常的通过id查询的功能时候：

    补：Code类：专门用来储存成功/失败标识符号的

    1. package com.itheima.controller;
    2.  
    3.  
    4. /**
    5.  *      分析该类的作用：
    6.  *           标记状态码（比如1：表示成功，2：表示失败）的类，（ Result里面的 ）
    7.  *
    8.  *           注意：这些状态码不是固定的，是实际开发中前端程序员和后端程序员商量好规定的一种状态信息，
    9.  *           通过这些商量的状态码，就可以知道拿没拿到数据了
    10.  *
    11.  */
    12. public class Code {
    13.  
    14.     /**
    15.      *  调用增删改查功能成功的状态码标记
    16.      *
    17.      *  注：因为是static静态修饰的，所以可以直接用类名Code调用属性名
    18.      *  public修饰：代表公共的（也就是说，任何包下的只要通过类名. 的方式都可以调取到Code类下的属性值）
    19.      *
    20.      */
    21.     public static final Integer SAVE_OK = 20011;
    22.     public static final Integer DELETE_OK = 20021;
    23.     public static final Integer UPDATE_OK = 20031;
    24.     public static final Integer SELECT_OK = 20041;
    25.  
    26.     /**
    27.      *  调用增删改查功能失败的状态码标记
    28.      */
    29.     public static final Integer SAVE_ERR = 20010;
    30.     public static final Integer DELETE_ERR = 20020;
    31.     public static final Integer UPDATE_ERR = 20030;
    32.     public static final Integer SELECT_ERR = 20040;
    33.  
    34.  
    35.     /**
    36.      *  系统异常 & 业务异常成功/失败状态码标记
    37.      */
    38.     public static final Integer SYSTEM_ERR =50001; // 出现系统异常状态码
    39.     public static final Integer BUSINESS_ERR =60001;   // 出现业务异常状态码
    40.  
    41.  
    42. }

  • 相关阅读:
    osg给osg::Geometry（自己绘制的几何体）添加纹理(二)
    JVM之垃圾收集器三
    第5章 【MySQL】InnoDB数据页结构
    小白备战大厂算法笔试(七)——图
    Linux常用命令——cksum命令
    一文读懂Plato Farm的ePLATO，以及其高溢价缘由
    高考报志愿选什么专业？
    政策“春风”吹不停！人形机器人再迎新机遇！
    ETL工具— C/S 架构 为 数字基建 “安全” 保驾护航
    React 全栈体系（十一）
  • 原文地址：https://blog.csdn.net/lwj_07/article/details/126029100