Cuando desarrollamos aplicaciones web de Spring, para verificar excepciones como IOException y ClassNotFoundException , el compilador a menudo le pide al programador que use try-catch para la captura explícita. Para excepciones que no son de cheque, como ClassCastException y NullPointerException , el compilador no lo solicitará, que a menudo es un aspecto que refleja la capacidad de escritura de código del programador.
En Spring Web, especialmente las aplicaciones de Boot Spring, cuando una solicitud se llama correctamente, generalmente devolverá un objeto en formato json , como se muestra en la figura a continuación:
Pero, ¿qué pasa si la solicitud arroja una RuntimeException ? Si no hacemos el procesamiento, la siguiente página aparecerá cuando volvamos a llamar:
Es decir, cuando ocurre un error en la llamada, Spring-Boot asignará la solicitud a la ruta /error de forma predeterminada. Si no hay un procesador de solicitud de ruta correspondiente, volverá a la página de error Whitelabel anterior.
1. Personaliza la página de manejo de errores
¡Por supuesto, es imposible no procesar las excepciones de tiempo de ejecución! La práctica habitual es personalizar la página de error unificada y luego volver. Según la idea anterior, implementamos un controlador con una ruta de solicitud de /error . El controlador devuelve una dirección de ruta de recursos, define un controlador con una ruta de mapa de solicitud de /error e implementa la interfaz ErrorController . El código es el siguiente:
MyErrorPageController
paquete com.example.demo.controller.handler.errorPage; import org.springframework.boot.web.servlet.error.errorController; import org.springframework.stereotype.controller; import og.springfframework.web.bind.annotation.requestmapping;/** * * * * * * * * * * * * * * * * * * * * la CASS MyErrorPageController. * * Descripción: Página de error personalizado * * @author: Huangjiawei * @since: 13 de junio de 2018 * @version: $ revision $ $ date $ $ lastchangedby $ * */ @controlerpublic clase myErRorPageController implementa errores {@requestmapping ("/error") public string manyError () {regreso ". // Este recurso se encuentra en el directorio de recursos/static} @Override public String getErRorPath () {return null; }} Luego cree el archivo error.html en reosurces/static :
<! DocType html> <html> <head> <meta charset = "utf-8"> <title> Inserte el título aquí </title> </head> <body> <h1> ¡Esta es una página de error! Almacenado en recursos/directorio estático. La llamada predeterminada está en el error Spring-Boot </h1> </body> </html>
Solicitar http://localhost:7000/demo/getUserInfoWithNoHandler.json nuevamente, como sigue:
@ControllerAdvice , @ResponseBody y @ExceptionHandler para manejar las excepciones de manera uniforme
En primavera, las tres anotaciones anteriores se pueden usar para un manejo de excepciones unificadas. Por defecto, podemos definir un controlador de procesadores unificado para ciertos tipos de excepciones que aparecen en el sistema. Por ejemplo, si el sistema lanza una NullPointerException , entonces podemos definir un procesador específicamente para NullPointerException . El código es el siguiente:
getUserInfoWithNullPointerException interfaz
/** * Testing the handling of null pointer errors* @return * @throws NullPointerException */@RequestMapping(value = "getUserInfoWithNullPointerException.json", method = RequestMethod.GET)public Student getUserInfoWithNullPointerException() throws NullPointerException {throw new NullPointerException();} NullPointerExceptionHandler.java
paquete com.example.demo.controller.handler; import org.springframework.web.bind.annotation.controllerAdVice; import org.springframework.web.bind.annotation.exceptionHandler; import og.springfframework.web.bind.annotation.ResponseBody; import com.example.demo.pojo.errorreturn;/** * * La clase nullpointerExceptionHandler. * * Descripción: manejar punteros nulos * * @author: huangjiawei * @since: 13 de junio de 2018 * @version: $ revision $ $ date $ $ ortChangedBy $ * */ @controlerAdVicePublic Class nullPointerExceptionHandler {@ExceptionHandler (nullpointerexception.class) @ResponseBody ErrorceReturn DeurnlullNullNullNullLUnceptualception () E.PrintStackTrace (); Error ErrorrEreRurn = new ErrorReturn (); error.setReturnCode ("-1"); Error.setDesc ("Se produjo una excepción de puntero nulo!"); Error de retorno; }} Ejecución del navegador: http://localhost:7000/demo/getUserInfoWithNullPointerException.json
Del mismo modo, si necesitamos proporcionar un procesador unificado para otras excepciones de tiempo de ejecución, también podemos definir un procesador para cada tipo de excepción como se indica anteriormente. Por ejemplo, si queremos definir un procesador para ArithmeticException , solo necesitamos crear una clase o método, y luego agregar ArithmeticException.class a la anotación @ExceptionHanler en el método para especificar el tipo de excepción.
Sin embargo, ¿ha descubierto que de esta manera define una clase o método de manejo de excepciones para cada tipo de excepción? Debido a que hay muchos tipos de excepción en tiempo de ejecución, es imposible especificar una clase o método de procesador para cada tipo. En este caso, la primavera también puede resolverlo. Si no definimos un procesador para un cierto tipo de excepción, como ArithmeticException , entonces podemos definir una Exception o un procesador Throwable para manejarlo de manera uniforme.
La ventaja de hacer esto es que reduce el número de clases de procesadores y transfiere el manejo de excepciones a la clase principal, ¡lo cual también es una gran ventaja de la herencia! Sin embargo, cuando define un procesador de un tipo específico de excepción y una Exception al mismo tiempo, tenga cuidado, no hay necesariamente una relación prioritaria aquí, es decir, no necesariamente sucederá que solo se ejecute el procesador de excepción principal. Solo puede ejecutar el procesador A, no solo el procesador B, o solo el procesador B, no el procesador A. Por ejemplo, la excepción de NullPointerExceptionHandler se pasará a Exception (pero ArithmeticException no se pasará a Exception )
Ahora supongamos que definimos tanto NullPointerExceptionHandler arriba como ExceptionThrowableHandler a continuación. Luego, cuando se produce NullPointerException , ExceptionThrowableHandler se ejecutará de forma predeterminada.
ExceptionThrowableHandler.java
paquete com.example.demo.controller.handler; import org.springframework.web.bind.annotation.controllerAdVice; import org.springframework.web.bind.annotation.exceptionHandler; import og.springfframework.web.bind.annotation.ResponseBody; import com.example.demo.pojo.errorreturn;/** * * La clase ExceptionThrowableHandler. * * Descripción: Algunas excepciones se pasan a excepciones de alto nivel (pero arithmeticException no se transmitirá a una excepción) * * @author: huangjiawei * @since: 13 de junio, 2018 * @version: $ revision $ $ date $ $ * * */ @controleradvicepublicS Clase excepción {@ExceptionHandler (silleable.claSs) ErrorrErTurn DealthRowable () {ErrorrErTurn Error = new ErrorrErTurn (); Error.setDesc ("¡manejar lanzado!"); error.setReturnCode ("-1"); Error de retorno; } @ExceptionHandler (Exception.class) @ResponseBody public Errorreturn DealComMonException () {ErrorrErnurn Error = new Errorreturn (); error.setReturnCode ("-1"); Error.setDesc ("¡Manejo de excepciones públicas!"); Error de retorno; }} Ejecución del navegador: http://localhost:7000/demo/getUserInfoWithNullPointerException.json
Se puede encontrar que el procesador que solo ejecuta Exception pero no ejecuta un puntero nulo, es decir, el procesamiento de excepciones se transmite hacia arriba. Echemos un vistazo a la situación en la que se lanza ArithmeticException :
getUserInfoWithArithmeticException.json
/** * Probar el manejo de errores de puntero nulo * @return * @throws nullPointerException */ @requestmapping (value = "getUserInfowitharithmeticException.json", método = requestMethod.get) público público
ArithmeticExceptionHandler.java
paquete com.example.demo.controller.handler; import org.springframework.web.bind.annotation.controllerAdVice; import org.springframework.web.bind.annotation.exceptionHandler; import og.springfframework.web.bind.annotation.ResponseBody; import com.example.demo.pojo.errorreturn; @ControllerAdVicePublic Class ARITHMETICEXCEPTERINGHANDLER { / *** manejar arithmeticExceptionException Exception* @return* / @ResponseBody @ExceptionHandler (arithmeticException.class) Public Errorreturn DealarithMeticException () {ErrIrReRNurn ErrorObject = NeweStorrErTurn (); ErrorObject.setReturnCode ("-1"); ErrorObject.setDesc ("¡Se produjo una excepción en el procesamiento aritmético!"); return ErrorObject; }} Ejecución del navegador: http://localhost:7000/demo/getUserInfoWithArithmeticException.json
Como resultado, se descubrió que el manejo de excepciones no se transmitió a ExceptionHandler en el nivel superior.
Resumen: tenga especialmente cuidado al definir procesadores de tipos específicos y tipos principales, como Exception . No todas las excepciones se procesarán en el nivel superior. Si solo queremos reducir el número de clases de procesadores y no queremos agregar clases o métodos para cada tipo específico de procesador, entonces el editor recomienda usar instanceof la palabra clave para juzgar el tipo de excepción.
Como en el siguiente código, solo establecemos un controlador de excepciones públicas, manejamos excepciones Exception y usamos instanceof para emitir juicios.
@ExceptionHandler (excepcion.class) @ResponseBodyPublic ErrorReturn DealComMonException (Exception e) {ErrorrErnn Error = new Errorreturn (); // Aquí puede usar InstanceOf para determinar el tipo de excepción if (e instanceo de arithmeticException) {error.setReturnCode ("-1"); Error.setDesc ("ARITHMETICEXCEPTION MANGING!"); Error de retorno; } System.err.println ("excepción"); error.setReturnCode ("-1"); Error.setDesc ("¡Manejo de excepciones públicas!"); Error de retorno;} El navegador ejecuta la interfaz que arroja ArithmeticException , como sigue:
La dirección del código de este artículo: https://github.com/smallercoder/spring_exceptionhandler
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.