Spring MVC Uitzonderingsafhandeling is erg belangrijk om ervoor te zorgen dat u geen serveruitzonderingen naar de client stuurt. Vandaag zullen we kijken naar Spring Uitzonderingsafhandeling met behulp van @ExceptionHandler, @ControllerAdvice en HandlerExceptionResolver. Elke webapplicatie vereist een goed ontwerp voor uitzonderingsafhandeling omdat we geen door de container gegenereerde pagina willen serveren wanneer er een onbehandelde uitzondering wordt gegenereerd door onze applicatie.
Spring Uitzonderingsafhandeling
Het hebben van een goed gedefinieerde aanpak voor uitzonderingsafhandeling is een groot pluspunt voor elk webapplicatieraamwerk; dat gezegd hebbende, levert het Spring MVC-raamwerk goed werk als het gaat om uitzonderings- en foutafhandeling in onze webapplicaties. Het Spring MVC-raamwerk biedt de volgende manieren om ons te helpen bij het bereiken van robuuste uitzonderingsafhandeling.
- Controller Based – We kunnen uitzonderingsafhandelingsmethoden definiëren in onze controllerklassen. Het enige wat we moeten doen is deze methoden annoteren met de
@ExceptionHandler-annotatie. Deze annotatie neemt de Exception-klasse als argument. Dus als we een van deze hebben gedefinieerd voor de Exception-klasse, dan zullen alle uitzonderingen die worden gegenereerd door onze verzoekafhandelingsmethode worden afgehandeld. Deze uitzonderingsafhandelingsmethoden zijn net als andere verzoekafhandelingsmethoden en we kunnen een foutreactie opbouwen en reageren met een ander foutpagina. We kunnen ook een JSON-foutreactie verzenden, waar we later in ons voorbeeld naar zullen kijken. Als er meerdere uitzonderingsafhandelingsmethoden zijn gedefinieerd, wordt de afhandelingsmethode gebruikt die het dichtst bij de Exception-klasse ligt. Bijvoorbeeld, als we twee afhandelingsmethoden hebben gedefinieerd voor IOException en Exception en onze verzoekafhandelingsmethode gooit IOException, dan wordt de afhandelingsmethode voor IOException uitgevoerd. - Global Exception Handler – Uitzonderingsafhandeling is een dwarsdoorsnijdende zorg, het moet worden gedaan voor alle aspecten in onze applicatie. We hebben al gekeken naar Spring AOP en daarom biedt Spring de
@ControllerAdvice-annotatie die we kunnen gebruiken met elke klasse om onze globale uitzonderingsafhandelaar te definiëren. De afhandelingsmethoden in Global Controller Advice zijn hetzelfde als de op controller gebaseerde uitzonderingsafhandelingsmethoden en worden gebruikt wanneer de controllerklasse niet in staat is om de uitzondering af te handelen. - HandlerExceptionResolver – Voor generieke uitzonderingen serveren we meestal statische pagina’s. Het Spring Framework biedt de
HandlerExceptionResolver-interface die we kunnen implementeren om een wereldwijde uitzonderingsafhandelaar te maken. De reden achter deze aanvullende manier om een wereldwijde uitzonderingsafhandelaar te definiëren, is dat het Spring-framework ook standaard implementatieklassen biedt die we kunnen definiëren in ons Spring Bean-configuratiebestand om de voordelen van de uitzonderingsafhandeling van het Spring-framework te verkrijgen.SimpleMappingExceptionResolveris de standaard implementatieklasse. Hiermee kunnen we exceptionMappings configureren waarin we kunnen specificeren welke resource moet worden gebruikt voor een bepaalde uitzondering. We kunnen het ook overschrijven om onze eigen wereldwijde handler te maken met onze toepassingsspecifieke wijzigingen, zoals het vastleggen van uitzonderingsberichten.
We zullen een Spring MVC-project maken waarin we de implementatie van op controller gebaseerde, op AOP gebaseerde en op Uitzonderingsresolver gebaseerde benaderingen van uitzonderings- en foutafhandeling zullen bekijken. We zullen ook een uitzonderingsafhandelingsmethode schrijven die een JSON-respons retourneert. Als je nieuw bent met JSON in Spring, lees dan Spring Restful JSON Tutorial. Ons uiteindelijke project zal eruitzien als de onderstaande afbeelding. We zullen alle componenten van onze applicatie stap voor stap bekijken. 
Spring Uitzonderingsafhandeling Maven Afhankelijkheden
Naast de standaard Spring MVC-afhankelijkheden hebben we ook de Jackson JSON-afhankelijkheid nodig voor JSON-ondersteuning. Ons uiteindelijke pom.xml-bestand ziet er als volgt uit.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev.spring</groupId>
<artifactId>SpringExceptionHandling</artifactId>
<name>SpringExceptionHandling</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.6</java-version>
<org.springframework-version>4.0.2.RELEASE</org.springframework-version>
<org.aspectj-version>1.7.4</org.aspectj-version>
<org.slf4j-version>1.7.5</org.slf4j-version>
<jackson.databind-version>2.2.3</jackson.databind-version>
</properties>
<dependencies>
<!-- Jackson -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.databind-version}</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
I have updated Spring Framework, AspectJ, Jackson and slf4j versions to use the latest one.
Spring MVC Uitzonderingsafhandeling Inzetingsdescriptor
Ons web.xml-bestand ziet er als volgt uit.
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
<!-- Creates the Spring Container shared by all Servlets and Filters -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Processes application requests -->
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/spring.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<error-page>
<error-code>404</error-code>
<location>/resources/404.jsp</location>
</error-page>
</web-app>
Het grootste deel is bedoeld voor het integreren van het Spring Framework in onze webtoepassing, behalve de error-page gedefinieerd voor de 404-fout. Dus wanneer onze toepassing een 404-fout genereert, wordt deze pagina gebruikt als reactie. Deze configuratie wordt gebruikt door de container wanneer onze Spring-webtoepassing een 404-foutcode genereert.
Spring Uitzonderingsafhandeling – Modelklassen
I have defined Employee bean as model class, however we will be using it in our application just to return valid response in specific scenario. We will be deliberately throwing different types of exceptions in most of the cases.
package com.journaldev.spring.model;
public class Employee {
private String name;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
Aangezien we ook een JSON-reactie zullen retourneren, laten we een Java Bean maken met uitzonderingsdetails die als reactie worden verzonden.
package com.journaldev.spring.model;
public class ExceptionJSONInfo {
private String url;
private String message;
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
Spring Exception Handling – Aangepaste Uitzonderingsklasse
Laten we een aangepaste uitzonderingsklasse maken die door onze applicatie zal worden gebruikt.
package com.journaldev.spring.exceptions;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="Employee Not Found") //404
public class EmployeeNotFoundException extends Exception {
private static final long serialVersionUID = -3332292346834265371L;
public EmployeeNotFoundException(int id){
super("EmployeeNotFoundException with id="+id);
}
}
Merk op dat we de @ResponseStatus-annotatie kunnen gebruiken met uitzonderingsklassen om de HTTP-code te definiëren die door onze applicatie wordt verzonden wanneer dit type uitzondering wordt gegenereerd door onze applicatie en behandeld door onze uitzonderingsafhandelingsimplementaties. Zoals je kunt zien, stel ik de HTTP-status in als 404 en hebben we een error-pagina gedefinieerd hiervoor, dus onze applicatie moet de error-pagina gebruiken voor dit type uitzondering als we geen weergave retourneren. We kunnen ook de statuscode overschrijven in onze uitzonderingsafhandelingsmethode, denk eraan als de standaard HTTP-statuscode wanneer onze uitzonderingsafhandelingsmethode geen weergavepagina retourneert als reactie.
Spring MVC Exception Handling Controller Class Exception Handler
Laten we eens kijken naar onze controllerklasse waarin we verschillende soorten uitzonderingen zullen gooien.
package com.journaldev.spring.controllers;
import java.io.IOException;
import java.sql.SQLException;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import com.journaldev.spring.exceptions.EmployeeNotFoundException;
import com.journaldev.spring.model.Employee;
import com.journaldev.spring.model.ExceptionJSONInfo;
@Controller
public class EmployeeController {
private static final Logger logger = LoggerFactory.getLogger(EmployeeController.class);
@RequestMapping(value="/emp/{id}", method=RequestMethod.GET)
public String getEmployee(@PathVariable("id") int id, Model model) throws Exception{
//opzettelijk verschillende soorten uitzonderingen gooien
if(id==1){
throw new EmployeeNotFoundException(id);
}else if(id==2){
throw new SQLException("SQLException, id="+id);
}else if(id==3){
throw new IOException("IOException, id="+id);
}else if(id==10){
Employee emp = new Employee();
emp.setName("Pankaj");
emp.setId(id);
model.addAttribute("employee", emp);
return "home";
}else {
throw new Exception("Generic Exception, id="+id);
}
}
@ExceptionHandler(EmployeeNotFoundException.class)
public ModelAndView handleEmployeeNotFoundException(HttpServletRequest request, Exception ex){
logger.error("Requested URL="+request.getRequestURL());
logger.error("Exception Raised="+ex);
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("exception", ex);
modelAndView.addObject("url", request.getRequestURL());
modelAndView.setViewName("error");
return modelAndView;
}
}
Let op dat voor de EmployeeNotFoundException-handler, ik een ModelAndView retourneer en daarom wordt de HTTP-statuscode als OK (200) verzonden. Als het void had geretourneerd, zou de HTTP-statuscode als 404 zijn verzonden. We zullen deze implementatie in onze wereldwijde uitzonderingshandler implementeren. Omdat ik alleen EmployeeNotFoundException in de controller afhandel, worden alle andere uitzonderingen die door onze controller worden gegenereerd, afgehandeld door de wereldwijde uitzonderingshandler.
@ControllerAdvice en @ExceptionHandler
Hier is onze controllerklasse voor de wereldwijde uitzonderingsafhandeling. Let op dat de klasse is geannoteerd met @ControllerAdvice-annotatie. Ook zijn de methoden geannoteerd met @ExceptionHandler-annotatie.
package com.journaldev.spring.controllers;
import java.io.IOException;
import java.sql.SQLException;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
@ControllerAdvice
public class GlobalExceptionHandler {
private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
@ExceptionHandler(SQLException.class)
public String handleSQLException(HttpServletRequest request, Exception ex){
logger.info("SQLException Occured:: URL="+request.getRequestURL());
return "database_error";
}
@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="IOException occured")
@ExceptionHandler(IOException.class)
public void handleIOException(){
logger.error("IOException handler executed");
//terugsturen van 404 foutcode
}
}
Let op dat ik voor SQLException database_error.jsp als responspagina retourneer met een http-statuscode van 200. Voor IOException retourneren we void met de statuscode van 404, zodat onze error-pagina in dit geval wordt gebruikt. Zoals je kunt zien, handel ik hier geen andere soorten uitzonderingen af, dat deel heb ik overgelaten voor de implementatie van HandlerExceptionResolver.
HandlerExceptionResolver
We breiden eenvoudig SimpleMappingExceptionResolver uit en overschrijven een van de methoden, maar we kunnen de belangrijkste methode resolveException overschrijven voor het loggen en verzenden van verschillende soorten weergavepagina’s. Maar dat is hetzelfde als het gebruik van ControllerAdvice-implementatie, dus ik laat het achterwege. We zullen het gebruiken om de weergavepagina te configureren voor alle andere uitzonderingen die niet door ons worden afgehandeld, door te reageren met een generieke foutpagina.
Spring Exception Handling Configuration-bestand
Ons Spring Bean-configuratiebestand ziet er als volgt uit. spring.xml code:
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="https://www.springframework.org/schema/beans"
xmlns:context="https://www.springframework.org/schema/context"
xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
<!-- Enables the Spring MVC @Controller programming model -->
<annotation-driven />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<resources mapping="/resources/**" location="/resources/" />
<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
<beans:bean id="simpleMappingExceptionResolver" class="com.journaldev.spring.resolver.MySimpleMappingExceptionResolver">
<beans:property name="exceptionMappings">
<beans:map>
<beans:entry key="Exception" value="generic_error"></beans:entry>
</beans:map>
</beans:property>
<beans:property name="defaultErrorView" value="generic_error"/>
</beans:bean>
<!-- Configure to plugin JSON as request and response in method handler -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<beans:property name="messageConverters">
<beans:list>
<beans:ref bean="jsonMessageConverter"/>
</beans:list>
</beans:property>
</beans:bean>
<!-- Configure bean to convert JSON to POJO and vice versa -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>
<context:component-scan base-package="com.journaldev.spring" />
</beans:beans>
Let op de bonen geconfigureerd voor ondersteuning van JSON in onze webapplicatie. Het enige deel dat betrekking heeft op het afhandelen van uitzonderingen, is de definitie van de simpleMappingExceptionResolver bean, waar we generic_error.jsp definiëren als de weergavepagina voor de Exception-klasse. Hierdoor wordt ervoor gezorgd dat elke uitzondering die niet wordt afgehandeld door onze applicatie, niet resulteert in het verzenden van een door de server gegenereerde foutpagina als reactie.
Spring MVC Uitzonderingsafhandeling JSP-weergavepagina’s
Het is tijd om te kijken naar het laatste deel van onze applicatie, onze weergavepagina’s die zullen worden gebruikt in onze applicatie. home.jsp code:
<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<html>
<head>
<title>Home</title>
</head>
<body>
<h3>Hello ${employee.name}!</h3><br>
<h4>Your ID is ${employee.id}</h4>
</body>
</html>
home.jsp wordt gebruikt om te reageren met geldige gegevens, d.w.z. wanneer we id als 10 krijgen in het clientverzoek. 404.jsp code:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>404 Error Page</title>
</head>
<body>
<h2>Resource Not Found Error Occured, please contact support.</h2>
</body>
</html>
404.jsp wordt gebruikt voor het genereren van de weergave voor de http-statuscode 404, voor onze implementatie zou dit de reactie moeten zijn wanneer we id als 3 krijgen in het clientverzoek. error.jsp code:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Error Page</title>
</head>
<body>
<h2>Application Error, please contact support.</h2>
<h3>Debug Information:</h3>
Requested URL= ${url}<br><br>
Exception= ${exception.message}<br><br>
<strong>Exception Stack Trace</strong><br>
<c:forEach items="${exception.stackTrace}" var="ste">
${ste}
</c:forEach>
</body>
</html>
error.jsp wordt gebruikt wanneer onze controllerklasseverzoekhandlermethode EmployeeNotFoundException werpt. We zouden deze pagina als reactie moeten krijgen wanneer de id-waarde 1 is in het clientverzoek. database_error.jsp code:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Database Error Page</title>
</head>
<body>
<h2>Database Error, please contact support.</h2>
</body>
</html>
database_error.jsp wordt gebruikt wanneer onze applicatie SQLException werpt, zoals geconfigureerd in de GlobalExceptionHandler-klasse. We zouden deze pagina als reactie moeten krijgen wanneer de id-waarde 2 is in het clientverzoek. generic_error.jsp code:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Generic Error Page</title>
</head>
<body>
<h2>Unknown Error Occured, please contact support.</h2>
</body>
</html>
Dit zou de pagina moeten zijn als reactie wanneer er een uitzondering optreedt die niet wordt afgehandeld door onze toepassingscode en de simpleMappingExceptionResolver-bean daarvoor zorgt. We zouden deze pagina als reactie moeten krijgen wanneer de id-waarde in het clientverzoek alles behalve 1, 2, 3 of 10 is.
Het uitvoeren van de Spring MVC Exception Handling-toepassing
Net implementeer de toepassing in de servlet-container die je gebruikt. Ik gebruik Apache Tomcat 7 als voorbeeld. Onderstaande afbeeldingen tonen de verschillende antwoordpagina’s die onze toepassing retourneert op basis van de ID-waarde. ID=10, geldig antwoord. 
ID=1, controller-gebaseerde uitzonderingsafhandelaar gebruikt 
ID=2, globale uitzonderingsafhandelaar gebruikt met weergave als antwoord 
ID=3, 404-foutpagina gebruikt 
ID=4, simpleMappingExceptionResolver gebruikt voor responsweergave 
Zoals je kunt zien, hebben we in alle gevallen het verwachte antwoord gekregen.
Spring Uitzonderingshandler JSON-reactie
We zijn bijna klaar met onze tutorial, behalve het laatste stuk waarin ik zal uitleggen hoe je een JSON-reactie kunt verzenden vanuit de uitzonderingshandlermethoden. Onze applicatie heeft alle JSON-afhankelijkheden en jsonMessageConverter is geconfigureerd, het enige wat we hoeven te doen is de uitzonderingshandlermethode implementeren. Voor de eenvoud zal ik de handleEmployeeNotFoundException()-methode van de EmployeeController herschrijven om een JSON-reactie terug te geven. Werk gewoon de uitzonderingshandlermethode van de EmployeeController bij met de onderstaande code en implementeer de applicatie opnieuw.
@ExceptionHandler(EmployeeNotFoundException.class)
public @ResponseBody ExceptionJSONInfo handleEmployeeNotFoundException(HttpServletRequest request, Exception ex){
ExceptionJSONInfo response = new ExceptionJSONInfo();
response.setUrl(request.getRequestURL().toString());
response.setMessage(ex.getMessage());
return response;
}
Nu, wanneer we id als 1 gebruiken in het clientverzoek, krijgen we de volgende JSON-reactie zoals getoond in de onderstaande afbeelding. 
Dat is alles voor Spring Uitzonderingsafhandeling en Spring MVC Uitzonderingsafhandeling, download alsjeblieft de applicatie vanaf onderstaande URL en experimenteer ermee om meer te leren.