在Spring基础上实现自己的异常处理框架

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

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

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

完整的异常组织结构：

用户可以方便的定义自己的异常，但所有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的工厂

package com.ldd600.exception.context;
2

public class CoreContextFactory {
4

private static CoreContextFactory instance;
5

private volatile ExceptionContext exceptionContext;
7

private Object exceptionContextLock = new Object();
9

private CoreContextFactory() {
11

}
13

public static synchronized CoreContextFactory getInstance() {
15

if (null == instance) {
16

instance = new CoreContextFactory();
17

}
18

return instance;
19

}
20

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

}
33

ExceptionContext: 存放全局的exception信息

package com.ldd600.exception.context;
2

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

import org.springframework.util.Assert;
12

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

public class ExceptionContext {
19

private Map<Class<?>, ExceptionDefinition> exceptionMap;
20

private Map<String, ExceptionHandler> handlers = new HashMap<String, ExceptionHandler>();
22

ExceptionContext() {
24

exceptionMap = new HashMap<Class<?>, ExceptionDefinition>();
25

}
26

public boolean containsException(Class<?> expClazz) {
28

return (exceptionMap.containsKey(expClazz));
29

}
30

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

definition.getHandlerNames().add(handlerClazz.getName());
44

} catch (Exception ex) {
45

throw new ConfigException("Add exception handler to context failure!", ex);
46

}
47

}
48

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

public void addExceptionHandlers(Class<?> expClazz, Class<? extends ExceptionHandler>

handlerClazzes) {
62

for(Class<? extends ExceptionHandler> handlerClazz : handlerClazzes) {
63

addExceptionHander(expClazz, handlerClazz);
64

}
65

}
66

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

if (isClearHandler) {
81

handlers.remove(handlers.get(handlerName));
82

}
83

}
84

public void setExceptionDefinition(Class<?> expClazz, ExceptionDefinition definition) {
86

exceptionMap.put(expClazz, definition);
87

}
88

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

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

}
130

ExceptionDefinition: Exception信息单元

package com.ldd600.exception.config;
2

import java.util.LinkedHashSet;
4

import java.util.Set;
5

public class ExceptionDefinition {
7

private String errorCode;
8

private Set<String> handlerNames = new LinkedHashSet<String> ();
10

ExceptionDefinition() {
12

}
14

public ExceptionDefinition(String errorCode) {
16

this.errorCode = errorCode;
17

}
18

public String getErrorCode() {
20

return errorCode;
21

}
22

public void setErrorCode(String errorCode) {
24

this.errorCode = errorCode;
25

}
26

public Set<String> getHandlerNames() {
28

return handlerNames;
29

}
30

}
31

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:

< xsd:complexType name ="exceptionType" >

< xsd:sequence >

< xsd:element name ="level" default ="error" minOccurs ="0" >

< xsd:simpleType >

< xsd:restriction base ="xsd:string" >

< xsd:enumeration value ="error" />

< xsd:enumeration value ="warning" />

< xsd:enumeration value ="info" />

< xsd:enumeration value ="confirmation" />

</ xsd:restriction >

</ xsd:simpleType >

</ xsd:element >

< xsd:element name ="handler" maxOccurs ="unbounded" >

< xsd:simpleType >

< xsd:restriction base ="xsd:string" />

</ xsd:simpleType >

</ xsd:element >

</ xsd:sequence >

< xsd:attribute name ="errorCode" >

< xsd:simpleType >

< xsd:restriction base ="xsd:string" >

< xsd:whiteSpace value ="preserve" />

< xsd:pattern value ="LDD600-+"d{1,5}.*" />

</ xsd:restriction >

</ xsd:simpleType >

</ xsd:attribute >

< xsd:attribute name ="class" type ="xsd:string" use ="required" />

</ xsd:complexType >

Annotation方案：

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

package com.ldd600.exception.annotation;
2

import java.lang.annotation.Documented;
4

import java.lang.annotation.ElementType;
5

import java.lang.annotation.Retention;
6

import java.lang.annotation.RetentionPolicy;
7

import java.lang.annotation.Target;
8

import com.ldd600.exception.base.handler.ExceptionHandler;
10

@Target( {ElementType.TYPE} )
12

@Retention(RetentionPolicy.RUNTIME)
13

@Documented
14

public @ interface Exceptional {
15

String errorCode();
16

Class<? extends ExceptionHandler>[] handlers();
17

}
18

package com.ldd600.exception.processor;
2

import org.springframework.beans.BeansException;
4

import org.springframework.beans.factory.config.BeanPostProcessor;
5

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

public class ExceptionalAnnotationBeanPostProcessor implements BeanPostProcessor {
14

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

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
32

return bean;
33

}
34

}
36

结果测试：

package com.ldd600.exception.test;
2

import org.jmock.Expectations;
4

import org.jmock.Mockery;
5

import org.springframework.beans.factory.BeanFactory;
6

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

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

@Override
26

protected String[] getConfigLocations() {
27

return new String[] { "applicationContext.xml" };
28

}
29

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

}, BaseAppException.class);
50

}
51

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

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

}, 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

}
132

参考资料：

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

文章2：http://sannotations.sourceforge.net/

本文源代码：源代码下载

在Spring基础上实现自己的异常处理框架

你可能感兴趣的:(在Spring基础上实现自己的异常处理框架)