原创整理不易,转载请注明出处:在java Spring基础上实现自定义异常处理框架教程
代码下载地址: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的工厂
package com.ldd0.exception.context; public class CoreContextFactory { private static CoreContextFactory instance; private volatile ExceptionContext exceptionContext; private Object exceptionContextLock = new Object(); private CoreContextFactory() { } public static synchronized CoreContextFactory getInstance() { if (null == instance) { instance = new CoreContextFactory(); } return instance; } public ExceptionContext getExceptionContext() { ExceptionContext tempExpContext = exceptionContext; if (tempExpContext == null) { synchronized (exceptionContextLock) { tempExpContext = exceptionContext; if (tempExpContext == null) exceptionContext = tempExpContext = new ExceptionContext(); } } return tempExpContext; } }
ExceptionContext: 存放全局的exception信息
package com.ldd600.exception.context; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import org.springframework.util.Assert; import com.ldd600.exception.base.BaseAppRuntimeException; import com.ldd600.exception.base.ConfigException; import com.ldd600.exception.base.handler.ExceptionHandler; import com.ldd600.exception.config.ExceptionDefinition; public class ExceptionContext { private Map<Class<?>, ExceptionDefinition> exceptionMap; private Map<String, ExceptionHandler> handlers = new HashMap<String, ExceptionHandler>(); ExceptionContext() { exceptionMap = new HashMap<Class<?>, ExceptionDefinition>(); } public boolean containsException(Class<?> expClazz) { return (exceptionMap.containsKey(expClazz)); } public void addExceptionHander(Class<?> expClazz, Class<? extends ExceptionHandler> handlerClazz) { try { ExceptionDefinition definition = getRealExceptionDefinition(expClazz); if (null == definition) { throw new IllegalArgumentException(expClazz.getName() + "not in the context, please configure or add it to the context first!!"); } ExceptionHandler handler = handlers.get(handlerClazz.getName()); if (null == handler) { handler = handlerClazz.newInstance(); handlers.put(handlerClazz.getName(), handler); } definition.getHandlerNames().add(handlerClazz.getName()); } catch (Exception ex) { throw new ConfigException("Add exception handler to context failure!", ex); } } public void addExceptionHandler(Class<?> expClazz, String errorCode, Class<? extends ExceptionHandler> handlerClazz) { Assert.hasLength(errorCode, expClazz + " errorCode must not be null or empty string!"); ExceptionDefinition definition = getRealExceptionDefinition(expClazz); if(null == definition) { definition = new ExceptionDefinition(errorCode); exceptionMap.put(expClazz, definition); } addExceptionHander(expClazz, handlerClazz); } public void addExceptionHandlers(Class<?> expClazz, Class<? extends ExceptionHandler> handlerClazzes) { for(Class<? extends ExceptionHandler> handlerClazz : handlerClazzes) { addExceptionHander(expClazz, handlerClazz); } } public void removeExceptionHandler(Class<?> expClazz, Class<? extends ExceptionHandler> handlerClazz) { Assert.isTrue(containsException(expClazz)); String handlerName = handlerClazz.getName(); getExceptionDefinition(expClazz).getHandlerNames().remove(handlerName); Collection<ExceptionDefinition> definitons = exceptionMap.values(); boolean isClearHandler = true; for (ExceptionDefinition expDefinition : definitons) { if (expDefinition.getHandlerNames().contains(handlerName)) { isClearHandler = false; break; } } if (isClearHandler) { handlers.remove(handlers.get(handlerName)); } } public void setExceptionDefinition(Class<?> expClazz, ExceptionDefinition definition) { exceptionMap.put(expClazz, definition); } public ExceptionDefinition getExceptionDefinition(Class<?> expClazz) { if (containsException(expClazz)) { return exceptionMap.get(expClazz); } else if (BaseAppRuntimeException.class.isAssignableFrom(expClazz.getSuperclass())) { return getExceptionDefinition(expClazz.getSuperclass()); } else { return null; } } public ExceptionDefinition getRealExceptionDefinition(Class<?> expClazz) { return exceptionMap.get(expClazz); } public List<ExceptionHandler> getExceptionHandlers(Class<?> expClazz){ ExceptionDefinition definition = getExceptionDefinition(expClazz); if (null != definition) { Set<String> handlerNames = definition.getHandlerNames(); List<ExceptionHandler> handlerList = new ArrayList<ExceptionHandler>(handlerNames.size()); for (String handlerName : handlerNames) { ExceptionHandler handler = handlers.get(handlerName); handlerList.add(handler); } List<ExceptionHandler> resultHandlerList = new ArrayList<ExceptionHandler>(handlerList); return resultHandlerList; } else { return Collections.<ExceptionHandler> emptyList(); } } public String getErrorCode(Class<?> expClazz){ ExceptionDefinition definition = getExceptionDefinition(expClazz); if (null != definition) { return definition.getErrorCode(); } else { return ""; } } }
ExceptionDefinition: Exception信息单元
package com.ldd0.exception.config; import java.util.LinkedHashSet; import java.util.Set; public class ExceptionDefinition { private String errorCode; private Set<String> handlerNames = new LinkedHashSet<String> (); ExceptionDefinition() { } public ExceptionDefinition(String errorCode) { this.errorCode = errorCode; } public String getErrorCode() { return errorCode; } public void setErrorCode(String errorCode) { this.errorCode = errorCode; } public Set<String> getHandlerNames() { return handlerNames; } }
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.processor; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; import com.ldd600.exception.annotation.Exceptional; import com.ldd600.exception.base.BaseAppException; import com.ldd600.exception.base.BaseAppRuntimeException; import com.ldd600.exception.config.ExceptionDefinition; import com.ldd600.exception.context.ExceptionContext; import com.ldd600.exception.context.CoreContextFactory; public class ExceptionalAnnotationBeanPostProcessor implements BeanPostProcessor { public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if(bean instanceof BaseAppRuntimeException || bean instanceof BaseAppException) { Exceptional exceptional = bean.getClass().getAnnotation(Exceptional.class); if(null != exceptional) { ExceptionContext ctx = CoreContextFactory.getInstance().getExceptionContext(); if(!ctx.containsException(bean.getClass())) { ExceptionDefinition expDefinition = new ExceptionDefinition(exceptional.errorCode()); ctx.setExceptionDefinition(bean.getClass(), expDefinition); } ctx.addExceptionHandlers(bean.getClass(), exceptional.handlers()); return null; } } return bean; } public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } }
结果测试:
package com.ldd600.exception.test; import org.jmock.Expectations; import org.jmock.Mockery; import org.springframework.beans.factory.BeanFactory; import com.ldd600.exception.action.BusinessAction; import com.ldd600.exception.base.BaseAppException; import com.ldd600.exception.base.BaseAppRuntimeException; import com.ldd600.exception.base.ConfigException; import com.ldd600.exception.base.handler.ConsoleHandler; import com.ldd600.exception.context.CoreContextFactory; import com.ldd600.exception.dto.DefaultRequest; import com.ldd600.exception.dto.DefaultResponse; import com.ldd600.exception.dto.Request; import com.ldd600.exception.dto.Response; import com.ldd600.exception.webservice.ActionBrokerImpl; public class ExceptionTest extends DependencyInjectionExceptionTestCase { Mockery context = new Mockery(); ActionBrokerImpl broker = new ActionBrokerImpl(); final Request request = new DefaultRequest(); final Response response = new DefaultResponse(); @Override protected String[] getConfigLocations() { return new String[] { "applicationContext.xml" }; } public void testExceptionThrow() { final BusinessAction<Response, Request> action = context .mock(BusinessAction.class); final BeanFactory beanFactory = context.mock(BeanFactory.class); assertThrowing(new Closure() { public void run() throws Throwable { context.checking(new Expectations() { { allowing(beanFactory).getBean("action"); will(returnValue(action)); one(action).execute(request, response); will(throwException(new BaseAppException())); } }); broker.setExceptionHandler(new ConsoleHandler()); broker.setBeanFactory(beanFactory); broker.execute("action", request, response); } }, BaseAppException.class); } public void testExceptionalAutoLoad() throws BaseAppException { final BeanFactory beanFactory = context.mock(BeanFactory.class); final BusinessAction<Response, Request> action = context .mock(BusinessAction.class); context.checking(new Expectations() { { allowing(beanFactory).getBean("action"); will(returnValue(action)); one(action).execute(request, response); will(throwException(new ConfigException())); } }); broker.setBeanFactory(beanFactory); broker.execute("action", request, response); assertEquals(CoreContextFactory.getInstance().getExceptionContext() .getErrorCode(ConfigException.class), "LDD600-00002"); context.assertIsSatisfied(); } public void testRuntimeException() { final BusinessAction<Response, Request> action = context .mock(BusinessAction.class); final BeanFactory beanFactory = context.mock(BeanFactory.class); assertThrowing(new Closure() { public void run() throws Throwable { context.checking(new Expectations() { { allowing(beanFactory).getBean("action"); will(returnValue(action)); one(action).execute(request, response); will(throwException(new BaseAppRuntimeException())); } }); broker.setExceptionHandler(new ConsoleHandler()); broker.setBeanFactory(beanFactory); broker.execute("action", request, response); } }, BaseAppRuntimeException.class); // test config assertEquals(CoreContextFactory.getInstance().getExceptionContext() .getErrorCode(BaseAppRuntimeException.class), "LDD600-00001"); // test handler assertFalse(response.isSuccess()); assertEquals(response.getErrorCode(), CoreContextFactory.getInstance() .getExceptionContext().getErrorCode( BaseAppRuntimeException.class)); context.assertIsSatisfied(); } public void testCheckedException() { final BusinessAction<Response, Request> action = context .mock(BusinessAction.class); final BeanFactory beanFactory = context.mock(BeanFactory.class); assertThrowing(new Closure() { public void run() throws Throwable { context.checking(new Expectations() { { allowing(beanFactory).getBean("action"); will(returnValue(action)); one(action).execute(request, response); will(throwException(new ExceptionFaker())); } }); broker.setBeanFactory(beanFactory); broker.execute("action", request, response); } }, ExceptionFaker.class); // test config assertEquals(CoreContextFactory.getInstance().getExceptionContext() .getErrorCode(ExceptionFaker.class), "LDD600-00003"); // test handler assertFalse(response.isSuccess()); assertEquals(response.getErrorCode(), CoreContextFactory.getInstance() .getExceptionContext().getErrorCode( ExceptionFaker.class)); context.assertIsSatisfied(); } }
参考资料:
文章1:http://www.onjava.com/pub/a/onjava/2006/01/11/exception-handling-framework-for-j2ee.html
文章2:http://sannotations.sourceforge.net/
本文源代码:源代码下载
相关推荐
为了使自定义的异常处理生效,还需要在Spring Boot配置文件中进行相应的配置。通常情况下,可以通过在`application.yml`或`application.properties`中添加以下内容来启用自定义异常处理: ```yaml spring: main: ...
DefaultErrorWebExceptionHandler 是 SpringCloud Gateway 提供的默认异常处理实现,我们可以通过继承这个类来自定义我们的异常处理逻辑。 在 Finchley 版本的 Gateway 中,默认使用 WebFlux 形式作为底层框架,而...
在使用Spring框架中的`RestTemplate`进行HTTP请求时,我们可能会遇到各种异常情况,如服务超时、服务不存在等,这些异常通常会导致程序中断,无法继续执行后续代码。在这种情况下,我们希望即使请求失败,也能获取到...
4. **异常处理**:在Spring Boot中,可以使用@ControllerAdvice和@ExceptionHandler注解实现全局异常处理。这允许我们在一个地方捕获并处理所有控制器层的异常,统一返回格式化的错误信息,同时记录日志,提高系统的...
在IT行业中,自定义Java开发框架是提升开发效率和代码质量的重要工具。它通常包括一系列设计模式、组件和工具,旨在简化项目的构建过程,提供快速的业务逻辑搭建能力,以及高效的表单管理和数据处理功能。"自定义...
在IT行业中,Spring框架是Java企业级应用开发的首选框架,而Struts则是早期非常流行的MVC(模型-视图-控制器)框架。本资源"自定义Spring框架+Struts框架(内有详细注释)"显然是为了帮助开发者深入理解这两个框架的...
在自定义框架中,我们需要实现类似的功能,允许开发者选择不同的视图技术,并定义视图解析策略。 最后,配置和依赖注入(DI)是Spring框架的一大特色。Spring通过XML或Java配置,以及@Autowired注解实现对象的创建...
在Spring框架中,Spring Context上下文是核心组件之一,它为开发者提供了强大的依赖注入(Dependency Injection,简称DI)和控制反转(Inversion of Control,简称IoC)功能。本篇文章将深入探讨如何利用Spring ...
Spring Security 是一个强大的安全框架,广泛用于Java Web应用的安全管理,包括身份验证、授权和访问控制。在Spring Boot中,Spring Security提供了开箱即用的功能,使得开发者可以快速地为应用添加安全特性。本资源...
在"spring自定义标签例子"这个项目中,我们可以深入理解这一特性,特别是通过Chapter2工程的实例来学习。 Spring框架的自定义标签通常用于简化XML配置,提升可读性和可维护性。这些标签是基于Java的`org.spring...
该项目提供了基于Java的Spring-Transfer框架源码,该框架实现了自定义的IoC(控制反转)和AOP(面向切面编程)功能。项目包含35个文件,其中包括20个Java源文件、4个属性文件、3个XML配置文件、2个Markdown文件、1个...
在Java编程语言中,Spring Boot框架提供了一个强大的基础来快速构建和部署应用程序。Spring Boot以其模块化、自动化配置和开箱即用的功能受到广大开发者喜爱。在这个特定的场景中,我们探讨的是如何在Spring Boot...
Spring Security 是一个强大的Java安全框架,它为Web应用程序提供了全面的安全解决方案。在Spring Security中,密码的加密是非常关键的一部分,因为这直接关系到用户数据的安全性。本示例将介绍如何在Spring ...
Java异常框架处理是Java编程中十分关键的一部分,主要涉及到Java异常类的层次结构、异常的分类、异常的处理方式,以及如何在实际开发中使用异常框架来处理各种运行时错误。 首先,我们需要了解Java的异常类的层次...
总的来说,"JAVA动态表单设计,自定义表单,自定义数据"涉及的技术栈包括Java后端开发、前端界面设计、数据库管理和RESTful API设计。通过以上各模块的协同工作,可以构建出一个高效、易用的动态表单系统,满足不同...
这个手动实现的Spring框架项目主要参照了网络上的视频教程,目的是为了学习和实践。项目中,POM.xml文件仅包含了一个Servlet依赖的jar包,这表明实现主要集中在Spring的核心功能上,如IoC(控制反转)和DI(依赖注入...
- 自定义框架借鉴了Struts的架构,但可能在具体实现上有所不同,比如请求处理机制、拦截器、AOP(面向切面编程)支持等。 - 自定义框架的优点在于可以根据项目需求进行定制,避免过度依赖第三方库,提高代码的可控...
本教程将探讨如何使用Java自定义注解来模拟实现这些SpringBoot相关的注解功能。 首先,我们来看`@Autowired`注解。`@Autowired`是Spring框架中的一个关键注解,用于自动装配bean。当我们想在类中注入某个依赖时,而...
Java 自定义注解验证是Java开发中的一个重要特性,它允许开发者创建自己的元数据,以便在编译时或运行时对代码进行验证和处理。自定义注解为代码提供了额外的信息,使得程序更具可读性、可维护性和灵活性。在本案例...
综上所述,结合Spring MVC和Spring Security实现自定义登录,需要理解两者的基本原理,配置合适的过滤器、认证提供者和授权规则。通过这种方式,我们可以创建一个既安全又易于维护的Web应用程序,为用户提供安全的...