SpringBoot entry series (11) Implementación de manejo unificado de excepciones SpringBoot entry series (4) Motor de plantillas integrado Thymeleaf

La sección anterior describe cómo Spring Boot integra las tareas programadas y cómo Spring Boot crea tareas asincrónicas y tareas programadas. Amigos poco claros pueden echar un vistazo al artículo anterior: " Spring Boot Getting Started Series "

A continuación, explicamos principalmente cómo usar el manejo unificado de excepciones en las aplicaciones Spring Boot.

Por qué el manejo unificado de excepciones

La forma de desarrollo del proyecto es la separación del front-end y el back-end, que se desarrolla en forma de interfaz Restful. El manejo de excepciones y los datos comerciales de la página se devuelven en forma json. Sin embargo, si se producen en el fondo excepciones como las excepciones de la base de datos, las excepciones de Shiro, las excepciones de Redis, etc., el front end generalmente muestra una página de error muy fea, que es muy hostil para los usuarios, por lo que debemos manejar todas las excepciones del sistema Y luego devuelve el resultado que queremos.

Cómo lograr

Hay dos métodos principales para que Spring Boot implemente el manejo unificado de excepciones:

El primero: use las anotaciones @ControllerAdvice y @ExceptionHandler

El segundo: use la clase ErrorController para lograr.

La forma de usar ErrorController es relativamente simple, por lo que no la presentaré aquí. Hoy hablaré principalmente sobre cómo implementar el manejo unificado de excepciones usando las anotaciones @ControllerAdvice y @ExceptionHandler.

1. Manejo de excepciones unificadas

paquete com.weiz.exception; 

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; 

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
importar org.springframework.web.servlet.ModelAndView; 

import com.weiz.utils.JSONResult; 

@ControllerAdvice 
public  class GlobalExceptionHandler { 

    public  static  final String ERROR_VIEW = "error" ; 


    @ExceptionHandler (value = Exception. Class )
     publicObject errorHandler (HttpServletRequest reqest, 
            HttpServletResponse response, Exception e) lanza Exception { 
        
        e.printStackTrace (); 
        // 是否 ajax 请求
        if (isAjax (reqest)) {
             return JSONResult.errorException (e.getMessage ()); 
        } else { 
            ModelAndView mav = new ModelAndView (); 
            mav.addObject ( "excepción" , e); 
            mav.addObject ( "url" , reqest.getRequestURL ()); 
            mav.setViewName (ERROR_VIEW); 
            volver mav; 
        } 
    }
    
    public  static  boolean isAjax (HttpServletRequest httpRequest) {
         return   (httpRequest.getHeader ("X-Requested-With")! = null   
                    && "XMLHttpRequest" 
                        .equals (httpRequest.getHeader ( "X-Requested-With" ))); 
    } 
}

Descripción:

　　1. La anotación @ControllerAdvice indica que esta es una clase de mejora de controlador. Cuando se produce una excepción en el controlador, será interceptada por este interceptor.

　　2. La anotación @ExceptionHandler define la clase de excepción interceptada, que puede obtener la información de excepción lanzada. Aquí puede definir múltiples métodos de intercepción para interceptar diferentes clases de excepciones, y puede obtener la información de la excepción lanzada con mayor libertad.

2. Página de error

<! DOCTYPE html> 
<html> 
<head lang = "en"> 
    <meta charset = "UTF-8" /> 
    <title> 捕获 全局 异常 </title> 
</head> 
<body> 
    <h1 style = "color : rojo "> 发生 错误 ： </h1> 
    <div th: text =" $ {url} "> </div> 
    <div th: text =" $ {exception.message} "> </div> 
</ body > 
</html>

Descripción: La plantilla de hoja de tomillo se usa aquí. Esto se introdujo antes: " SpringBoot Getting Started Series (4) Integrated Template Engine Thymeleaf "

3. Clase de prueba

Cree un controlador que pruebe anormalmente

paquete com.weiz.controller; 

import com.weiz.utils.JSONResult;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody; 

@Controller 
@RequestMapping ( "err" )
 clase pública  ErrorController { 
    @RequestMapping ( "/ error" )
     public String error () { int a = 1/0 ; devuelve "thymeleaf / error" ; 
    } 
    @RequestMapping ( "/ ajaxerror" )
    

        
        
        
        
    public String ajaxerror () { 
        
        return "thymeleaf / ajaxerror" ; 
    } 
    
    @RequestMapping ( "/ getAjaxerror" ) 
    @ResponseBody 
    public JSONResult getAjaxerror () { 
        
        int a = 1/0 ; 
        
        devuelve JSONResult.ok (); 
    } 
}

Prueba

Escriba en el navegador: http: // localhost: 8088 / err / error

Pasado

Esto concluye el manejo unificado de excepciones de Spring Boot. Aquí solo se presenta el método de usar la anotación @ControllerAdvice para implementar el manejo de excepciones, y la implementación de ErrorController, puede entender.

El método @ControllerAdvice solo puede manejar excepciones lanzadas por el controlador, mientras que el método tipo ErrorController puede manejar todas las excepciones, incluidos los errores que no han ingresado al controlador, como 404, 401 y otros errores.