Requisitos previos: Spring MVC
Cuando algo sale mal con su aplicación, el servidor muestra una página de excepción que define el tipo de excepción, la página de excepción generada por el servidor no es fácil de usar. Spring MVC proporciona manejo de excepciones para su aplicación web para asegurarse de que está enviando su propia página de excepción en lugar de la excepción generada por el servidor al usuario. La anotación @ ExceptionHandler se usa para detectar ciertas excepciones de tiempo de ejecución y enviar respuestas de acuerdo con la excepción. En este artículo, proyectaremos Spring Mvc para mostrar cómo interceptar y definir excepciones, veremos cómo definir el nivel de método y la excepción de nivel de clase.
Pasos para crear la aplicación
Primero, cree un proyecto maven, estamos usando Eclipse IDE para este proyecto. Ahora, busque webapp, ya que estamos creando una aplicación web. Elija crear maven mientras crea un nuevo proyecto y agregue un arquetipo de aplicación web maven. Ingrese la identificación del grupo y la identificación del artefacto para su proyecto y haga clic en finalizar.
Después de hacer clic en finalizar, la estructura de su proyecto se vería así:
El pom.xml se crea automáticamente con cualquier proyecto maven, define todas las dependencias requeridas para el proyecto. Asegúrese de agregar todas las dependencias mencionadas en este archivo.
XML
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.gfg</groupId> <artifactId>SpringMvcExceptionHandling</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>war</packaging> <name>SpringMvcExceptionHandling Maven Webapp</name> <!-- FIXME change it to the project's website --> <url>http://www.example.com</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.7</maven.compiler.source> <maven.compiler.target>1.7</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.1.1.RELEASE</version> </dependency> <dependency> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-jasper</artifactId> <version>9.0.12</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>3.0-alpha-1</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> </dependencies> <build> <finalName>SpringMvcExceptionHandling</finalName> <pluginManagement> <plugins> <plugin> <artifactId>maven-clean-plugin</artifactId> <version>3.1.0</version> </plugin> <plugin> <artifactId>maven-resources-plugin</artifactId> <version>3.0.2</version> </plugin> <plugin> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.0</version> </plugin> <plugin> <artifactId>maven-surefire-plugin</artifactId> <version>2.22.1</version> </plugin> <plugin> <artifactId>maven-war-plugin</artifactId> <version>3.2.2</version> </plugin> <plugin> <artifactId>maven-install-plugin</artifactId> <version>2.5.2</version> </plugin> <plugin> <artifactId>maven-deploy-plugin</artifactId> <version>2.8.2</version> </plugin> </plugins> </pluginManagement> </build> </project>
El web.xml define el mapeo con diferentes URL y servlets para manejar las requests de esas URL.
XML
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> <servlet> <servlet-name>gfg</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/gfg-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>gfg</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>
El archivo gfg-servlet.xml maneja todas las requests HTTP para las aplicaciones web. El análisis de componentes localiza y asigna beans de acuerdo con la anotación definida. Las clases basadas en anotaciones habilitan las clases de anotaciones de primavera. La configuración del bean ayuda a identificar y escanear el JSP ubicado en la carpeta de vistas.
XML
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context \ http://www.springframework.org/schema/context/spring-context.xsd"> <context:component-scan base-package="com.gfg" /> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix"> <value>/WEB-INF/views/</value> </property> <property name="suffix"> <value>.jsp</value> </property> </bean> <mvc:annotation-driven /> </beans>
La clase Estudiante en com.gfg.model define el objeto estudiante con tres objetos firstName , lastName y rollNo . Tenga en cuenta que hemos mantenido el número de rollo como una string en lugar de un número entero, esto nos ayudará a verificar posibles excepciones de NumberFormat.
Java
package com.gfg.model;
public class Student {
private String firstName;
private String lastName;
private String rollNo;
public Student(String firstName, String lastName,
String rollNo)
{
super();
this.firstName = firstName;
this.lastName = lastName;
this.rollNo = rollNo;
}
public Student() {}
public String getFirstName() { return firstName; }
public void setFirstName(String firstName)
{
this.firstName = firstName;
}
public String getLastName() { return lastName; }
public void setLastName(String lastName)
{
this.lastName = lastName;
}
public String getRollNo() { return rollNo; }
public void setRollNo(String rollNo)
{
this.rollNo = rollNo;
}
}
La clase LoginController en el paquete com.gfg.controller define dos métodos, el método showForm define un mapeo Get y simplemente muestra el formulario de inicio de sesión del estudiante. El método processForm tiene dos parámetros de @ ModelAttribute para estudiantes y un modelo para establecer atributos en nuestras páginas de visualización. El parámetro del modelo establece todos los atributos de la página de visualización. Recuerde, en la clase Estudiante definimos rollNo como una String. Ahora, lo analizaremos en int: esto ayudará a detectar dos excepciones de NumberFormat. Si la string está vacía o la string tiene alfabetos para ambos, enviará una NumberFormatException. Ahora, para capturar esa excepción y manejarla por separado para una mejor experiencia del usuario, definimos un método numberformatHandler y lo anotamos con @ ExceptionHandler , y establecemos el valor en NumberFormatException.class . Entonces, esta era una forma de manejar Exception a nivel de método.
Java
package com.gfg.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import com.gfg.model.Student;
@Controller
public class LoginController {
@RequestMapping("/login")
public String showForm(Model theModel) {
theModel.addAttribute("student", new Student());
return "portal";
}
@RequestMapping("/welcome")
public String processForm(@ModelAttribute("welcome") Student student, Model mod) {
mod.addAttribute("FirstName", student.getFirstName());
mod.addAttribute("LastName", student.getLastName());
int n = Integer.parseInt(student.getRollNo());
mod.addAttribute("RollNo", n);
return "welcome";
}
@ExceptionHandler(value = NumberFormatException.class)
public String numberformatHandler(Model theModel) {
theModel.addAttribute("err", "NumberFormatException");
return "error";
}
}
La clase MyExceptionHandler en com.gfg.errorhandler define todas las excepciones para nuestra aplicación de modo que para un tipo diferente de excepción el usuario vea una página de error adecuada y simple. Para que esté disponible para todas las clases en nuestro proyecto, solo tenemos que agregar la anotación @ ControllerAdvice, esto recomendará a Spring MVC que use nuestro método de excepción en lugar de las páginas generadas por el servidor. Entonces, en esto hemos definido un controlador de excepciones a nivel de clase .
Java
package com.gfg.errorhandler;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
@ControllerAdvice
public class MyExceptionHandler {
@ExceptionHandler(value = NullPointerException.class)
public String nullPointerHandler(Model theModel) {
theModel.addAttribute("err", "NullPointerException");
return "error";
}
@ExceptionHandler(value = Exception.class)
public String AnyOtherHandler() {
return "error";
}
}
El archivo portal.jsp en la carpeta de vistas define el portal de inicio de sesión del estudiante.
HTML
<%@ taglib prefix="form" url="http://www.springframework.org/tags/form" %> <html> <head> </head> <body> <h1>Student Portal</h1> <form:form action="welcome" modelAttribute="student"> <label>First name:</label> <form:input path="firstName" /> <br><br> <label>Last name:</label> <form:input path="lastName" /> <br><br> <label>Roll No:</label> <form:input path="rollNo" /> <br><br> <input type="submit" value="Submit" /> </form:form> </body> </html>
La página welcome.jsp en la carpeta de vistas define la página de bienvenida para nuestra aplicación.
HTML
<%@ taglib prefix="form" url="http://www.springframework.org/tags/form" %> <html> <head> </head> <body> <h1>Student Portal</h1> <form:form action="welcome" modelAttribute="student"> <label>First name:</label> <form:input path="firstName" /> <br><br> <label>Last name:</label> <form:input path="lastName" /> <br><br> <label>Roll No:</label> <form:input path="rollNo" /> <br><br> <input type="submit" value="Submit" /> </form:form> </body> </html>
La página error.jsp es una página de manejo de excepciones simple que define el nombre de la excepción e informa al usuario sobre una excepción.
HTML
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Opps....</h1>
<h1> ${err} Exception caused</h1>
</body>
</html>
Después de agregar todas las clases y archivos de configuración, su proyecto se vería así:
Ahora que hemos completado nuestro proyecto, es hora de ejecutarlo en un servidor tomcat, simplemente inicie el servidor tomcat y escriba http:localhost:8080/SpringMvcExceptionHandling/login
Por lo tanto, en este proyecto de Spring MVC , definimos controladores de excepciones en el método y en el nivel de clase y definimos nuestra propia página de vista de excepciones personalizada para una mejor experiencia del usuario.
Publicación traducida automáticamente
Artículo escrito por ashutosh44 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA