Jersey框架的统一异常处理

Jersey框架的统一异常处理机制

作者：zheng963

一、背景  

写这边文章源于有朋友问过java中的checked exception和unchecked exception有啥区别，当时我对其的回答是：我编程时仅用RuntimeException。其实，我说句话我是有前提的，确切的应该这么说：在成熟的开发框架下编写业务代码，我只使用或关注RuntimeException。因为，由于框架往往将异常的处理统一封装，这样以便程序员更好的关注业务代码，而业务的一些错误通常是在系统运行期间发生的，因此业务的异常通常被设计为RuntimeException的子类。 

我的回答显然不能让朋友满意！因为，不管是任何一个初学java的都知道，在我们学习IO类和JDBC编程的时候，我们用了大量的try...catch...，这种反复重复的try...catch会让我们对java的异常记忆深刻！初学者往往不清楚java的异常为什么会设计成这个样子，他们通常会对异常只进行简单的处理——在catch块里面简单的把异常打印出来，用的最多的就是这个语句：

Java代码  

1. e.printStackTrace()。  

我们还与一些记忆，比如数组越界这类的异常： 

Java代码  

1. java.lang.ArrayIndexOutOfBoundsException: 6  

这也会使我们记忆犹新，因为在我们调试程序的时候，它经常出现！我们会发现这类异常并不需要在代码里用try...catch...去捕获它。 

上面两个例子，其实就是朋友问到的checked exception和unchecked exception，需要try...catch...的异常是checked exception，不需要的则是unchecked exception。如果要说他们的区别，我说他们一个要try...catch...，一个不需要，这样的回答行吗？我认为这样的回答是苍白的。有同学会进一步说，try...catch很显然，是强制要求抛出异常的方法调用者显式的处理异常，那e.printStackTrace()算不算处理了异常，我认为那只算是一种简单懒惰的处理方式吧！那什么样的处理方式算是高明的，java语言设计者其实是期望发生异常后，调用者能够在catch里将异常恢复回来，使得程序能够继续执行下去。但是，“聪明的程序员都是懒惰的”呵呵，大多数情况下我们选择异常出现后只进行记录日志和UI用户提示，后面我会结合jersey框架，说说其中的统一异常处理。读到这里，有人会说，那checked exception和unchecked exception异常的区别就是，一个需要处理，一个不需要处理。这个回答正确吗？我认为是错误的！我的观点是：无论是checked exception还是unchecked exception，我们都要进行处理！

上一段，我们似乎还是没有解决checked exception和unchecked exception的区别，我认为如何给出答案并不重要，重要的是我们怎么去处理这些异常，以及我们如何在开发时使用异常。 

我的观点是（Web系统开发）：  

1、在框架层面封装checked exception，将其转化为unchecked exception，避免开发过程中编写繁冗的try...catch代码。 

2、业务层面的开发，根据程序代码职责定义不同的RuntimeException(它就是unchecked exception，一般定义为RuntimeException的子类) 

3、通过前两个观点，系统中自定义的异常将只存在unchecked exception，系统只在于客户端交换数据的上层，设置统一异常处理机制，并将一些异常转化为用户所能理解的信息传达给用户。 

4、其他如业务层，数据持久层，等底层只负责将异常抛出即可，但要注意不要丢失掉异常堆栈（这一点是初学者容易犯的一个错误）。 


背景说的够长了！让我们进入正题吧，看看Jersey框架的统一异常处理器是怎样使用的！ 

二、jersey框架的统一异常处理机制  

有如下约定：  

1、示例采用jersey1.x版本 
2、spring版本为2.5 
3、为了简单起见，示例项目不采用Maven机制 

示例的业务场景说明：  

1、我们通过读取一个properties配置文件，配置文件的内容为： 

引用

key1=hello 
key2=iteye.com

2、发起一个http://localhost:8888/a/resources/test?n=11的GET请求，要求n为数字，且必须小于10，如果n错误，将产生一个unchecked exception错误。 

3、本示例中数据访问层将读取一个文件，读取文件错误将会产生checked exception错误。 

示例项目结构设计  



代码片段说明  

1、数据存储文件：test.properties 

Java代码  

1. key1=hello  
2. key2=iteye.com  

这就是我们要读取的文件，为了简单起见，它是一个properties文件。 

2、数据访问类：TestDao.java 

Java代码  

1. package com.iteye.redhacker.jersey.dao;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.net.URL;  
6. import java.util.Properties;  
7.   
8. import org.springframework.stereotype.Component;  
9.   
10. import com.iteye.redhacker.jersey.exception.DaoException;  
11. import com.iteye.redhacker.jersey.exception.ExceptionCode;  
12.   
13. @Component  
14. public class TestDao {  
15.     public String sayHello() {  
16.         ClassLoader classLoader = TestDao.class.getClassLoader();  
17.         String iniFile = "com/iteye/redhacker/jersey/dao/test.properties";  
18.         URL url = classLoader.getResource(iniFile);  
19.         InputStream is;  
20.         try {  
21.             is = url.openStream();  
22.         } catch (IOException e) {  
23.             throw new DaoException(e, ExceptionCode.READ_FILE_FAILED);  
24.         }  
25.         Properties proper = null;  
26.         try {  
27.             if (proper == null) {  
28.                 proper = new Properties();  
29.             }  
30.             proper.load(url.openStream());  
31.         } catch (IOException e) {  
32.             throw new DaoException(e, ExceptionCode.READ_CONFIG_FAILED);  
33.         } finally {  
34.             if (is != null) {  
35.                 try {  
36.                     is.close();  
37.                     is = null;  
38.                 } catch (IOException e) {  
39.                     throw new DaoException(e, ExceptionCode.COLSE_FILE_FAILED);  
40.                 }  
41.             }  
42.         }  
43.         return proper.getProperty("key1") + "," + proper.getProperty("key2");  
44.     }  
45. }  

在该类中，将checked exception全部转化为unchecked exception（我们自定义的exception），调用sayHello()方法时，不再需要try...catch... 

3、业务实现类：TestService.java 

Java代码  

1. package com.iteye.redhacker.jersey.service;  
2.   
3. import org.springframework.beans.factory.annotation.Autowired;  
4. import org.springframework.stereotype.Component;  
5.   
6. import com.iteye.redhacker.jersey.dao.TestDao;  
7. import com.iteye.redhacker.jersey.exception.ExceptionCode;  
8. import com.iteye.redhacker.jersey.exception.ServiceException;  
9.   
10. @Component  
11.   
12. public class TestService {  
13.       
14.     @Autowired  
15.     private TestDao testDao;  
16.       
17.     public String sayHello(int n) {  
18.         // 业务上规定n不能大于10   
19.         if (n > 10) {  
20.             throw new ServiceException(ExceptionCode.MUST_BE_LESS_THAN_10);  
21.         }  
22.         return testDao.sayHello();  
23.     }  
24.   
25.     /** 
26.      * @param testDao the testDao to set 
27.      */  
28.     public void setTestDao(TestDao testDao) {  
29.         this.testDao = testDao;  
30.     }  
31. }  

在该类中，我们抛出了一个自己的业务异常，它是一个unchecked exception。 

注意：我们使用@Autowired注入了TestDao类，@Autowired是Spring提供的一个注解；我们必须提供一个要注解属性的Set方法，否则注解将失败。 

4、请求接入类：TestResources.java 

Java代码  

1. package com.iteye.redhacker.jersey.delegate;  
2.   
3. import javax.ws.rs.GET;  
4. import javax.ws.rs.Path;  
5. import javax.ws.rs.Produces;  
6. import javax.ws.rs.QueryParam;  
7. import javax.ws.rs.core.MediaType;  
8.   
9. import com.iteye.redhacker.jersey.service.TestService;  
10. import com.sun.jersey.api.spring.Autowire;  
11.   
12. @Path("/test")  
13. @Autowire  
14. public class TestResources {  
15.       
16.     private TestService testService;  
17.       
18.     @GET  
19.     @Produces(MediaType.TEXT_PLAIN)  
20.     public String sayHello(@QueryParam("n") int n) {  
21.         return testService.sayHello(n);  
22.     }  
23.   
24.     /** 
25.      * @param testService the testService to set 
26.      */  
27.     public void setTestService(TestService testService) {  
28.         this.testService = testService;  
29.     }  
30.       
31.       
32. }  

这里是jersey定义的一个资源，我们可以这样访问这个资源:发起GET请求，访问URI为/resources/test，可以传递一个查询参数n，例如：/resources/test?n=1 

注意：我们使用了@Autowire并不是Spring的一个注解，它是jersey-srping集成包的一个注解；我们必须提供一个要注解属性的Set方法，否则注解将失败。 

5、统一异常处理器类：ExceptionMapperSupport.java 

Java代码  

1. package com.iteye.redhacker.jersey.jaxrs;  
2.   
3. import javax.servlet.ServletContext;  
4. import javax.servlet.http.HttpServletRequest;  
5. import javax.ws.rs.core.Context;  
6. import javax.ws.rs.core.MediaType;  
7. import javax.ws.rs.core.Response;  
8. import javax.ws.rs.core.Response.Status;  
9. import javax.ws.rs.ext.ExceptionMapper;  
10. import javax.ws.rs.ext.Provider;  
11.   
12. import org.apache.log4j.Logger;  
13. import org.springframework.web.context.WebApplicationContext;  
14.   
15. import com.iteye.redhacker.jersey.exception.BaseException;  
16. import com.iteye.redhacker.jersey.exception.ExceptionCode;  
17. import com.sun.jersey.api.NotFoundException;  
18.   
19. /** 
20.  * 统一异常处理器 
21.  */  
22. @Provider  
23. public class ExceptionMapperSupport implements ExceptionMapper<Exception> {  
24.     private static final Logger LOGGER = Logger  
25.             .getLogger(ExceptionMapperSupport.class);  
26.   
27.     private static final String CONTEXT_ATTRIBUTE = WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE;  
28.   
29.     @Context  
30.     private HttpServletRequest request;  
31.   
32.     @Context  
33.     private ServletContext servletContext;  
34.   
35.     /** 
36.      * 异常处理 
37.      *  
38.      * @param exception 
39.      * @return 异常处理后的Response对象 
40.      */  
41.     public Response toResponse(Exception exception) {  
42.         String message = ExceptionCode.INTERNAL_SERVER_ERROR;  
43.         Status statusCode = Status.INTERNAL_SERVER_ERROR;  
44.         WebApplicationContext context = (WebApplicationContext) servletContext  
45.                 .getAttribute(CONTEXT_ATTRIBUTE);  
46.         // 处理unchecked exception  
47.         if (exception instanceof BaseException) {  
48.             BaseException baseException = (BaseException) exception;  
49.             String code = baseException.getCode();  
50.             Object[] args = baseException.getValues();  
51.             message = context.getMessage(code, args, exception.getMessage(),  
52.                     request.getLocale());  
53.   
54.         } else if (exception instanceof NotFoundException) {  
55.             message = ExceptionCode.REQUEST_NOT_FOUND;  
56.             statusCode = Status.NOT_FOUND;  
57.         }   
58.         // checked exception和unchecked exception均被记录在日志里  
59.         LOGGER.error(message, exception);  
60.         return Response.ok(message, MediaType.TEXT_PLAIN).status(statusCode)  
61.                 .build();  
62.     }  
63. }  

在这个类里面我们处理了我们定义的unchecked exception异常，还处理了系统未知的exception(包括未知的unchecked exception和checked exception)。我们的处理方式是：a、记录异常日志；b、向客户端抛一个标准的http标准错误状态码和错误消息，由客户端对错误信息进行自行处理，值得说明的是，这种处理方式是REST所提倡的，它恰当的使用了HTTP标准状态码； 

在这个类中我们还使用了spring的国际化配置组件，用于对系统抛出的错误key进行国际化转换，这有利于我们的项目国际化升级。 

6、自定义异常基类：BaseException.java 

Java代码  

1. package com.iteye.redhacker.jersey.exception;  
2.   
3. /** 
4.  * 异常基类，各个模块的运行期异常均继承与该类 
5.  */  
6. public class BaseException extends RuntimeException {  
7.   
8.     /** 
9.      * the serialVersionUID 
10.      */  
11.     private static final long serialVersionUID = 1381325479896057076L;  
12.   
13.     /** 
14.      * message key 
15.      */  
16.     private String code;  
17.   
18.     /** 
19.      * message params 
20.      */  
21.     private Object[] values;  
22.   
23.     /** 
24.      * @return the code 
25.      */  
26.     public String getCode() {  
27.         return code;  
28.     }  
29.   
30.     /** 
31.      * @param code the code to set 
32.      */  
33.     public void setCode(String code) {  
34.         this.code = code;  
35.     }  
36.   
37.     /** 
38.      * @return the values 
39.      */  
40.     public Object[] getValues() {  
41.         return values;  
42.     }  
43.   
44.     /** 
45.      * @param values the values to set 
46.      */  
47.     public void setValues(Object[] values) {  
48.         this.values = values;  
49.     }  
50.   
51.     public BaseException(String message, Throwable cause, String code, Object[] values) {  
52.         super(message, cause);  
53.         this.code = code;  
54.         this.values = values;  
55.     }  
56. }  

这个类定义了项目异常类的基本模板，其他异常继承与它。值得注意的是，它巧妙的利用了国际化配置的一些特征，甚至可以抛出下面这样定义的一个错误消息，通过传递参数的方式，复用错误信息： 

Java代码  

1. 第{0}个{1}参数错误  

7、其他异常基本差不多，只是类型不同，我们看一下DaoException.java 

Java代码  

1. package com.iteye.redhacker.jersey.exception;  
2.   
3. public class DaoException extends BaseException {  
4.   
5.     /** 
6.      * Constructors 
7.      *  
8.      * @param code 
9.      *            错误代码 
10.      */  
11.     public DaoException(String code) {  
12.         super(code, null, code, null);  
13.     }  
14.   
15.     /** 
16.      * Constructors 
17.      *  
18.      * @param cause 
19.      *            异常接口 
20.      * @param code 
21.      *            错误代码 
22.      */  
23.     public DaoException(Throwable cause, String code) {  
24.         super(code, cause, code, null);  
25.     }  
26.   
27.     /** 
28.      * Constructors 
29.      *  
30.      * @param code 
31.      *            错误代码 
32.      * @param values 
33.      *            一组异常信息待定参数 
34.      */  
35.     public DaoException(String code, Object[] values) {  
36.         super(code, null, code, values);  
37.     }  
38.   
39.     /** 
40.      * Constructors 
41.      *  
42.      * @param cause 
43.      *            异常接口 
44.      * @param code 
45.      *            错误代码 
46.      * @param values 
47.      *            一组异常信息待定参数 
48.      */  
49.     public DaoException(Throwable cause, String code, Object[] values) {  
50.         super(code, null, code, values);  
51.     }  
52.   
53.     private static final long serialVersionUID = -3711290613973933714L;  
54.   
55. }  

它继承了BaseException，当抛出这个异常时，我们就从异常名字上直接初步判断出，错误出自Dao层。 

8、errMsg.properties用于定义异常信息，来看一下： 

Java代码  

1. read.file.failed=读取文件失败  
2. read.config.failed=读取配置项失败  
3. must.be.less.than.10=参数必须小于10  
4. colse.file.failed=关闭文件失败  
5. request.not.found=没有找到相应的服务  
6. internal.server.error=服务器内部错误  

三、部署及测试  

你可以在本文附件里下载到源码。导入eclipse后，查看源码。 

部署很简单，只要将你的tomcat/config/server.xml里加入： 

Java代码  

1. <Host>  
2. ...  
3. <Context path="/a"  reloadable="true" docBase="D:/workspace/test/JerseyExceptionMapperTest/web"  />  
4.   
5. </Host>  

启动tomcat就可以了！ 

做两个测试： 
1、 
 
2、 
 

第1个测试，还可以在log中看到如下异常错误： 

Java代码  

1. [2013-08-15 00:25:55] [ERROR] 参数必须小于10  
2. com.iteye.redhacker.jersey.exception.ServiceException: must.be.less.than.10  
3.     at com.iteye.redhacker.jersey.service.TestService.sayHello(TestService.java:20)  
4.     at com.iteye.redhacker.jersey.delegate.TestResources.sayHello(TestResources.java:21)  
5.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)  
6.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)  
7.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)  
8.     at java.lang.reflect.Method.invoke(Method.java:597)  
9.     at com.sun.jersey.spi.container.JavaMethodInvokerFactory$1.invoke(JavaMethodInvokerFactory.java:60)  
10.     at com.sun.jersey.server.impl.model.method.dispatch.AbstractResourceMethodDispatchProvider$TypeOutInvoker._dispatch(AbstractResourceMethodDispatchProvider.java:185)  
11.     at com.sun.jersey.server.impl.model.method.dispatch.ResourceJavaMethodDispatcher.dispatch(ResourceJavaMethodDispatcher.java:75)  
12.     at com.sun.jersey.server.impl.uri.rules.HttpMethodRule.accept(HttpMethodRule.java:288)  
13.     at com.sun.jersey.server.impl.uri.rules.ResourceClassRule.accept(ResourceClassRule.java:108)  
14.     at com.sun.jersey.server.impl.uri.rules.RightHandPathRule.accept(RightHandPathRule.java:147)  
15.     at com.sun.jersey.server.impl.uri.rules.RootResourceClassesRule.accept(RootResourceClassesRule.java:84)  
16.     at com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1483)  
17.     at com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1414)  
18.     at com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1363)  
19.     at com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1353)  

关于其他的一些测试，大家可以去尝试一下，比如故意把test.properties删除，当找不到要读取的文件时，checked exception是如何转化为我们自己定义个unchecked exception，并记录下了日志，返回给客户端标准的http错误状态码和错误信息。 

四、总结  

1、通过jersey框架我们不难看出，在web项目开发来讲，对于checked exception和unchecked exception的处理我们尽可能在框架层面就进行了统一处理，以便我们更加关注与业务的实现。 

2、如果是非web项目，我想，程序架构设计者也应当尽量统一的处理异常；如果不做统一处理，当遇到checked exception，我们应当对其进行恰当的异常处理，而不是不是简单的做一个e.printStackTrace()的处理；如果我们不能恢复异常，那我们至少要将异常的错误信息完整的记录到日志文件中去，以便后续的程序出现故障时进行错误排查。