Quando desenvolvemos aplicativos da Web da primavera, para verificar exceções como IOException e ClassNotFoundException , o compilador geralmente leva o programador a usar try-catch para captura explícita. Para exceções que não verifiquem, como ClassCastException e NullPointerException , o compilador não solicitará, o que geralmente é um aspecto que reflete a capacidade de escrever código do programador.
Na Web da primavera, especialmente aplicativos de botas de primavera, quando uma solicitação é chamada com sucesso, geralmente retorna um objeto no formato json , como mostrado na figura abaixo:
Mas e se a solicitação lançar uma RuntimeException ? Se não fizermos o processamento, a página a seguir aparecerá quando ligarmos novamente:
Ou seja, quando ocorrer um erro na chamada, a Spring-Boot mapeará a solicitação para o caminho /error por padrão. Se não houver processador de solicitação de caminho correspondente, ele retornará à página de erro Whitelabel acima.
1. Personalize a página de manuseio de erros
Obviamente, é impossível não processar exceções de tempo de execução! A prática usual é personalizar a página de erro unificada e retornar. De acordo com a ideia acima, implementamos um controlador com um caminho de solicitação de /error . O controlador retorna um endereço do caminho do recurso, define um controlador com um caminho de mapa de solicitação de /error e implementa a interface ErrorController . O código é o seguinte:
MyErrorPageController
pacote com.example.demo.controller.handler.erRorPage; importar org.springframework.boot.web.servlet.error.errorcontroller; importar org.springframework.anterotype.controller; importrg.springframe.web.anType.anType.notation.anTroller; importrg.springFramework.web.bind.bindypey.anType.notation.notation.notation.notation.notation.notation.notation; MyerRorPageController. * * Descrição: Página de erro personalizada * * @Author: Huangjiawei * @since: 13 de junho de 2018 * @Version: $ revision $ $ data $ $ lastChangedby $ * */ @controlerpublic class MyerRorPontroller implementa ErrorController {@ReQuestMapping ("/errorTerL) (Public Stringerror; // Este recurso está localizado no diretório de recursos/estático} @Override public String getERRorRorpath () {return null; }} Em seguida, crie o arquivo error.html no diretório reosurces/static :
<! Doctype html> <html> <head> <meta charset = "utf-8"> <title> Insira o título aqui </title> </head> <body> <h1> Esta é uma página de erro! Armazenado em Recursos/Diretório estático. A chamada padrão está no erro de primavera </h1> </body> </html>
Solicite http://localhost:7000/demo/getUserInfoWithNoHandler.json novamente, como segue:
@ControllerAdvice , @ResponseBody e @ExceptionHandler para lidar com exceções uniformemente
Na primavera, as três anotações acima podem ser usadas para manipulação de exceções unificadas. Por padrão, podemos definir um manipulador de processador unificado para certos tipos de exceções que aparecem no sistema. Por exemplo, se o sistema lançar uma NullPointerException , podemos definir um processador especificamente para NullPointerException . O código é o seguinte:
interface getUserInfoWithNullPointerException
/** * 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
pacote com.example.demo.controller.handler; importar org.springframework.web.bind.annotation.controlleradvice; importar org.springframework.web.bind.annotation.exceptionHandler; importernportFramework.web.bind.annotation.exception; com.example.demo.pojo.erRorreTurn;/** * * A classe NullPointerExceptionHandler. * * Description: Handle null pointers* * @author: huangjiawei * @since: June 13, 2018* @version: $Revision$ $Date$ $LastChangedBy$ * */@ControllerAdvicepublic class NullPointerExceptionHandler { @ExceptionHandler(NullPointerException.class) @ResponseBody public ErrorReturn dealNullPointerException() { E.PrintStackTrace (); Erro errorreTurn = new errorreTurn (); error.setReturncode ("-1"); error.setDesc ("Exceção de ponteiro nulo ocorreu!"); erro de retorno; }} Execução do navegador: http://localhost:7000/demo/getUserInfoWithNullPointerException.json
Da mesma forma, se precisarmos fornecer um processador unificado para outras exceções de tempo de execução, também podemos definir um processador para cada tipo de exceção como acima. Por exemplo, se queremos definir um processador para ArithmeticException , precisamos apenas criar uma classe ou método e adicionar ArithmeticException.class à anotação @ExceptionHanler sobre o método para especificar o tipo de exceção.
No entanto, você descobriu que dessa maneira define uma classe ou método de manipulação de exceções para cada tipo de exceção. Como existem muitos tipos de exceção em tempo de execução, é impossível especificar uma classe ou método do processador para cada tipo. Nesse caso, a primavera também pode resolvê -lo. Se não definirmos um processador para um certo tipo de exceção, como ArithmeticException , podemos definir uma Exception ou processador Throwable para lidar com isso de maneira uniforme.
A vantagem de fazer isso é que ele reduz o número de classes de processador e transfere o tratamento de exceções para a classe pai, o que também é uma grande vantagem de herança! No entanto, quando você define um processador de um tipo específico de exceção e uma Exception ao mesmo tempo, tenha cuidado, não há necessariamente um relacionamento prioritário aqui, ou seja, pode não ser necessariamente acontecer que apenas o processador de exceção dos pais seja executado. Ele pode executar apenas o processador A, não apenas o processador B, ou apenas o processador B, não o processador A. Por exemplo, a exceção NullPointerExceptionHandler será passada para Exception (mas ArithmeticException não será passada para Exception )
Agora, suponha que definamos NullPointerExceptionHandler acima e ExceptionThrowableHandler abaixo. Então, quando ocorre NullPointerException , ExceptionThrowableHandler será executado por padrão.
ExceptionThrowableHandler.java
pacote com.example.demo.controller.handler; importar org.springframework.web.bind.annotation.controlleradvice; importar org.springframework.web.bind.annotation.exceptionHandler; importernportFramework.web.bind.annotation.exception; com.example.demo.pojo.erRorreTurn;/** * * * A CLASSE ExceptionHortHandler. * * Description: Some exceptions are passed to high-level exceptions (but ArithmeticException will not be transmitted to Exception) * * @author: huangjiawei * @since: June 13, 2018* @version: $Revision$ $Date$ $LastChangedBy$ * */@ControllerAdvicepublic class ExceptionThrowableHandler { @ExceptionHandler(Throwable.class) @ResponseBody public errorreTurn decalityRowable () {errorTurn error = new errorreTurn (); error.setDesc ("Handle Throwable!"); error.setReturncode ("-1"); erro de retorno; } @ExceptionHandler (excepcion.class) @ResponseBody Public errorreTurn OalComMonexception () {error de errrorTurn = new errorreTurn (); error.setReturncode ("-1"); error.setDesc ("Manipulação de exceção pública!"); erro de retorno; }} Execução do navegador: http://localhost:7000/demo/getUserInfoWithNullPointerException.json
Pode -se descobrir que o processador que executa apenas Exception , mas não executa um ponteiro nulo, ou seja, o processamento de exceção é transmitido para cima. Vamos dar uma olhada na situação em que ArithmeticException é lançada:
getUserInfoWithArithmeticException.json
/** * Testando o manuseio de erros de ponteiro nulo * @return * @throws nullPointerException */ @requestMapp (value = "getUserinfowitharithMeticexception.json", métodos = requestmethod.get) public student getUserInFowithMeticexException () () () () (), requestricexcepthod.get) public student getUserinFowithMetice
ArithmeticExceptionHandler.java
pacote com.example.demo.controller.handler; importar org.springframework.web.bind.annotation.controlleradvice; importar org.springframework.web.bind.annotation.exceptionHandler; importernportFramework.web.bind.annotation.exception; com.example.demo.pojo.erRorreTurn; @ControlleRadvicePublic Classe arithmeticexceptionHandler { / *** Handle arithmeticexceptionexception exceção* @return* / @ResponseBodyBodyBodyBodEBodyHandler (arithMeticexception.class) public) errorTurNeGeRitExMorTiceMMOBOBOBodyMeReTiceMler (arithmeticexception.class) public) e errorTerNeTeRiticeMorTiceMorTiceMorTiceMorTeTiceReTiceReTiceMler (arithMeticexception.Class) Public) ErrorObject.SetReturncode ("-1"); ErrorObject.SetDesc ("Exceção ocorreu no processamento aritmético!"); retornar errorObject; }} Execução do navegador: http://localhost:7000/demo/getUserInfoWithArithmeticException.json
Como resultado, verificou -se que o manuseio de exceção não foi transmitido ao ExceptionHandler no nível superior.
Resumo: tenha cuidado ao definir processadores de tipos específicos e tipos de pais, como Exception . Nem todas as exceções serão processadas no nível superior. Se quisermos reduzir apenas o número de classes do processador e não queremos adicionar classes ou métodos para cada tipo específico de processador, o editor recomenda o uso instanceof do Keyword para julgar o tipo de exceção.
Como no código a seguir, estabelecemos apenas um manipulador de exceção pública, lidamos com exceções Exception e usamos instanceof para fazer julgamentos.
@ExceptionHandler (Exception.Class) @ResponseBodyPublic errorreTurn DealCommonexception (Exceção e) {error de errrorTurn = new errorreTurn (); // Aqui você pode usar a instância para determinar o tipo de exceção if (e instanceof arithmeticexception) {error.setReturnCode ("-1"); error.setDesc ("Aithmeticexception manuseio!"); erro de retorno; } System.err.println ("Exception"); error.setReturncode ("-1"); error.setDesc ("Manipulação de exceção pública!"); Erro de retorno;} O navegador executa a interface que lança ArithmeticException , como segue:
O endereço do código deste artigo: https://github.com/smalmercoder/spring_exceptionhandler
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.