在pring基础上实现自定义异常处理框架教程

代码下载地址：http://www.zuidaima.com/share/1774096228535296.htm

应用项目大致的体系结构：

    
 

 该异常处理框架满足的要求：

 

• 完整的异常组织结构
• 异常的统一处理
• 可配置，受管式，方便使用

 

完整的异常组织结构：

• 用户可以方便的定义自己的异常，但所有UncheckedException需要继承BaseAppRuntimeException，所有的checked Exception可以继承BaseAppException，或者需要抛出且不需要check时用WrapperredAppException封装后抛出
• 合理地使用checked异常
• Exception有唯一的error code，这样用户报告异常后，可以根据异常号找到相应Exception，把exception直接显示给用户也没有太大的意义，如何纪录exception那就是下文讲到的ExceptionHandler的职责了。
• 如果是第三方包括jdk中的异常，需要封装成BaseAppException或者BaseAppRuntimeException后抛出

                                      

   

 

统一的异常处理

异常统一在框架中进行处理，不需要在上层应用的代码中去处理抛出的异常。为了尽量捕捉到所有的异常，将异常处理放在了ActionBroker中，这样凡是action以后抛出的异常都可以捕捉到，因为webservice只是简单的调用action类的方法，一般不会出现异常。当我们捕捉到异常后，需要进行异常处理，定义了ExceptionHandler接口，用接口抽象出异常处理类的具体实现。

 

                         

USFContextFactory: 创建ExceptionContext的工厂

[java]  view plain  copy

 print ?

1. package com.ldd0.exception.context;  
2.   
3. public class CoreContextFactory {  
4.     private static CoreContextFactory instance;  
5.   
6.     private volatile ExceptionContext exceptionContext;  
7.   
8.     private Object exceptionContextLock = new Object();  
9.   
10.     private CoreContextFactory() {  
11.   
12.     }  
13.   
14.     public static synchronized CoreContextFactory getInstance() {  
15.         if (null == instance) {  
16.             instance = new CoreContextFactory();  
17.         }  
18.         return instance;  
19.     }  
20.   
21.     public ExceptionContext getExceptionContext() {  
22.         ExceptionContext tempExpContext = exceptionContext;  
23.         if (tempExpContext == null) {   
24.             synchronized (exceptionContextLock) {  
25.                 tempExpContext = exceptionContext;  
26.                 if (tempExpContext == null)  
27.                     exceptionContext = tempExpContext = new ExceptionContext();  
28.             }  
29.         }  
30.         return tempExpContext;  
31.     }  
32. }  

ExceptionContext: 存放全局的exception信息

[java]  view plain  copy

 print ?

1. package com.ldd600.exception.context;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Collection;  
5. import java.util.Collections;  
6. import java.util.HashMap;  
7. import java.util.List;  
8. import java.util.Map;  
9. import java.util.Set;  
10.   
11. import org.springframework.util.Assert;  
12.   
13. import com.ldd600.exception.base.BaseAppRuntimeException;  
14. import com.ldd600.exception.base.ConfigException;  
15. import com.ldd600.exception.base.handler.ExceptionHandler;  
16. import com.ldd600.exception.config.ExceptionDefinition;  
17.   
18. public class ExceptionContext {  
19.     private Map<Class<?>, ExceptionDefinition> exceptionMap;  
20.   
21.     private Map<String, ExceptionHandler> handlers = new HashMap<String, ExceptionHandler>();  
22.   
23.     ExceptionContext() {  
24.         exceptionMap = new HashMap<Class<?>, ExceptionDefinition>();  
25.     }  
26.   
27.     public boolean containsException(Class<?> expClazz) {  
28.         return (exceptionMap.containsKey(expClazz));  
29.     }  
30.       
31.     public void addExceptionHander(Class<?> expClazz, Class<? extends ExceptionHandler> handlerClazz) {  
32.         try {  
33.             ExceptionDefinition definition = getRealExceptionDefinition(expClazz);  
34.             if (null == definition) {  
35.                 throw new IllegalArgumentException(expClazz.getName() + "not in the context, please configure or add it to the context first!!");  
36.             }   
37.             ExceptionHandler handler = handlers.get(handlerClazz.getName());  
38.             if (null == handler) {  
39.                 handler = handlerClazz.newInstance();  
40.                 handlers.put(handlerClazz.getName(), handler);  
41.             }  
42.               
43.             definition.getHandlerNames().add(handlerClazz.getName());  
44.         } catch (Exception ex) {  
45.             throw new ConfigException("Add exception handler to context failure!", ex);  
46.         }  
47.     }  
48.       
49.     public void addExceptionHandler(Class<?> expClazz, String errorCode, Class<? extends ExceptionHandler> handlerClazz) {  
50.         Assert.hasLength(errorCode, expClazz + " errorCode must not be null or empty string!");  
51.         ExceptionDefinition definition = getRealExceptionDefinition(expClazz);  
52.         if(null == definition) {  
53.             definition = new ExceptionDefinition(errorCode);  
54.             exceptionMap.put(expClazz, definition);  
55.         }  
56.         addExceptionHander(expClazz, handlerClazz);  
57.     }  
58.       
59.       
60.       
61.     public void addExceptionHandlers(Class<?> expClazz, Class<? extends ExceptionHandler> handlerClazzes) {  
62.         for(Class<? extends ExceptionHandler> handlerClazz : handlerClazzes) {  
63.             addExceptionHander(expClazz, handlerClazz);  
64.         }  
65.     }  
66.   
67.     public void removeExceptionHandler(Class<?> expClazz, Class<? extends ExceptionHandler> handlerClazz) {  
68.         Assert.isTrue(containsException(expClazz));  
69.         String handlerName = handlerClazz.getName();  
70.         getExceptionDefinition(expClazz).getHandlerNames().remove(handlerName);  
71.         Collection<ExceptionDefinition> definitons = exceptionMap.values();  
72.         boolean isClearHandler = true;  
73.         for (ExceptionDefinition expDefinition : definitons) {  
74.             if (expDefinition.getHandlerNames().contains(handlerName)) {  
75.                 isClearHandler = false;  
76.                 break;  
77.             }  
78.         }  
79.   
80.         if (isClearHandler) {  
81.             handlers.remove(handlers.get(handlerName));  
82.         }  
83.     }  
84.   
85.     public void setExceptionDefinition(Class<?> expClazz, ExceptionDefinition definition) {  
86.         exceptionMap.put(expClazz, definition);  
87.     }  
88.   
89.     public ExceptionDefinition getExceptionDefinition(Class<?> expClazz) {  
90.         if (containsException(expClazz)) {  
91.             return exceptionMap.get(expClazz);    
92.         } else if (BaseAppRuntimeException.class.isAssignableFrom(expClazz.getSuperclass())) {  
93.             return getExceptionDefinition(expClazz.getSuperclass());  
94.         } else {  
95.             return null;  
96.         }  
97.     }  
98.       
99.     public ExceptionDefinition getRealExceptionDefinition(Class<?> expClazz) {  
100.         return exceptionMap.get(expClazz);  
101.     }  
102.   
103.     public List<ExceptionHandler> getExceptionHandlers(Class<?> expClazz){  
104.         ExceptionDefinition definition = getExceptionDefinition(expClazz);  
105.         if (null != definition) {  
106.             Set<String> handlerNames = definition.getHandlerNames();  
107.             List<ExceptionHandler> handlerList = new ArrayList<ExceptionHandler>(handlerNames.size());  
108.             for (String handlerName : handlerNames) {  
109.                 ExceptionHandler handler = handlers.get(handlerName);  
110.                 handlerList.add(handler);  
111.             }  
112.             List<ExceptionHandler> resultHandlerList = new ArrayList<ExceptionHandler>(handlerList);  
113.             return resultHandlerList;  
114.         } else {  
115.             return Collections.<ExceptionHandler> emptyList();  
116.         }  
117.     }  
118.       
119.     public String getErrorCode(Class<?> expClazz){  
120.         ExceptionDefinition definition = getExceptionDefinition(expClazz);  
121.         if (null != definition) {  
122.             return definition.getErrorCode();  
123.         } else {  
124.             return "";  
125.         }  
126.     }  
127.       
128.       
129. }  

 

ExceptionDefinition: Exception信息单元

 

[java]  view plain  copy

 print ?

1. package com.ldd0.exception.config;  
2.   
3. import java.util.LinkedHashSet;  
4. import java.util.Set;  
5.   
6. public class ExceptionDefinition {  
7.     private String errorCode;  
8.   
9.     private Set<String> handlerNames = new LinkedHashSet<String> ();  
10.   
11.     ExceptionDefinition() {  
12.           
13.     }  
14.       
15.     public ExceptionDefinition(String errorCode) {  
16.         this.errorCode = errorCode;  
17.     }  
18.       
19.     public String getErrorCode() {  
20.         return errorCode;  
21.     }  
22.   
23.     public void setErrorCode(String errorCode) {  
24.         this.errorCode = errorCode;  
25.     }  
26.   
27.     public Set<String> getHandlerNames() {  
28.         return handlerNames;  
29.     }  
30. }  

 

ExceptionDefiniton定义了和某个exception相关的具体信息，根据exception的class name可以从exceptionContext中的exceptionMap得到指定的exception的相关信息，这些信息是在系统初始化时读取到exceptionContext中的。并且避免了exception handler的重复初始化。

 

可配置，受管式，方便使用

 采取两种配置方式，exception的相关信息比如它的errorCode， exceptionHandlers可以配置在外部的xml文件中，也可以用annotation标注。对于exception的处理是有继承性质的，如果某个exception没有在exceptionContext中注册，就使用它的父类的配置信息。如果无任何父类在exceptionContext中注册，就使用默认机制进行处理。

 

XML 方案：

            因为spring2.0支持自定义schema功能，我们可以方便地采用自己的schema只要实现NamespaceHandler和BeanDefinitionPaser，后面一个比较重要，可以将自定义xml文件中的相关类注册到spring的上下文中，成为spring bean。

Xml schema:

[xml]  view plain  copy

 print ?

1. <xsd:complexType name="exceptionType">  
2.         <xsd:sequence>  
3.             <xsd:element name="level" default="error" minOccurs="0">  
4.                 <xsd:simpleType>  
5.                     <xsd:restriction base="xsd:string">  
6.                         <xsd:enumeration value="error" />  
7.                         <xsd:enumeration value="warning" />  
8.                         <xsd:enumeration value="info" />  
9.                         <xsd:enumeration value="confirmation" />  
10.                     </xsd:restriction>  
11.                 </xsd:simpleType>  
12.             </xsd:element>  
13.             <xsd:element name="handler" maxOccurs="unbounded">  
14.                 <xsd:simpleType>  
15.                     <xsd:restriction base="xsd:string" />  
16.                 </xsd:simpleType>  
17.             </xsd:element>  
18.         </xsd:sequence>  
19.         <xsd:attribute name="errorCode">  
20.             <xsd:simpleType>  
21.                 <xsd:restriction base="xsd:string">  
22.                     <xsd:whiteSpace value="preserve" />  
23.                     <xsd:pattern value="LDD600-+\d{1,5}.*" />  
24.                 </xsd:restriction>  
25.             </xsd:simpleType>  
26.         </xsd:attribute>  
27.         <xsd:attribute name="class" type="xsd:string" use="required" />  
28.     </xsd:complexType>  

 

Annotation方案：

            JDK1.5以上就有了annotation，可以简化我们的配置，使得配置信息和代码联系在一起，增加了代码的可读性。如何在spring中注册自定义的annotation和用annotation标注的class，可以参考文章2和文章：   。对于每个注册了的class用ExceptionalAnnotationBeanPostProcessor来parse具体的annotation信息（对于annotation的parse方法还会在以后继续改进）。

[java]  view plain  copy

 print ?

1. package com.ldd600.exception.processor;  
2.   
3. import org.springframework.beans.BeansException;  
4. import org.springframework.beans.factory.config.BeanPostProcessor;  
5.   
6. import com.ldd600.exception.annotation.Exceptional;  
7. import com.ldd600.exception.base.BaseAppException;  
8. import com.ldd600.exception.base.BaseAppRuntimeException;  
9. import com.ldd600.exception.config.ExceptionDefinition;  
10. import com.ldd600.exception.context.ExceptionContext;  
11. import com.ldd600.exception.context.CoreContextFactory;  
12.   
13. public class ExceptionalAnnotationBeanPostProcessor implements BeanPostProcessor {  
14.   
15.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
16.        if(bean instanceof BaseAppRuntimeException || bean instanceof BaseAppException) {  
17.            Exceptional exceptional = bean.getClass().getAnnotation(Exceptional.class);  
18.            if(null != exceptional) {  
19.                ExceptionContext ctx = CoreContextFactory.getInstance().getExceptionContext();  
20.                if(!ctx.containsException(bean.getClass())) {  
21.                    ExceptionDefinition expDefinition = new ExceptionDefinition(exceptional.errorCode());  
22.                    ctx.setExceptionDefinition(bean.getClass(), expDefinition);  
23.                }  
24.                ctx.addExceptionHandlers(bean.getClass(), exceptional.handlers());  
25.                return null;  
26.            }  
27.        }  
28.        return bean;  
29.     }  
30.   
31.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
32.             return bean;  
33.     }  
34.   
35. }  

 

结果测试：

[java]  view plain  copy

 print ?

1. package com.ldd600.exception.test;  
2.   
3. import org.jmock.Expectations;  
4. import org.jmock.Mockery;  
5. import org.springframework.beans.factory.BeanFactory;  
6.   
7. import com.ldd600.exception.action.BusinessAction;  
8. import com.ldd600.exception.base.BaseAppException;  
9. import com.ldd600.exception.base.BaseAppRuntimeException;  
10. import com.ldd600.exception.base.ConfigException;  
11. import com.ldd600.exception.base.handler.ConsoleHandler;  
12. import com.ldd600.exception.context.CoreContextFactory;  
13. import com.ldd600.exception.dto.DefaultRequest;  
14. import com.ldd600.exception.dto.DefaultResponse;  
15. import com.ldd600.exception.dto.Request;  
16. import com.ldd600.exception.dto.Response;  
17. import com.ldd600.exception.webservice.ActionBrokerImpl;  
18.   
19. public class ExceptionTest extends DependencyInjectionExceptionTestCase {  
20.     Mockery context = new Mockery();  
21.     ActionBrokerImpl broker = new ActionBrokerImpl();  
22.     final Request request = new DefaultRequest();  
23.     final Response response = new DefaultResponse();  
24.   
25.     @Override  
26.     protected String[] getConfigLocations() {  
27.         return new String[] { "applicationContext.xml" };  
28.     }  
29.   
30.     public void testExceptionThrow() {  
31.         final BusinessAction<Response, Request> action = context  
32.                 .mock(BusinessAction.class);  
33.         final BeanFactory beanFactory = context.mock(BeanFactory.class);  
34.         assertThrowing(new Closure() {  
35.             public void run() throws Throwable {  
36.                 context.checking(new Expectations() {  
37.                     {  
38.                         allowing(beanFactory).getBean("action");  
39.                         will(returnValue(action));  
40.                         one(action).execute(request, response);  
41.                         will(throwException(new BaseAppException()));  
42.                     }  
43.                 });  
44.                 broker.setExceptionHandler(new ConsoleHandler());  
45.                 broker.setBeanFactory(beanFactory);  
46.                 broker.execute("action", request, response);  
47.             }  
48.   
49.         }, BaseAppException.class);  
50.     }  
51.   
52.     public void testExceptionalAutoLoad() throws BaseAppException {  
53.         final BeanFactory beanFactory = context.mock(BeanFactory.class);  
54.         final BusinessAction<Response, Request> action = context  
55.                 .mock(BusinessAction.class);  
56.         context.checking(new Expectations() {  
57.             {  
58.                 allowing(beanFactory).getBean("action");  
59.                 will(returnValue(action));  
60.                 one(action).execute(request, response);  
61.                 will(throwException(new ConfigException()));  
62.             }  
63.         });  
64.         broker.setBeanFactory(beanFactory);  
65.         broker.execute("action", request, response);  
66.         assertEquals(CoreContextFactory.getInstance().getExceptionContext()  
67.                 .getErrorCode(ConfigException.class), "LDD600-00002");  
68.         context.assertIsSatisfied();  
69.     }  
70.   
71.     public void testRuntimeException() {  
72.         final BusinessAction<Response, Request> action = context  
73.                 .mock(BusinessAction.class);  
74.         final BeanFactory beanFactory = context.mock(BeanFactory.class);  
75.         assertThrowing(new Closure() {  
76.             public void run() throws Throwable {  
77.                 context.checking(new Expectations() {  
78.                     {  
79.                         allowing(beanFactory).getBean("action");  
80.                         will(returnValue(action));  
81.                         one(action).execute(request, response);  
82.                         will(throwException(new BaseAppRuntimeException()));  
83.                     }  
84.                 });  
85.                 broker.setExceptionHandler(new ConsoleHandler());  
86.                 broker.setBeanFactory(beanFactory);  
87.                 broker.execute("action", request, response);  
88.             }  
89.   
90.         }, BaseAppRuntimeException.class);  
91.         // test config  
92.         assertEquals(CoreContextFactory.getInstance().getExceptionContext()  
93.                 .getErrorCode(BaseAppRuntimeException.class), "LDD600-00001");  
94.         // test handler  
95.         assertFalse(response.isSuccess());  
96.         assertEquals(response.getErrorCode(), CoreContextFactory.getInstance()  
97.                 .getExceptionContext().getErrorCode(  
98.                         BaseAppRuntimeException.class));  
99.         context.assertIsSatisfied();  
100.     }  
101.   
102.     public void testCheckedException() {  
103.         final BusinessAction<Response, Request> action = context  
104.                 .mock(BusinessAction.class);  
105.         final BeanFactory beanFactory = context.mock(BeanFactory.class);  
106.         assertThrowing(new Closure() {  
107.             public void run() throws Throwable {  
108.                 context.checking(new Expectations() {  
109.                     {  
110.                         allowing(beanFactory).getBean("action");  
111.                         will(returnValue(action));  
112.                         one(action).execute(request, response);  
113.                         will(throwException(new ExceptionFaker()));  
114.                     }  
115.                 });  
116.                 broker.setBeanFactory(beanFactory);  
117.                 broker.execute("action", request, response);  
118.             }  
119.   
120.         }, ExceptionFaker.class);  
121.         // test config  
122.         assertEquals(CoreContextFactory.getInstance().getExceptionContext()  
123.                 .getErrorCode(ExceptionFaker.class), "LDD600-00003");  
124.         // test handler  
125.         assertFalse(response.isSuccess());  
126.         assertEquals(response.getErrorCode(), CoreContextFactory.getInstance()  
127.                 .getExceptionContext().getErrorCode(  
128.                         ExceptionFaker.class));  
129.         context.assertIsSatisfied();  
130.     }  
131. }  

参考资料：

文章1：http://www.onjava.com/pub/a/onjava/2006/01/11/exception-handling-framework-for-j2ee.html

文章2：http://sannotations.sourceforge.net/
本文源代码：源代码下载

来源:http://blog.csdn.net/yaerfeng/article/details/25100239