O tratamento de exceções do Spring MVC é muito importante para garantir que você não esteja enviando exceções do servidor para o cliente. Hoje vamos analisar o tratamento de exceções do Spring usando @ExceptionHandler, @ControllerAdvice e HandlerExceptionResolver. Qualquer aplicativo web requer um bom design para o tratamento de exceções, pois não queremos servir uma página gerada pelo contêiner quando ocorrer qualquer exceção não tratada pelo nosso aplicativo.
Tratamento de Exceções do Spring
Ter uma abordagem de tratamento de exceções bem definida é um grande ponto positivo para qualquer framework de aplicativo web. Dito isso, o framework Spring MVC entrega um bom desempenho quando se trata de tratamento de exceções e erros em nossos aplicativos web. O framework Spring MVC fornece as seguintes maneiras de nos ajudar a alcançar um tratamento de exceções robusto.
- Controlador Baseado – Podemos definir métodos de tratamento de exceções em nossas classes de controlador. Tudo o que precisamos fazer é anotar esses métodos com a anotação
@ExceptionHandler. Esta anotação recebe a classe Exception como argumento. Portanto, se tivermos definido um desses para a classe Exception, então todas as exceções lançadas pelo nosso método de manipulação de solicitações serão tratadas. Esses métodos de tratamento de exceções são semelhantes a outros métodos de manipulação de solicitações e podemos construir uma resposta de erro e responder com uma página de erro diferente. Também podemos enviar uma resposta de erro JSON, que veremos mais tarde em nosso exemplo. Se houver vários métodos de tratamento de exceções definidos, o método de tratamento mais próximo da classe Exception é usado. Por exemplo, se tivermos dois métodos de tratamento definidos para IOException e Exception e nosso método de manipulação de solicitações lançar IOException, então o método de tratamento para IOException será executado. - Manipulador de Exceções Global – O tratamento de exceções é uma preocupação transversal, deve ser feito para todos os pontos de corte em nossa aplicação. Já exploramos o Spring AOP e é por isso que o Spring fornece a anotação
@ControllerAdviceque podemos usar com qualquer classe para definir nosso manipulador global de exceções. Os métodos de manipulador no Conselho Global do Controlador são os mesmos que os métodos de manipulação de exceções baseados em controlador e são usados quando a classe do controlador não consegue lidar com a exceção. - HandlerExceptionResolver – Para exceções genéricas, na maioria das vezes servimos páginas estáticas. O Spring Framework fornece a interface
HandlerExceptionResolverque podemos implementar para criar um manipulador de exceções global. A razão por trás deste modo adicional de definir um manipulador de exceções global é que o Spring framework também fornece classes de implementação padrão que podemos definir em nosso arquivo de configuração de beans do Spring para obter benefícios de tratamento de exceções do Spring framework.SimpleMappingExceptionResolveré a classe de implementação padrão, que nos permite configurar exceçãoMappings onde podemos especificar qual recurso usar para uma exceção específica. Também podemos substituí-lo para criar nosso próprio manipulador global com nossas mudanças específicas de aplicativo, como registro de mensagens de exceção.
Vamos criar um projeto Spring MVC onde vamos analisar a implementação de abordagens de tratamento de exceções e erros baseadas em Controller, baseadas em AOP e baseadas em Exception Resolver. Também escreveremos um método manipulador de exceções que retornará uma resposta JSON. Se você é novo em JSON no Spring, leia Spring Restful JSON Tutorial. Nosso projeto final ficará como a imagem abaixo, vamos analisar todos os componentes de nossa aplicação um por um. 
Dependências do Maven para Manipulação de Exceções no Spring
Além das dependências padrão do Spring MVC, também precisaremos da dependência Jackson JSON para suporte a JSON. Nosso arquivo pom.xml final fica assim.
<?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.
Descritor de Implantação para Manipulação de Exceções no Spring MVC
Nosso arquivo web.xml fica assim.
<?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>
A maior parte é para conectar o Spring Framework à nossa aplicação web, exceto pela página de erro definida para o erro 404. Então, quando nossa aplicação lançar o erro 404, esta página será usada como resposta. Essa configuração é usada pelo contêiner quando nossa aplicação web Spring lança o código de erro 404.
Manipulação de Exceções no Spring – Classes de Modelo
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;
}
}
Desde que também estaremos retornando uma resposta JSON, vamos criar uma classe Java Bean com detalhes da exceção que serão enviados como resposta.
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;
}
}
Tratamento de Exceções no Spring – Classe de Exceção Personalizada
Vamos criar uma classe de exceção personalizada para ser usada por nossa aplicação.
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);
}
}
Observe que podemos usar a anotação @ResponseStatus com classes de exceção para definir o código HTTP que será enviado pela nossa aplicação quando esse tipo de exceção for lançado e manipulado pelas implementações de tratamento de exceção. Como você pode ver, estou configurando o status HTTP como 404 e temos uma página de erro definida para isso, então nossa aplicação deve usar a página de erro para esse tipo de exceção se não estivermos retornando nenhuma visualização. Também podemos substituir o código de status em nosso método manipulador de exceção, pense nisso como o código de status HTTP padrão quando nosso método manipulador de exceção não está retornando nenhuma página de visualização como resposta.
Classe Controladora de Tratamento de Exceções do Spring MVC
Vamos dar uma olhada em nossa classe de controladora onde iremos lançar diferentes tipos de exceções.
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{
//lançando deliberadamente diferentes tipos de exceção
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;
}
}
Observe que, para o manipulador EmployeeNotFoundException, estou retornando ModelAndView e, portanto, o código de status http será enviado como OK (200). Se fosse retornando void, então o código de status http teria sido enviado como 404. Vamos analisar este tipo de implementação em nossa implementação de manipulador de exceções global. Uma vez que estou lidando apenas com EmployeeNotFoundException no controlador, todas as outras exceções lançadas pelo nosso controlador serão tratadas pelo manipulador de exceções global.
@ControllerAdvice e @ExceptionHandler
Aqui está a nossa classe de controlador de manipulador de exceções global. Observe que a classe é anotada com a anotação @ControllerAdvice. Além disso, os métodos são anotados com a anotação @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");
//retornando código de erro 404
}
}
Observe que para SQLException, estou retornando database_error.jsp como página de resposta com código de status HTTP 200. Para IOException, estamos retornando void com código de status 404, então nossa página de erro será usada nesse caso. Como você pode ver, não estou lidando com nenhum outro tipo de exceção aqui, essa parte deixei para a implementação do HandlerExceptionResolver.
HandlerExceptionResolver
Estamos apenas estendendo o SimpleMappingExceptionResolver e substituindo um de seus métodos, mas podemos substituir seu método mais importante resolveException para fazer log e enviar diferentes tipos de páginas de visualização. Mas isso é o mesmo que usar a implementação do ControllerAdvice, então estou deixando isso de lado. Usaremos para configurar a página de visualização para todas as outras exceções não tratadas por nós, respondendo com a página de erro genérica.
Arquivo de Configuração de Tratamento de Exceções do Spring
Nosso arquivo de configuração de bean do Spring parece o seguinte. Código 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>
Observe os feijões configurados para suportar JSON em nossa aplicação web. A única parte relacionada ao tratamento de exceções é a definição do feijão simpleMappingExceptionResolver, onde estamos definindo generic_error.jsp como a página de visualização para a classe Exception. Isso garante que qualquer exceção não tratada pela nossa aplicação não resultará no envio da página de erro gerada pelo servidor como resposta.
Spring MVC Exception Handling JSP View Pages
É hora de examinar a última parte de nossa aplicação, nossas páginas de visualização que serão usadas em nossa aplicação. Código 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 é usado para responder com dados válidos, ou seja, quando recebemos id como 10 na solicitação do cliente. Código 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 é usado para gerar a visualização para o código de status http 404, para nossa implementação, esta deve ser a resposta quando recebemos id como 3 na solicitação do cliente. Código 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 é usado quando o método manipulador de solicitações da nossa classe de controlador lança EmployeeNotFoundException. Devemos obter esta página como resposta quando o valor do id é 1 na solicitação do cliente. Código 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 é usado quando nossa aplicação lança SQLException, conforme configurado na classe GlobalExceptionHandler. Devemos obter esta página como resposta quando o valor do id é 2 na solicitação do cliente. Código 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>
Esta deve ser a página como resposta quando ocorrer qualquer exceção não tratada pelo código de nossa aplicação e o bean simpleMappingExceptionResolver cuidar disso. Devemos obter esta página como resposta quando o valor do ID na solicitação do cliente for diferente de 1, 2, 3 ou 10.
Executando a Aplicação de Tratamento de Exceções do Spring MVC
Basta implantar a aplicação no container de servlet que você está usando, estou usando o Apache Tomcat 7 como exemplo. As imagens abaixo mostram as diferentes páginas de resposta retornadas pela nossa aplicação com base no valor do id. ID=10, resposta válida. 
ID=1, manipulador de exceção baseado no controlador usado 
ID=2, manipulador de exceção global usado com visualização como resposta 
ID=3, página de erro 404 usada 
ID=4, simpleMappingExceptionResolver usado para visualização da resposta 
Como você pode ver, obtivemos a resposta esperada em todos os casos.
Resposta JSON do Manipulador de Exceções Spring
Estamos quase terminando nosso tutorial, exceto pela última parte onde explicarei como enviar uma resposta JSON a partir dos métodos manipuladores de exceção. Nossa aplicação possui todas as dependências JSON e o jsonMessageConverter está configurado, tudo o que precisamos fazer é implementar o método manipulador de exceção. Para simplicidade, vou reescrever o método handleEmployeeNotFoundException() do EmployeeController para retornar uma resposta JSON. Basta atualizar o método manipulador de exceção do EmployeeController com o código abaixo e implantar a aplicação novamente.
@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;
}
Agora, quando usamos id como 1 na solicitação do cliente, recebemos a seguinte resposta JSON conforme mostrado na imagem abaixo. 
Isso é tudo para o Tratamento de Exceções Spring e o Tratamento de Exceções Spring MVC, por favor, baixe a aplicação a partir da URL abaixo e explore-a para aprender mais.