Wenn wir Spring-Webanwendungen entwickeln und Ausnahmen wie IOException und ClassNotFoundException überprüfen, fordert der Compiler den Programmierer häufig auf, try-catch zur expliziten Erfassung zu verwenden. Bei Nicht-Überprüfungsausnahmen wie ClassCastException und NullPointerException fordert der Compiler Sie nicht auf, was häufig ein Aspekt ist, der die Fähigkeit des Programmierers Schreibschreiben widerspiegelt.
In Spring Web, insbesondere in den Spring-Boot-Anwendungen, wird bei einer erfolgreichen Anforderung ein Objekt im json Format im Allgemeinen zurückgegeben, wie in der folgenden Abbildung gezeigt:
Aber was ist, wenn die Anfrage eine RuntimeException wirft? Wenn wir die Verarbeitung nicht durchführen, wird die folgende Seite angezeigt, wenn wir erneut anrufen:
Das heißt, wenn ein Fehler im Anruf auftritt, zeichnet Spring-Boot die Anforderung standardmäßig auf den /error ab. Wenn es keinen entsprechenden Pfadanforderungsprozessor gibt, kehrt er zu der obigen Whitelabel -Fehlerseite zurück.
1. Passen Sie die Fehlerbehandlungsseite an
Natürlich ist es unmöglich, die Laufzeitausnahmen nicht zu verarbeiten! Die übliche Praxis besteht darin, die einheitliche Fehlerseite anzupassen und dann zurückzugeben. Nach der obigen Idee implementieren wir einen Controller mit einem Anforderungsweg von /error . Der Controller gibt eine Ressourcenpfadadresse zurück, definiert einen Controller mit einem Anforderungskartenpfad /error und implementiert die ErrorController -Schnittstelle. Der Code ist wie folgt:
MyErrorPageController
paket com.example.demo.controller.handler.Errorpage; import org.springframework.boot.web.servlet.Error.ErrorController import org.spingframework.stereotype.Controller; MyerRorpageController. * * Beschreibung: benutzerdefinierte Fehlerseite * * @Author: Huangjiawei // Diese Ressource befindet sich im Ressourcen-/statischen Verzeichnis} @Override public String getErrorPath () {return null; }} Erstellen Sie dann die Datei error.html im Verzeichnis reosurces/static :
<! DocType html> <html> <kopf> <meta charset = "utf-8"> <title> Title hier einfügen </title> </head> <body> <h1> Dies ist eine Fehlerseite! Gespeichert in Ressourcen/statischen Verzeichnis. Der Standardaufruf befindet sich im Spring-Boot-Fehler </h1> </body> </html>
Anfrage http://localhost:7000/demo/getUserInfoWithNoHandler.json erneut wie folgt:
@ControllerAdvice , @ResponseBody und @ExceptionHandler , um Ausnahmen gleichmäßig zu behandeln
Im Frühjahr können die oben genannten drei Anmerkungen für ein einheitliches Ausnahmebehandlung verwendet werden. Standardmäßig können wir einen einheitlichen Prozessorhandler für bestimmte Arten von Ausnahmen definieren, die im System erscheinen. Wenn das System beispielsweise eine NullPointerException auswirkt, können wir einen Prozessor speziell für NullPointerException definieren. Der Code ist wie folgt:
getUserInfoWithNullPointerException -Schnittstelle
/** * Testen Sie das Umgang mit Nullzeigerfehlern * @return * @throws nullPointerexception */ @requestMapping (value = "getUserinfowithnullPointerexception.json", method = requestMethod.get) public student GetUserInfowitHnullPointerexception () Wursts NullPointenexception () {}Pointenexception {{{{{throwSpoinception () {{}Poinception {{throwsNexception (); NullPointerExceptionHandler.java
paket com.example.demo.controller.handler; import org.springframework.web.bind.annotation.controlleradvice; import org.springframework com.example.demo.pojo.errorreturn;/** * Die Klasse nullPointerexceptionHandler. * * Beschreibung: Handle Null -Zeiger * * @author: huangjiawei E. printstacktrace (); ErrorrorReturn error = neuer errorreturn (); ERROR.SETRETURNCODE ("-1"); error.setDesc ("Null -Zeiger -Ausnahme ist aufgetreten!"); Rückgabefehler; }} Browserausführung: http://localhost:7000/demo/getUserInfoWithNullPointerException.json
Wenn wir einen einheitlichen Prozessor für andere Laufzeitausnahmen bereitstellen müssen, können wir auch einen Prozessor für jeden Ausnahmetyp wie oben definieren. Wenn wir beispielsweise einen Prozessor für ArithmeticException definieren möchten, müssen wir nur eine Klasse oder Methode erstellen und dann ArithmeticException.class hinzufügen. Klassifizieren Sie die @ExceptionHanler -Annotation auf der Methode, um den Ausnahmetyp anzugeben.
Haben Sie jedoch festgestellt, dass dies auf diese Weise eine Ausnahmebehandlungsklasse oder -methode für jeden Ausnahmetyp definiert. Da es zur Laufzeit viele Ausnahmetypen gibt, ist es für jeden Typ unmöglich, eine Prozessorklasse oder -methode anzugeben. In diesem Fall kann die Frühling es auch lösen. Wenn wir einen Prozessor nicht für eine bestimmte Art von Ausnahme definieren, wie z. B. ArithmeticException , können wir eine Exception oder einen Throwable definieren, um sie gleichmäßig zu handhaben.
Der Vorteil davon ist, dass es die Anzahl der Prozessorklassen verringert und die Ausnahmebehandlung an die übergeordnete Klasse überträgt, was auch ein großer Vorteil der Vererbung ist! Wenn Sie jedoch gleichzeitig einen Prozessor einer bestimmten Art von Ausnahme und einer Exception definieren, gibt es hier nicht unbedingt eine vorrangige Beziehung, dh möglicherweise nicht unbedingt der Fall, dass nur der übergeordnete Ausnahmeberecht ausgesetzt wird. Es kann nur den Prozessor A, nicht nur den B -Prozessor oder nur den B -Prozessor, nicht nur den A -Prozessor ausführen. Beispielsweise wird die Ausnahme NullPointerExceptionHandler an Exception übergeben ( ArithmeticException wird jedoch nicht an Exception übergeben)
Nehmen wir nun an, wir definieren sowohl NullPointerExceptionHandler als auch ExceptionThrowableHandler . Wenn dann NullPointerException auftritt, wird ExceptionThrowableHandler -Methode standardmäßig ausgeführt.
ExceptionThrowableHandler.java
paket com.example.demo.controller.handler; import org.springframework.web.bind.annotation.controlleradvice; import org.springframework com.example.demo.pojo.errorreturn;/** * * Die Klasse Exception ThrowableHandler. * * Beschreibung: Einige Ausnahmen werden an hochrangige Ausnahmen übergeben (aber Arithmexception wird nicht auf Ausnahme übertragen) * * @Author: Huangjiawei * @Since: 13. Juni 2018 * @Version: $ Revision $ $ $ $ letzt @ResponseBody public errorReturn dealthrowable () {errorreturn error = new errorReturn (); error.setDesc ("Handlungsstöber!"); ERROR.SETRETURNCODE ("-1"); Rückgabefehler; } @ExceptionHandler (exception.class) @ResponseBody public errorReturn admentCommonexception () {errorreturn error = new errorReturn (); ERROR.SETRETURNCODE ("-1"); error.setDesc ("öffentliche Ausnahmehandling!"); Rückgabefehler; }} Browserausführung: http://localhost:7000/demo/getUserInfoWithNullPointerException.json
Es ist festzustellen, dass der Prozessor, der nur Exception ausführt, aber keinen Nullzeiger ausführt, dh die Ausnahmebereichung wird nach oben übertragen. Schauen wir uns die Situation an, in der ArithmeticException geworfen wird:
getUserInfoWithArithmeticException.json
/** * Testing the handling of null pointer errors* @return * @throws NullPointerException */@RequestMapping(value = "getUserInfoWithArithmeticException.json", method = RequestMethod.GET)public Student getUserInfoWithArithmeticException() throws ArithmeticException {throw new ArithmeticException();} ArithmeticExceptionHandler.java
paket com.example.demo.controller.handler; import org.springframework.web.bind.annotation.controlleradvice; import org.springframework com.example.demo.pojo.errorreturn; @ControllerAdvicePublic Class ArithmexceptionHandler { / *** ARITHMETICExceptionException -Ausnahme* @return* / @RespondeBody @ExceptionHandler (ArithTicexception.class) public erorrorrorrornturn adminaliturn () {) {{{{{{{{{{{ERRORTURNRORTURN); ERROOBJECT.SETRETURNCODE ("-1"); ERROOBJECT.SETDESC ("Ausnahme in der arithmetischen Verarbeitung aufgetreten!"); return errorObject; }} Browserausführung: http://localhost:7000/demo/getUserInfoWithArithmeticException.json
Infolgedessen wurde festgestellt, dass die Ausnahmebehandlung nicht an ExceptionHandler auf der oberen Ebene übertragen wurde.
Zusammenfassung: Seien Sie besonders vorsichtig, wenn Sie Prozessoren sowohl bestimmter Typen als auch über Elterntypen wie Exception definieren. Nicht alle Ausnahmen werden auf der oberen Ebene verarbeitet. Wenn wir nur die Anzahl der Prozessorklassen reduzieren und keine Klassen oder Methoden für jeden bestimmten Prozessoryp hinzufügen möchten, empfiehlt der Editor, instanceof zu verwenden, um den Ausnahmetyp zu beurteilen.
Wie im folgenden Code stellen wir nur einen öffentlichen Ausnahmebehandler ein, behandeln Exception und verwenden instanceof , um Urteile zu fällen.
@ExceptionHandler (exception.class) @ResponseBodypublic errorReturn DealCommonexception (Ausnahme e) {errorRRorReturn error = new errrretrurn (); // Hier können Sie Instanz verwenden, um den Ausnahmetyp zu bestimmen, wenn (e Instanz von Arithmexception) {error.setReturnCode ("-1"); error.setDesc ("Arithmeticexception Handling!"); Rückgabefehler; } System.err.println ("Ausnahme"); ERROR.SETRETURNCODE ("-1"); error.setDesc ("öffentliche Ausnahmehandling!"); Rückgabefehler;} Der Browser führt die Schnittstelle aus, die ArithmeticException verweist, wie folgt:
Die Codeadresse dieses Artikels: https://github.com/smallercoder/spring_exceptionHandler
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.