spring mvc 异常统一处理

三. spring mvc 异常统一处理

博客分类:  spring3系列
 

SpringMVC 提供的异常处理主要有两种方式,一种是直接实现自己的HandlerExceptionResolver,另一种是使用注解的方式实现一个专门用于处理异常的Controller——ExceptionHandler。前者当发生异常时,页面会跳到指定的错误页面,后者同样,只是后者会在每个controller中都需要加入重复的代码。如何进行简单地统一配置异常,使得发生普通错误指定到固定的页面,ajax发生错直接通过js获取,展现给用户,变得非常重要。下面先介绍下2种异常处理方式,同时,结合现有的代码,让其支持ajax方式,实现spring MVC web系统的异常统一处理。

 

1、实现自己的HandlerExceptionResolver,HandlerExceptionResolver是一个接口,springMVC本身已经对其有了一个自身的实现——DefaultExceptionResolver,该解析器只是对其中的一些比较典型的异常进行了拦截处理 。

 

Java代码   收藏代码
  1. import javax.servlet.http.HttpServletRequest;  
  2. import javax.servlet.http.HttpServletResponse;  
  3.   
  4. import org.springframework.web.servlet.HandlerExceptionResolver;  
  5. import org.springframework.web.servlet.ModelAndView;  
  6.   
  7. public class ExceptionHandler implements HandlerExceptionResolver {  
  8.   
  9.     @Override   
  10.     public ModelAndView resolveException(HttpServletRequest request,  
  11.             HttpServletResponse response, Object handler, Exception ex) {  
  12.         // TODO Auto-generated method stub  
  13.         return new ModelAndView("exception");  
  14.     }  
  15.   
  16. }  

 

 上述的resolveException的第4个参数表示对哪种类型的异常进行处理,如果想同时对多种异常进行处理,可以把它换成一个异常数组。

定义了这样一个异常处理器之后就要在applicationContext中定义这样一个bean对象,如:

Xml代码   收藏代码
  1. <bean id="exceptionResolver" class="com.tiantian.xxx.web.handler.ExceptionHandler"/>  

 

2、使用@ExceptionHandler进行处理

使用@ExceptionHandler进行处理有一个不好的地方是进行异常处理的方法必须与出错的方法在同一个Controller里面

如:

Java代码   收藏代码
  1. import org.springframework.stereotype.Controller;  
  2. import org.springframework.web.bind.annotation.ExceptionHandler;  
  3. import org.springframework.web.bind.annotation.RequestMapping;  
  4.   
  5. import com.tiantian.blog.web.servlet.MyException;  
  6.   
  7. @Controller   
  8. public class GlobalController {  
  9.   
  10.       
  11.     /** 
  12.      * 用于处理异常的 
  13.      * @return  
  14.      */  
  15.     @ExceptionHandler({MyException.class})  
  16.     public String exception(MyException e) {  
  17.         System.out.println(e.getMessage());  
  18.         e.printStackTrace();  
  19.         return "exception";  
  20.     }  
  21.       
  22.     @RequestMapping("test")  
  23.     public void test() {  
  24.         throw new MyException("出错了!");  
  25.     }  
  26.       
  27.       
  28. }  

 

这里在页面上访问test方法的时候就会报错,而拥有该test方法的Controller又拥有一个处理该异常的方法,这个时候处理异常的方法就会被调用。当发生异常的时候,上述两种方式都使用了的时候,第一种方式会将第二种方式覆盖。

 

3. 针对Spring MVC 框架,修改代码实现普通异常及ajax异常的全部统一处理解决方案。

在上篇文章中,关于spring异常框架体系讲的非常清楚,Dao层,以及sevcie层异常我们建立如下异常。

Java代码   收藏代码
  1. package com.jason.exception;  
  2.   
  3. public class BusinessException extends Exception {  
  4.   
  5.     private static final long serialVersionUID = 1L;  
  6.   
  7.     public BusinessException() {  
  8.         // TODO Auto-generated constructor stub  
  9.     }  
  10.   
  11.     public BusinessException(String message) {  
  12.         super(message);  
  13.         // TODO Auto-generated constructor stub  
  14.     }  
  15.   
  16.     public BusinessException(Throwable cause) {  
  17.         super(cause);  
  18.         // TODO Auto-generated constructor stub  
  19.     }  
  20.   
  21.     public BusinessException(String message, Throwable cause) {  
  22.         super(message, cause);  
  23.         // TODO Auto-generated constructor stub  
  24.     }  
  25.   
  26. }  

 

Java代码   收藏代码
  1. package com.jason.exception;  
  2.   
  3. public class SystemException extends RuntimeException {  
  4.   
  5.     private static final long serialVersionUID = 1L;  
  6.   
  7.     public SystemException() {  
  8.         // TODO Auto-generated constructor stub  
  9.     }  
  10.   
  11.     /** 
  12.      * @param message 
  13.      */  
  14.     public SystemException(String message) {  
  15.         super(message);  
  16.         // TODO Auto-generated constructor stub  
  17.     }  
  18.   
  19.     /** 
  20.      * @param cause 
  21.      */  
  22.     public SystemException(Throwable cause) {  
  23.         super(cause);  
  24.         // TODO Auto-generated constructor stub  
  25.     }  
  26.   
  27.     /** 
  28.      * @param message 
  29.      * @param cause 
  30.      */  
  31.     public SystemException(String message, Throwable cause) {  
  32.         super(message, cause);  
  33.         // TODO Auto-generated constructor stub  
  34.     }  
  35.   
  36. }  

 

在sevice层我们需要将建立的异常抛出,在controller层,我们需要捕捉异常,将其转换直接抛出,抛出的异常,希望能通过我们自己统一的配置,支持普通页面和ajax方式的页面处理,下面就详细讲一下步骤。

(1) 配置web.xml 文件,将常用的异常进行配置,配置文件如下403,404,405,500页面都配置好了:

 

Xml代码   收藏代码
  1. xml version="1.0" encoding="UTF-8"?>  
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">  
  3.   <display-name>SpringJSONdisplay-name>  
  4.   <context-param>    
  5.         <param-name>webAppRootKeyparam-name>    
  6.         <param-value>SpringJSON.webapp.rootparam-value>    
  7.    context-param>   
  8.     
  9.       
  10.     <context-param>  
  11.         <param-name>log4jConfigLocationparam-name>  
  12.         <param-value>classpath:log4j.xmlparam-value>  
  13.     context-param>  
  14.       
  15.       
  16.     <context-param>  
  17.         <param-name>log4jRefreshIntervalparam-name>  
  18.         <param-value>60000param-value>  
  19.     context-param>  
  20.   
  21.       
  22.       
  23.       
  24.     <context-param>  
  25.         <param-name>contextConfigLocationparam-name>  
  26.         <param-value>classpath:applicationContext.xmlparam-value>  
  27.     context-param>  
  28.       
  29.     <listener>  
  30.         <listener-class>org.springframework.web.util.Log4jConfigListenerlistener-class>  
  31.     listener>  
  32.     <listener>  
  33.         <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>  
  34.     listener>  
  35.     <listener>  
  36.         <listener-class>org.springframework.web.util.IntrospectorCleanupListenerlistener-class>  
  37.     listener>  
  38.       
  39.       
  40.       
  41.     <filter>  
  42.         <filter-name>CharacterEncodingFilterfilter-name>  
  43.         <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>  
  44.         <init-param>  
  45.             <param-name>encodingparam-name>  
  46.             <param-value>UTF-8param-value>  
  47.         init-param>  
  48.         <init-param>  
  49.             <param-name>forceEncodingparam-name>  
  50.             <param-value>trueparam-value>  
  51.         init-param>  
  52.     filter>  
  53.     <filter-mapping>  
  54.         <filter-name>CharacterEncodingFilterfilter-name>  
  55.         <url-pattern>/*url-pattern>  
  56.     filter-mapping>  
  57.       
  58.       
  59.     <servlet>  
  60.         <servlet-name>SpringJSONservlet-name>  
  61.         <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>  
  62.         <init-param>  
  63.             <param-name>contextConfigLocationparam-name>  
  64.             <param-value>classpath:spring/applicationContext-servlet.xmlparam-value>  
  65.         init-param>  
  66.         <load-on-startup>1load-on-startup>  
  67.     servlet>  
  68.       
  69.       
  70.     <servlet-mapping>  
  71.         <servlet-name>SpringJSONservlet-name>  
  72.         <url-pattern>*.htmlurl-pattern>  
  73.     servlet-mapping>  
  74.     <welcome-file-list>  
  75.         <welcome-file>index.htmlwelcome-file>  
  76.     welcome-file-list>  
  77.     <error-page>  
  78.         <error-code>403error-code>  
  79.         <location>/WEB-INF/pages/error/403.jsplocation>  
  80.     error-page>  
  81.     <error-page>  
  82.         <error-code>404error-code>  
  83.         <location>/WEB-INF/pages/error/404.jsplocation>  
  84.     error-page>  
  85.     <error-page>  
  86.         <error-code>405error-code>  
  87.         <location>/WEB-INF/pages/error/405.jsplocation>  
  88.     error-page>  
  89.     <error-page>  
  90.         <error-code>500error-code>  
  91.         <location>/WEB-INF/pages/error/500.jsplocation>  
  92.     error-page>  
  93. web-app>  

 2.建立相应的error页面,其中errorpage.jsp 是业务异常界面

Html代码   收藏代码
  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8" isErrorPage="true"%>  
  2. <%@ include file="/common/taglibs.jsp"%>  
  3. >  
  4. <html xmlns="http://www.w3.org/1999/xhtml">  
  5. <head>  
  6.     <title>error pagetitle>  
  7.     <script type="text/javascript">  
  8.         $(function(){  
  9.             $("#center-div").center(true);  
  10.         })  
  11.     script>  
  12. head>  
  13. <body style="margin: 0;padding: 0;background-color: #f5f5f5;">  
  14.     <div id="center-div">  
  15.         <table style="height: 100%; width: 600px; text-align: center;">  
  16.             <tr>  
  17.                 <td>  
  18.                 <img width="220" height="393" src="${basePath}/images/common/error.png" style="float: left; padding-right: 20px;" alt="" />  
  19.                     <%= exception.getMessage()%>  
  20.                     <p style="line-height: 12px; color: #666666; font-family: Tahoma, '宋体'; font-size: 12px; text-align: left;">  
  21.                     <a href="javascript:history.go(-1);">返回a>!!!  
  22.                     p>  
  23.                 td>  
  24.             tr>  
  25.         table>  
  26.     div>  
  27. body>  
  28. html>  

spring mvc 异常统一处理_第1张图片
 errorpage.jsp代码内容如下:

Html代码   收藏代码
  1.   

 

3.分析spring源码,自定义SimpleMappingExceptionResolver覆盖spring的SimpleMappingExceptionResolver。

关于SimpleMappingExceptionResolver的用法,大家都知道,只需在application-servlet.xml中做如下的配置

Java代码   收藏代码
  1. "exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">  
  2.       "exceptionMappings">   
  3.            
  4.           "com.jason.exception.SystemException">error/500   
  5.           "com.jason.exception.BusinessException">error/errorpage  
  6.           "java.lang.exception">error/500  
  7.             
  8.           
  9.         
  10.       

 观察SimpleMappingExceptionResolver,我们可以复写其doResolveException(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex)方法,通过修改该方法实现普通异常和ajax异常的处理,代码如下:

 

Java代码   收藏代码
  1. package com.jason.exception;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.PrintWriter;  
  5.   
  6. import javax.servlet.http.HttpServletRequest;  
  7. import javax.servlet.http.HttpServletResponse;  
  8.   
  9. import org.springframework.web.servlet.ModelAndView;  
  10. import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;  
  11.   
  12. public class CustomSimpleMappingExceptionResolver extends  
  13.         SimpleMappingExceptionResolver {  
  14.   
  15.     @Override  
  16.     protected ModelAndView doResolveException(HttpServletRequest request,  
  17.             HttpServletResponse response, Object handler, Exception ex) {  
  18.         // Expose ModelAndView for chosen error view.  
  19.         String viewName = determineViewName(ex, request);  
  20.         if (viewName != null) {// JSP格式返回  
  21.             if (!(request.getHeader("accept").indexOf("application/json") > -1 || (request  
  22.                     .getHeader("X-Requested-With")!= null && request  
  23.                     .getHeader("X-Requested-With").indexOf("XMLHttpRequest") > -1))) {  
  24.                 // 如果不是异步请求  
  25.                 // Apply HTTP status code for error views, if specified.  
  26.                 // Only apply it if we're processing a top-level request.  
  27.                 Integer statusCode = determineStatusCode(request, viewName);  
  28.                 if (statusCode != null) {  
  29.                     applyStatusCodeIfPossible(request, response, statusCode);  
  30.                 }  
  31.                 return getModelAndView(viewName, ex, request);  
  32.             } else {// JSON格式返回  
  33.                 try {  
  34.                     PrintWriter writer = response.getWriter();  
  35.                     writer.write(ex.getMessage());  
  36.                     writer.flush();  
  37.                 } catch (IOException e) {  
  38.                     e.printStackTrace();  
  39.                 }  
  40.                 return null;  
  41.   
  42.             }  
  43.         } else {  
  44.             return null;  
  45.         }  
  46.     }  
  47. }  

 

配置application-servelt.xml如下:(代码是在大的工程中提炼出来的,具体有些东西这里不做处理)

 

Java代码   收藏代码
  1. "1.0" encoding="UTF-8"?>  
  2. "http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:mvc="http://www.springframework.org/schema/mvc"  
  5.        xmlns:p="http://www.springframework.org/schema/p"  
  6.        xmlns:context="http://www.springframework.org/schema/context"  
  7.        xmlns:aop="http://www.springframework.org/schema/aop"  
  8.        xmlns:tx="http://www.springframework.org/schema/tx"  
  9.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  10.             http://www.springframework.org/schema/beans/spring-beans.xsd  
  11.             http://www.springframework.org/schema/context   
  12.             http://www.springframework.org/schema/context/spring-context.xsd  
  13.             http://www.springframework.org/schema/aop   
  14.             http://www.springframework.org/schema/aop/spring-aop.xsd  
  15.             http://www.springframework.org/schema/tx   
  16.             http://www.springframework.org/schema/tx/spring-tx.xsd  
  17.             http://www.springframework.org/schema/mvc   
  18.             http://www.springframework.org/schema/mvc/spring-mvc.xsd  
  19.             http://www.springframework.org/schema/context   
  20.             http://www.springframework.org/schema/context/spring-context.xsd">  
  21.               
  22.       
  23.     "/images/**" location="/images/"/>  
  24.     "/css/**" location="/css/"/>  
  25.     "/js/**" location="/js/"/>  
  26.     "/html/**" location="/html/"/>  
  27.     "/common/**" location="/common/"/>  
  28.       
  29.       
  30.       
  31.       
  32.       
  33.     package="com.jason.web"/>  
  34.       
  35.     "captchaProducer" name= "captchaProducer" class="com.google.code.kaptcha.impl.DefaultKaptcha">    
  36.         "config">    
  37.             class="com.google.code.kaptcha.util.Config">    
  38.                     
  39.                         
  40.                         "kaptcha.image.width">300  
  41.                         "kaptcha.image.height">60  
  42.                         "kaptcha.textproducer.char.string">0123456789  
  43.                         "kaptcha.textproducer.char.length">4   
  44.                         
  45.                     
  46.                 
  47.             
  48.        
  49.        
  50.       
  51.      "exceptionResolver" class="com.jason.exception.CustomSimpleMappingExceptionResolver">  
  52.       "exceptionMappings">   
  53.            
  54.           "com.jason.exception.SystemException">error/500   
  55.           "com.jason.exception.BusinessException">error/errorpage  
  56.           "java.lang.exception">error/500  
  57.             
  58.           
  59.         
  60.       
  61.       
  62.       
  63.     class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">  
  64.       "messageConverters">     
  65.               
  66.              class = "org.springframework.http.converter.StringHttpMessageConverter">     
  67.                 "supportedMediaTypes">  
  68.                         
  69.                           text/html;charset=UTF-8     
  70.                           
  71.                      
  72.                   
  73.               
  74.          
  75.       
  76.       
  77.       
  78.     "viewResolver"  class="org.springframework.web.servlet.view.InternalResourceViewResolver"   
  79.         p:prefix="/WEB-INF/pages/"   
  80.         p:suffix=".jsp" />  
  81.   

 

至此,整个异常体系架构配置成功,当整个工程出现异常时,页面会根据web.xml跳转到指定的页面。当在系统应用中出现普通异常时,根据是系统异常还是应用异常,跳到相应的界面,当ajax异常时,在ajax的error中可直接获得异常。普通的异常我们都配置好了界面,系统会自动跳转,主要看一下ajax的方式。

具体演示如下:

在登录界面建立如下的controller

Java代码   收藏代码
  1. package com.jason.web;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.Date;  
  5. import java.util.HashMap;  
  6. import java.util.Map;  
  7.   
  8. import javax.servlet.http.HttpServletRequest;  
  9. import javax.servlet.http.HttpServletResponse;  
  10. import javax.servlet.http.HttpSession;  
  11.   
  12. import org.apache.commons.lang.StringUtils;  
  13. import org.springframework.beans.factory.annotation.Autowired;  
  14. import org.springframework.stereotype.Controller;  
  15. import org.springframework.web.bind.annotation.RequestMapping;  
  16. import org.springframework.web.bind.annotation.ResponseBody;  
  17. import org.springframework.web.servlet.ModelAndView;  
  18.   
  19. import com.jason.domain.User;  
  20. import com.jason.exception.BusinessException;  
  21. import com.jason.service.UserService;  
  22. import com.jason.util.Constants;  
  23. import com.jason.web.dto.LoginCommand;  
  24.   
  25. @Controller  
  26. public class LoginController {  
  27.   
  28.     @Autowired  
  29.     private UserService userService;  
  30.   
  31.     /** 
  32.      * jump into the login page 
  33.      *  
  34.      * @return 
  35.      * @throws BusinessException 
  36.      * @throws 
  37.      * @throws BusinessException 
  38.      */  
  39.     @RequestMapping(value = "/index.html")  
  40.     public String loginPage() throws BusinessException {  
  41.         return Constants.LOGIN_PAGE;  
  42.     }  
  43.   
  44.     /** 
  45.      * get the json object 
  46.      *  
  47.      * @return 
  48.      * @throws Exception 
  49.      */  
  50.     @RequestMapping(value = "/josontest.html")  
  51.     public @ResponseBody  
  52.     Map getjson() throws BusinessException {  
  53.         Map map = new HashMap();  
  54.         try {  
  55.             map.put("content""123");  
  56.             map.put("result"true);  
  57.             map.put("account"1);  
  58.             throw new Exception();  
  59.         } catch (Exception e) {  
  60.             throw new BusinessException("detail of ajax exception information");  
  61.         }  
  62.     }  
  63.   
  64.     /** 
  65.      * login in operation 
  66.      *  
  67.      * @param request 
  68.      * @param loginCommand 
  69.      * @return 
  70.      * @throws IOException 
  71.      */  
  72.     @RequestMapping(value = "/login.html")  
  73.     public ModelAndView loginIn(HttpServletRequest request,  
  74.             HttpServletResponse respone, LoginCommand loginCommand)  
  75.             throws IOException {  
  76.   
  77.         boolean isValidUser = userService.hasMatchUser(  
  78.                 loginCommand.getUserName(), loginCommand.getPassword());  
  79.         boolean isValidateCaptcha = validateCaptcha(request, loginCommand);  
  80.   
  81.         ModelAndView modeview = new ModelAndView(Constants.LOGIN_PAGE);  
  82.   
  83.         if (!isValidUser) {  
  84.             // if have more information,you can put a map to modelView,this use  
  85.             // internalization  
  86.             modeview.addObject("loginError""login.user.error");  
  87.             return modeview;  
  88.         } else if (!isValidateCaptcha) {  
  89.             // if have more information,you can put a map to modelView,this use  
  90.             // internalization  
  91.             modeview.addObject("loginError""login.user.kaptchaError");  
  92.             return modeview;  
  93.         } else {  
  94.             User user = userService.findUserByUserName(loginCommand  
  95.                     .getUserName());  
  96.             user.setLastIp(request.getLocalAddr());  
  97.             user.setLastVisit(new Date());  
  98.   
  99.             userService.loginSuccess(user);  
  100.   
  101.             // we can also use  
  102.             request.getSession().setAttribute(Constants.LOGINED, user);  
  103.             String uri = (String) request.getSession().getAttribute(  
  104.                     Constants.CURRENTPAGE);  
  105.             if (uri != null  
  106.                     && !StringUtils.equalsIgnoreCase(uri,  
  107.                             Constants.CAPTCHA_IMAGE)) {  
  108.                 respone.sendRedirect(request.getContextPath() + uri);  
  109.             }  
  110.             return new ModelAndView(Constants.FRONT_MAIN_PAGE);  
  111.         }  
  112.     }  
  113.   
  114.     /** 
  115.      * logout operation 
  116.      *  
  117.      * @param request 
  118.      * @param response 
  119.      * @return 
  120.      */  
  121.     @RequestMapping(value = "/logout.html")  
  122.     public ModelAndView logout(HttpServletRequest request,  
  123.             HttpServletResponse response) {  
  124.   
  125.         /* 
  126.          * HttpServletRequest.getSession(ture) equals to 
  127.          * HttpServletRequest.getSession() means a new session created if no 
  128.          * session exists request.getSession(false) means if session exists get 
  129.          * the session,or value null 
  130.          */  
  131.         HttpSession session = request.getSession(false);  
  132.   
  133.         if (session != null) {  
  134.             session.invalidate();  
  135.         }  
  136.   
  137.         return new ModelAndView("redirect:/index.jsp");  
  138.     }  
  139.   
  140.     /** 
  141.      * check the Captcha code 
  142.      *  
  143.      * @param request 
  144.      * @param command 
  145.      * @return 
  146.      */  
  147.     protected Boolean validateCaptcha(HttpServletRequest request, Object command) {  
  148.         String captchaId = (String) request.getSession().getAttribute(  
  149.                 com.google.code.kaptcha.Constants.KAPTCHA_SESSION_KEY);  
  150.         String response = ((LoginCommand) command).getKaptchaCode();  
  151.         if (!StringUtils.equalsIgnoreCase(captchaId, response)) {  
  152.             return false;  
  153.         }  
  154.         return true;  
  155.     }  
  156. }  

 首先看一下ajax的方式,在controller中我们认为让ajax抛出一样,在页面中我们采用js这样调用

Js代码   收藏代码
  1. function ajaxTest()  
  2.     {  
  3.         $.ajax( {  
  4.             type : 'GET',  
  5.             //contentType : 'application/json',     
  6.             url : '${basePath}/josontest.html',     
  7.             async: false,//禁止ajax的异步操作,使之顺序执行。  
  8.             dataType : 'json',  
  9.             success : function(data,textStatus){  
  10.                 alert(JSON.stringify(data));  
  11.             },  
  12.             error : function(data,textstatus){  
  13.                 alert(data.responseText);  
  14.             }  
  15.         });  
  16.     }  

 当抛出异常是,我们在js的error中采用 alert(data.responseText);将错误信息弹出,展现给用户,具体页面代码如下:

Html代码   收藏代码
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"  
  2.     pageEncoding="UTF-8"%>  
  3. <%@ include file="/common/taglibs.jsp"%>  
  4. >  
  5. <html>  
  6.  <head>  
  7.   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  8.   <title>spring login informationtitle>  
  9.   <script type="text/javascript">  
  10.     function ajaxTest()  
  11.     {  
  12.         $.ajax( {  
  13.             type : 'GET',  
  14.             //contentType : 'application/json',     
  15.             url : '${basePath}/josontest.html',     
  16.             async: false,//禁止ajax的异步操作,使之顺序执行。  
  17.             dataType : 'json',  
  18.             success : function(data,textStatus){  
  19.                 alert(JSON.stringify(data));  
  20.             },  
  21.             error : function(data,textstatus){  
  22.                 alert(data.responseText);  
  23.             }  
  24.         });  
  25.     }  
  26.   script>  
  27.  head>  
  28.  <body>  
  29.     <table cellpadding="0" cellspacing="0" style="width:100%;">  
  30.       <tr>  
  31.           <td rowspan="2" style="width:30px;">  
  32.           td>  
  33.           <td style="height:72px;">  
  34.               <div>  
  35.                   spring login front information  
  36.               div>  
  37.               <div>  
  38.                    ${loginedUser.userName},欢迎您进入Spring login information,您当前积分为${loginedUser.credits};  
  39.               div>  
  40.               <div>  
  41.                 <a href="${basePath}/backendmain.html">后台管理a>  
  42.              div>  
  43.           td>  
  44.            <td style="height:72px;">  
  45.               <div>  
  46.                 <input type=button value="Ajax Exception Test" onclick="ajaxTest();">input>  
  47.              div>  
  48.           td>  
  49.           <td>  
  50.             <div>  
  51.             <a href="${basePath}/logout.html">退出a>  
  52.            div>  
  53.          td>  
  54.       tr>  
  55.     table>  
  56.  body>  
  57. html>  

 验证效果:

 


spring mvc 异常统一处理_第2张图片
 至此,ajax方式起了作用,整个系统的异常统一处理方式做到了统一处理。我们在开发过程中无需关心,异常处理配置了。

转载于:https://my.oschina.net/u/875508/blog/902888

你可能感兴趣的:(测试,json,xhtml)