Learn to program spring MVC exception handling is released, welcome to visit via Xuebiancheng8.com
There are two ways to deal with exceptions in Spring3.0: One is to use the handlerexceptionresolver interface, and one is to use it inside the controller class @ExceptionHandler annotations. The first approach enables global exception control, and spring already provides a default implementation class Simplemappingexceptionresolver In the second way, more personalized point exception handling can be implemented inside the controller with greater flexibility. In general, the project only need to adopt the first way, each person to define their own abnormal presentation way, too personality, not unity.
From the current survey results, these two ways can not coexist, do not know whether the future version will be able to integrate them, so as to be flexible configuration.
Exception handling based on the Handlerexceptionresolver interface:
In this way, you only need to implement the Resolveexception method, which returns a Modelandview object, determines the type of the exception inside the method, and then common appropriate Modelandview object, if the method returns NULL, Then spring will continue to look for other beans that implement the Handlerexceptionresolver interface. In other words, spring searches all the beans that have implemented the Handlerexceptionresolver interface in their environment, executing them one after the other, until a Modelandview object is returned.
Example code:
Java code
/**
* Exception handling class based on Handlerexceptionresolver interface
* @author Zywang 2011-4-2
*/
public class CustomExceptionHandler implements Handlerexceptionresolver {
@Override
Public Modelandview resolveexception (HttpServletRequest request,
HttpServletResponse response, Object object, Exception Exception) {
If (Exception instanceof IOException) {
return new Modelandview ("Ioexp");
}else if (Exception instanceof SQLException) {
return new Modelandview ("Sqlexp");
}
return null;
}
}
This class must be declared in spring, let Spring manage it, you can use the @component tag, or you can use the <bean/> node. To make exception handling simple, Spring provides the Simplemappingexceptionresolver class, which implements the Handlerexceptionresolver interface, which requires only the use of < The bean/> node is declared, with the following examples:
XML code
<bean class= "Org.springframework.web.servlet.handler.SimpleMappingExceptionResolver" >
<!--define the default exception handling page, which is used when registering the exception type.
<property name= "Defaulterrorview" value= "error" ></property>
<!--defines the name of the variable that the exception handling page uses to get the exception information, which is named exception by default
<property name= "Exceptionattribute" value= "ex" ></property>
<!--define exceptions that require special handling, with the class name or full pathname as key, and the name of the page as the value--
<property name= "Exceptionmappings" >
<props>
<prop key= "IOException" >error/ioexp</prop>
<prop key= "Java.sql.SQLException" >error/sqlexp</prop>
</props>
</property>
</bean>
With Simplemappingexceptionresolver we can map different exceptions to different JSP pages (through the configuration of the Exceptionmappings property), and we can also specify a default XOR for all exceptions.
Often prompt page (through the configuration of the Defaulterrorview property), if the thrown exception does not have a corresponding mapping in Exceptionmappings, spring will display the exception information with this default configuration (note that the exception display interface configured here includes only the main file name, As for the file path and suffix already specified in viewresolver).
A typical exception display page is as follows:
<body>
<% Exception ex = (Exception) request.getattribute ("Exception"); %>
<P/>
<% Ex.printstacktrace (New Java.io.PrintWriter (out)); %>
</body>
Exception is really simplemappingexceptionresolver stored in the request, you can view the source code.
If Simplemappingexceptionresolver cannot meet the need for exception handling, we can
The Handlerexceptionresolver interface implements its own exception-handling class, which is also very simple (it is only necessary to implement a
Resolveexception method).
If there is a viewresolver, then the JSP page must be under that page, then if you can't find the page, you can adjust the page path according to the error
@exceptionhandler-based exception handling:
The method needs to be defined inside the controller, then create a method and decorate it with @exceptionhandler annotations to handle the exception, which is basically the same method as @RequestMapping modification, Only one parameter of type exception can be added, and the type of one or more exceptions @ExceptionHandler, if empty, is considered to trigger all exception type errors.
Example code:
Java code
/**
* based on @exceptionhandler exception handling
* @ author zywang 2011-4-2
*/
@Controller
public class exceptionhandlercontroller {
@ExceptionHandler (value={ Ioexception.class,sqlexception.class})
public string exp (exception ex,httpservletrequest request) {
request.setattribute ("Ex", ex);
return "/error.jsp";
}
}
Learn to program spring MVC exception handling is released and is welcome to visit via Xuebiancheng8.com.
Spring MVC exception Handling
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
