Bagaimana untuk mengkonfigurasi pengendali pengecualian global SpringBoot untuk menangkap pengecualian

1. Kata Pengantar

Dalam mana-mana sistem, kami tidak akan menangkap dan mengendalikan pengecualian secara bodoh di setiap tempat Secara amnya, kami akan mengendalikan pengecualian di satu tempat untuk keseluruhan sistem, dan mengendalikan pengecualian global dalam but musim bunga. Sangat mudah;

Pemisahan hujung depan dan belakang, API hujung belakang, secara amnya untuk pengendalian pengecualian, hanya ada dua perkara yang perlu dilakukan,

1 pemprosesan, ini Ia adalah dalaman

2. Ia mengembalikan hasil kepada pemanggil API, iaitu luaran

Untuk pemanggil API, dia hanya Ia perlukan hasil pulangan (termasuk kod ralat dan maklumat segera), dan dia tidak mengambil berat tentang yang lain

Untuk bahagian belakang, ia hanya perlu merekodkan log, memberitahu atau menerbitkan mesej yang sepadan dengan baris gilir lain untuk memproses perkara berkaitan ;

Jadi: Saya telah melihat ramai orang merangkum banyak kelas pengecualian tersuai Sebenarnya, anda hanya memerlukan satu pengendali pengecualian untuk mengendalikan semua pengecualian, dan kemudian merangkumkan kod pengenalan ralat dan mesej segera. Penghitungan digunakan untuk kembali kepada pemanggil API; kemudian pemprosesan bahagian belakang boleh diproses secara langsung dalam satu kaedah pengendalian pengecualian Tidak perlu merangkumkan N berbilang pengecualian tersuai, yang tidak masuk akal

>Pemahaman ideologi tentang pengecualian

Kita harus sedar bahawa semua keabnormalan adalah manifestasi abnormal sistem, adalah kecacatan, dan adalah BUG, ​​walaupun beberapa pengecualian adalah Kami secara aktif membuangnya

Apa yang perlu kita lakukan ialah cuba meningkatkan ketersediaan sistem dan mengelakkan berlakunya sebarang pengecualian ke tahap yang paling besar, dan bukannya bergantung pada pengendalian pengecualian yang sempurna untuk menambah baik sistem

Pengendalian Pengecualian ialah langkah kecemasan yang diambil apabila pengecualian tidak dapat dielakkan berlaku. Tujuan utama adalah untuk meningkatkan keramahan kepada dunia luar dan memberikan petunjuk pemulihan kepada bahagian dalam

Jangan fikir bahawa pengendalian pengecualian yang sempurna adalah teras sistem, bukan. t mengharapkan pengendalian pengecualian menjadi sempurna, jangan mengharapkan pengendalian pengecualian untuk menghapuskan kecacatan sistem

Jika sistem mempunyai terlalu banyak pengecualian, maka apa yang anda perlu lakukan ialah tidak menambah baik mekanisme pengendalian pengecualian, tetapi untuk memikirkan seni bina sistem: Sama ada reka bentuk itu munasabah dan sama ada reka bentuk logik sistem adalah munasabah

2 Kaedah 1 pengendalian pengecualian global (@ControllerAdvice dan @ExceptionHandler)

==. ==================================

Dalam pembangunan, kami akan mempunyai Senario berikut: Terdapat beberapa pengecualian perniagaan dalam antara muka tertentu. Sebagai contoh, parameter yang dimasukkan oleh pengguna gagal untuk disahkan, nama pengguna dan kata laluan tidak wujud, dsb. Apabila pengecualian perniagaan ini dicetuskan, kita perlu membuang pengecualian perniagaan tersuai ini dan mengendalikannya. Secara amnya, kita perlu mengembalikan kod status dan perihalan pengecualian maklumat pengecualian ini kepada pemanggil dengan cara yang mesra, dan pemanggil menggunakan kod status dan maklumat lain untuk menentukan keadaan khusus pengecualian.

Pada masa lalu, kita mungkin perlu mengendalikannya melalui try/catch pada lapisan pengawal. Mula-mula tangkap pengecualian tersuai, kemudian tangkap pengecualian lain. Untuk pengecualian yang berbeza, kita perlu merangkum objek yang akan dikembalikan semasa menangkap. Walau bagaimanapun, kelemahan ini ialah kod menjadi bertele-tele. Setiap antara muka memerlukan pemprosesan cuba/tangkap, dan sebaik sahaja ia perlu dilaraskan, semua antara muka perlu diubah suai, yang sangat memudaratkan penyelenggaraan kod, seperti yang ditunjukkan dalam kod berikut

@RequestMapping (value = "/test")
public ResponseEntity test() {
    ResponseEntity re = new ResponseEntity();
    // 业务处理
    // ...
    try {
        // 业务
    } catch (BusinessException e) {
        logger.info("业务发生异常，code:" + e.getCode() + "msg:" + e.getMsg());
        re.setCode(e.getCode());
        re.setMsg(e.getMsg());
        return re;
    } catch (Exception e) {
        logger.error("服务错误:", e);
        re.setCode("xxxxx");
        re.setMsg("服务错误");
        return re;
    }
    return re;
}

Jadi, adakah ada cara untuk melakukan ini? Bagaimana untuk mengendalikan mesej pengecualian ini dengan mudah? Jawapannya ya. Dalam Spring 3.2, anotasi @ControllerAdvice ditambahkan, yang boleh digunakan untuk mentakrifkan @ExceptionHandler, @InitBinder dan @ModelAttribute, dan digunakan pada semua @RequestMapping. Ringkasnya, anda boleh mengkonfigurasi kelas pengendalian pengecualian global melalui anotasi @ControllerAdvice untuk mengendalikan pengecualian secara seragam dalam lapisan pengawal Pada masa yang sama, tidak perlu menulis try/catch dalam pengawal, yang menjadikan kod itu bersih dan mudah dijaga.

Penggunaan

Tentukan pengecualian tersuai

Pengetahuan yang berkaitan tentang pengecualian tersuai tidak akan diterangkan secara terperinci di sini tak tahu, cari sendiri. Tampal kelas pengecualian perniagaan tersuai mudah di sini.

/**
 * 自定义业务异常类
 *
 * @author Yuzhe Ma
 * @date 2018/11/28
 */
@Data
public class BusinessException extends RuntimeException {
    private String code;
    private String msg;
 
    public BusinessException(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

Nota: @Data ialah pemalam Lombok. Menjana kaedah set/dapat secara automatik. Kaedah penggunaan khusus tidak akan diperkenalkan di sini.

@ControllerAdvice + @ExceptionHand` Konfigurasikan kelas pengendalian pengecualian global

/**
 * 全局异常处理器
 *
 * @author Yuzhe Ma
 * @date 2018/11/12
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
 
    /**
     * 处理 Exception 异常
     *
     * @param httpServletRequest httpServletRequest
     * @param e                  异常
     * @return
     */
    @ResponseBody
    @ExceptionHandler(value = Exception.class)
    public ResponseEntity exceptionHandler(HttpServletRequest httpServletRequest, Exception e) {
        logger.error("服务错误:", e);
        return new ResponseEntity("xxx", "服务出错");
    }
 
    /**
     * 处理 BusinessException 异常
     *
     * @param httpServletRequest httpServletRequest
     * @param e                  异常
     * @return
     */
    @ResponseBody
    @ExceptionHandler(value = BusinessException.class)
    public ResponseEntity businessExceptionHandler(HttpServletRequest httpServletRequest, BusinessException e) {
        logger.info("业务异常。code:" + e.getCode() + "msg:" + e.getMsg());
        return new ResponseEntity(e.getCode(), e.getMsg());
    }
}

@ControllerAdvice

Tentukan kelas ini sebagai global pengecualian Kelas pemprosesan.

@ExceptionHandler

Takrifkan kaedah ini sebagai kaedah pengendalian pengecualian. Nilai nilai ialah fail kelas bagi kelas pengecualian yang perlu dikendalikan. Dalam contoh, kaedah itu diluluskan dalam dua parameter. Satu ialah kelas pengecualian Pengecualian yang sepadan, dan satu lagi ialah kelas HttpServletRequest. Sudah tentu, sebagai tambahan kepada dua parameter ini, beberapa parameter lain juga disokong.

Dengan cara ini, pengecualian yang berbeza boleh dikendalikan secara seragam. Biasanya, untuk mengelak daripada menggunakan sebarang cubaan/tangkap dalam pengawal, Exception juga boleh diproses secara seragam dalam GlobalExceptionHandler. Dengan cara ini, pengecualian lain yang tidak dikonfigurasikan dengan @ExceptionHandler akan dikendalikan secara seragam.

Cukup buang pengecualian apabila menghadapi pengecualian

Dalam perniagaan, apabila anda menghadapi pengecualian perniagaan, hanya gunakan lontaran untuk membuang pengecualian perniagaan yang sepadan. Contohnya,

throw new BusinessException("3000", "账户密码错误");

ditulis dalam Pengawal sebagai

Controller 中，不需要再写 try/catch，除非特殊用途。

@RequestMapping(value = "/test")
public ResponseEntity test() {
    ResponseEntity re = new ResponseEntity();
    // 业务处理
    // ...
    return re;
}

结果展示

异常抛出后，返回如下结果。

{
    "code": "3000",
    "msg": "账户密码错误",
    "data": null
}

注意 不一定必须在 controller 层本身抛出异常才能被 GlobalExceptionHandler 处理，只要异常最后是从 contoller 层抛出去的就可以被全局异常处理器处理。异步方法中的异常不会被全局异常处理。抛出的异常如果被代码内的 try/catch 捕获了，就不会被 GlobalExceptionHandler 处理了。总结

本文介绍了在 SpringBoot 中，通过配置全局异常处理器统一处理 Controller 层引发的异常。

优点

减少代码冗余，代码便于维护

缺点

只能处理 controller 层抛出的异常，对例如 Interceptor（拦截器）层的异常、定时任务中的异常、异步方法中的异常，不会进行处理。

3.全局异常并处理的方法二 (AOP)

虽然@ControllerAdvice注解通常和@ExceptionHandler注解用于全局异常的处理。

但是这种方式有个缺点就是，只是对控制层进行了异常拦截，比如像工具类中或者其他类中的异常，并不会拦截。

由于业务执行时不能保证程序不出错,所以写代码必须添加try-catch,但是如果频繁的添加try-catch则必然导致代码结构混乱.所以需要进行优化.

原则:如果出现了问题一般将检查异常,转化为运行时异常.

核心原理: 代理动态思想------->AOP操作

采用自定义AOP的方式可以实现拦截。

有几个关键点

1. 定义切入点为最大项目包

2. 采用AOP的@AfterThrowing注解获取到全局异常捕获一个例子package com.example.promethuesdemo.exception; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; import org.springframework.stereotype.Component; /** * @author chenzhen * Created by chenzhen on 2020/7/20.

*/
    @Aspect
    @Slf4j
    @Component
    public class GlobalExceptionAspect {
        @Pointcut("execution(* com.example..*.*(..))")
        public void pointcut(){
 
        }
 
        @AfterThrowing(pointcut = "pointcut()",throwing = "e")
        public void afterThrowing(JoinPoint joinPoint,Throwable e){
            log.error("全局捕获到异常了..............");
            //纪录错误信息
            log.error("系统错误:{}", e.getMessage());
            // todo 想要执行的操作
        }
 
    }

aop中相关概念

Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。* Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它

joint point。* Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。* Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。* Target（目标对象）：织入 Advice 的目标对象.。 Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

Advice（增强）的类型

before advice, 在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中,不能人为地决定是否继续执行 join point 中的代码)* after return advice, 在一个 join point 正常返回后执行的 advice* after throwing advice, 当一个 join point 抛出异常后执行的 advice* after(final) advice, 无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice.* around advice, 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice.* introduction，introduction可以为原有的对象增加新的属性和方法。

注意

spring AOP中的AfterThrowing增强处理可以对目标方法的异常进行处理，但这种处理与直接使用catch捕捉处理异常的方式不同，catch捕捉意味着能完全处理异常，即只要catch块本身不抛出新的异常，则被处理的异常不会往上级调用者进一步传播下去；但是如果使用了AfterThrowing增强处理用于对异常进行处理，处理后异常仍然会往上一级调用者传播，如果是在main中调用的目标方法，那么异常会直接传到JVM，如下截图所示：

SpringBoot 之配置全局异常处理器捕获异常

Juga ambil perhatian bahawa jika pengecualian berlaku dalam kaedah sasaran dan dikendalikan oleh tangkapan dan tangkapan tidak membuang pengecualian baharu, maka pemprosesan peningkatan AfterThrowing untuk kaedah sasaran tidak akan dilaksanakan.

Atas ialah kandungan terperinci Bagaimana untuk mengkonfigurasi pengendali pengecualian global SpringBoot untuk menangkap pengecualian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!