La gestion des exceptions Spring MVC est très importante pour s’assurer que vous n’envoyez pas d’exceptions du serveur au client. Aujourd’hui, nous examinerons la gestion des exceptions Spring en utilisant @ExceptionHandler, @ControllerAdvice et HandlerExceptionResolver. Toute application web nécessite une bonne conception de la gestion des exceptions car nous ne voulons pas servir une page générée par le conteneur lorsque une exception non gérée est lancée par notre application.
Gestion des exceptions Spring
Avoir une approche bien définie de la gestion des exceptions est un énorme avantage pour n’importe quel framework d’application web, cela étant dit, le framework Spring MVC offre une bonne solution en matière de gestion des exceptions et des erreurs dans nos applications web. Le framework Spring MVC fournit les moyens suivants pour nous aider à réaliser une gestion robuste des exceptions.
- Basé sur le contrôleur – Nous pouvons définir des méthodes de gestion des exceptions dans nos classes de contrôleur. Tout ce dont nous avons besoin est d’annoter ces méthodes avec l’annotation
@ExceptionHandler. Cette annotation prend la classe Exception comme argument. Donc, si nous en avons défini une pour la classe Exception, alors toutes les exceptions lancées par notre méthode de gestion de requête seront gérées. Ces méthodes de gestion des exceptions sont comme les autres méthodes de gestion de requête et nous pouvons construire une réponse d’erreur et répondre avec une page d’erreur différente. Nous pouvons également envoyer une réponse d’erreur JSON, que nous verrons plus tard dans notre exemple. S’il existe plusieurs méthodes de gestion des exceptions définies, alors la méthode de gestion la plus proche de la classe Exception est utilisée. Par exemple, si nous avons deux méthodes de gestion définies pour IOException et Exception et que notre méthode de gestion de requête lance IOException, alors la méthode de gestion pour IOException sera exécutée. - Gestionnaire d’exceptions global – La gestion des exceptions est une préoccupation transversale, elle devrait être effectuée pour tous les points de coupe de notre application. Nous avons déjà examiné Spring AOP et c’est pourquoi Spring fournit l’annotation
@ControllerAdviceque nous pouvons utiliser avec n’importe quelle classe pour définir notre gestionnaire d’exceptions global. Les méthodes de gestion dans Global Controller Advice sont les mêmes que les méthodes de gestion des exceptions basées sur le contrôleur et sont utilisées lorsque la classe de contrôleur n’est pas capable de gérer l’exception. - Gestionnaire d’exceptions – Pour les exceptions génériques, la plupart du temps, nous servons des pages statiques. Le Framework Spring fournit l’interface
HandlerExceptionResolverque nous pouvons implémenter pour créer un gestionnaire d’exceptions global. La raison derrière cette manière supplémentaire de définir un gestionnaire d’exceptions global est que le framework Spring fournit également des classes d’implémentation par défaut que nous pouvons définir dans notre fichier de configuration de bean Spring pour bénéficier de la gestion des exceptions du framework Spring.SimpleMappingExceptionResolverest la classe d’implémentation par défaut, elle nous permet de configurer des exceptionMappings où nous pouvons spécifier quelle ressource utiliser pour une exception particulière. Nous pouvons également la remplacer pour créer notre propre gestionnaire global avec nos propres modifications spécifiques à l’application, telles que le journalisation des messages d’exception.
Créons un projet Spring MVC où nous examinerons la mise en œuvre des approches de gestion des exceptions et des erreurs basées sur les contrôleurs, basées sur l’AOP et basées sur le gestionnaire d’exceptions. Nous écrirons également une méthode de gestionnaire d’exceptions qui renverra une réponse JSON. Si vous êtes nouveau dans l’utilisation de JSON avec Spring, lisez Tutoriel Spring Restful JSON. Notre projet final ressemblera à l’image ci-dessous, nous examinerons tous les composants de notre application un par un. 
Gestion des exceptions de printemps Dépendances Maven
En plus des dépendances standard de Spring MVC, nous aurions également besoin de la dépendance Jackson JSON pour le support JSON. Notre fichier pom.xml final ressemble à ce qui suit.
<?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.
Descripteur de déploiement de gestion des exceptions Spring MVC
Notre fichier web.xml ressemble à ce qui suit.
<?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>
La plupart de la partie est pour brancher le Framework Spring pour notre application web, sauf la page d’erreur définie pour l’erreur 404. Ainsi, lorsque notre application lancera une erreur 404, cette page sera utilisée comme réponse. Cette configuration est utilisée par le conteneur lorsque notre application web Spring lance le code d’erreur 404.
Gestion des exceptions de printemps – Classes de modèle
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;
}
}
Depuis que nous allons également renvoyer une réponse JSON, créons une classe Java Bean avec les détails de l’exception qui seront envoyés en tant que réponse.
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;
}
}
Gestion des exceptions Spring – Classe d’exception personnalisée
Créons une classe d’exception personnalisée à utiliser par notre application.
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);
}
}
Remarquez que nous pouvons utiliser l’annotation @ResponseStatus avec les classes d’exception pour définir le code HTTP qui sera envoyé par notre application lorsque ce type d’exception est levé par notre application et traité par nos implémentations de gestion des exceptions. Comme vous pouvez le voir, je définis le statut HTTP comme 404 et nous avons une page d’erreur définie pour cela, donc notre application devrait utiliser la page d’erreur pour ce type d’exception si nous ne renvoyons pas de vue. Nous pouvons également remplacer le code de statut dans notre méthode de gestionnaire d’exceptions, pensez-y comme le code de statut HTTP par défaut lorsque notre méthode de gestionnaire d’exceptions ne renvoie aucune vue en tant que réponse.
Contrôleur de gestion des exceptions Spring MVC – Gestionnaire d’exceptions de classe
Jetons un coup d’œil à notre classe de contrôleur où nous lèverons différents types d’exceptions.
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{
//lancer délibérément différents types d'exceptions
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;
}
}
Remarquez que pour le gestionnaire EmployeeNotFoundException, je renvoie un ModelAndView et donc le code de statut HTTP sera envoyé en tant que OK (200). Si cela avait renvoyé void, alors le code de statut HTTP aurait été envoyé en tant que 404. Nous examinerons ce type de mise en œuvre dans notre implémentation de gestionnaire d’exceptions global. Étant donné que je ne gère que EmployeeNotFoundException dans le contrôleur, toutes les autres exceptions levées par notre contrôleur seront gérées par le gestionnaire d’exceptions global.
@ControllerAdvice et @ExceptionHandler
Voici notre classe de contrôleur de gestionnaire d’exceptions global. Remarquez que la classe est annotée avec l’annotation @ControllerAdvice. De plus, les méthodes sont annotées avec l’annotation @ExceptionHandler.
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");
//retourne le code d'erreur 404
}
}
Remarquez que pour SQLException, je retourne database_error.jsp en tant que page de réponse avec le code de statut HTTP 200. Pour IOException, nous retournons void avec le code de statut 404, donc notre error-page sera utilisée dans ce cas. Comme vous pouvez le voir, je ne gère aucun autre type d’exception ici, cette partie je l’ai laissée à l’implémentation HandlerExceptionResolver.
HandlerExceptionResolver
Nous étendons simplement SimpleMappingExceptionResolver et remplaçons l’une de ses méthodes, mais nous pouvons remplacer sa méthode la plus importante resolveException pour la journalisation et l’envoi de différents types de pages de vue. Mais c’est la même chose que d’utiliser l’implémentation ControllerAdvice, donc je le laisse. Nous l’utiliserons pour configurer la page de vue pour toutes les autres exceptions non gérées par nous en répondant avec une page d’erreur générique.
Fichier de configuration de gestion des exceptions Spring
Notre fichier de configuration de bean Spring ressemble à ce qui suit. Code spring.xml :
<?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>
Remarquez les beans configurés pour prendre en charge JSON dans notre application web. La seule partie liée à la gestion des exceptions est la définition du bean simpleMappingExceptionResolver où nous définissons generic_error.jsp comme page de vue pour la classe Exception. Cela garantit que toute exception non gérée par notre application ne résultera pas en l’envoi d’une page d’erreur générée par le serveur en tant que réponse.
Gestion des exceptions Spring MVC JSP Vue Pages
Il est temps de se pencher sur la dernière partie de notre application, nos pages de vue qui seront utilisées dans notre application. Code home.jsp:
<%@ 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 est utilisé pour répondre avec des données valides, c’est-à-dire lorsque nous obtenons un identifiant de 10 dans la requête du client. Code 404.jsp:
<%@ 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 est utilisé pour générer la vue pour le code d’état 404 http, pour notre implémentation cela devrait être la réponse lorsque nous obtenons un identifiant de 3 dans la requête du client. Code error.jsp:
<%@ 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 est utilisé lorsque la méthode de gestionnaire de demande de classe de notre contrôleur lance EmployeeNotFoundException. Nous devrions obtenir cette page en réponse lorsque la valeur de l’identifiant est de 1 dans la requête du client. Code database_error.jsp:
<%@ 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 est utilisé lorsque notre application génère une SQLException, comme configuré dans la classe GlobalExceptionHandler. Nous devrions obtenir cette page en réponse lorsque la valeur de l’identifiant est de 2 dans la requête du client. Code generic_error.jsp:
<%@ 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>
Cela devrait être la page en réponse lorsqu’une exception non gérée se produit et que le bean simpleMappingExceptionResolver s’en occupe. Nous devrions obtenir cette page en réponse lorsque la valeur d’identifiant dans la requête du client est autre que 1, 2, 3 ou 10.
Exécution de l’application de gestion des exceptions Spring MVC
Il suffit de déployer l’application dans le conteneur de servlet que vous utilisez, j’utilise Apache Tomcat 7 pour cet exemple. Les images ci-dessous montrent les différentes pages de réponse renvoyées par notre application en fonction de la valeur de l’identifiant. ID=10, réponse valide. 
ID=1, gestionnaire d’exceptions basé sur le contrôleur utilisé 
ID=2, gestionnaire d’exceptions global utilisé avec vue comme réponse 
ID=3, page d’erreur 404 utilisée 
ID=4, simpleMappingExceptionResolver utilisé pour la vue de réponse 
Comme vous pouvez le voir, nous avons obtenu la réponse attendue dans tous les cas.
Gestionnaire d’exceptions Spring Réponse JSON
Nous sommes presque arrivés à la fin de notre tutoriel, sauf la dernière partie où j’expliquerai comment envoyer une réponse JSON à partir des méthodes de gestionnaire d’exceptions. Notre application dispose de toutes les dépendances JSON et jsonMessageConverter est configuré, tout ce que nous avons à faire est de mettre en œuvre la méthode de gestionnaire d’exceptions. Pour simplifier, je vais réécrire la méthode handleEmployeeNotFoundException() du contrôleur Employee pour retourner une réponse JSON. Mettez simplement à jour la méthode de gestionnaire d’exceptions du contrôleur Employee avec le code ci-dessous et déployez à nouveau l’application.
@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;
}
Maintenant, lorsque nous utilisons l’identifiant 1 dans la requête du client, nous obtenons la réponse JSON suivante comme indiqué dans l’image ci-dessous. 
C’est tout pour la gestion des exceptions Spring et la gestion des exceptions Spring MVC, veuillez télécharger l’application à partir de l’URL ci-dessous et explorez-la pour en savoir plus.