`

SSH项目中利用struts的ExceptionHandler处理异常

StrutsSSH项目管理ApacheJSP 
阅读更多

一、概述

       在Struts1.X的版本中加入了对异常的处理 Exception Handling，有了它就不需要我们用try/catch等捕获异常，一旦出现了我们已经定义的异常那么就会转到相应得页面，并且携带定制的信息。Struts框架提供了默认的异常处理org.apache.struts.action.ExceptionHandler，它的execute()方法负责处理异常。在需要实现自定义处理时重写方法，可以在配置文件定义由谁来处理Action类中掷出的某种异常。

 

二、Struts框架处理异常的流程

      struts的控制器负责捕获各种异常，包括控制器运行中本身抛出的异常，以及调用模型的业务方法时抛出的异常。当struts的控制器捕获到异常后，在异常处理代码块中，创建描述信息的actionMessage对象把它保存在acionMessages(或其子类actionErrors)对象中，然后把actionMessage保存在特定范围（配置文件中的scope）。然后可以用<html:errors />检索特定范围内的actionMessages对象

 

三、实现步骤

  1. 创建自己的异常处理类
    Java代码 复制代码
    1. package com.fengzhiyin.common;   
    2.   
    3. import javax.servlet.ServletException;   
    4. import javax.servlet.http.HttpServletRequest;   
    5. import javax.servlet.http.HttpServletResponse;   
    6.   
    7. import org.apache.commons.logging.Log;   
    8. import org.apache.commons.logging.LogFactory;   
    9. import org.apache.struts.Globals;   
    10. import org.apache.struts.action.ActionForm;   
    11. import org.apache.struts.action.ActionForward;   
    12. import org.apache.struts.action.ActionMapping;   
    13. import org.apache.struts.action.ActionMessage;   
    14. import org.apache.struts.config.ExceptionConfig;   
    15. import org.apache.struts.util.ModuleException;   
    16.   
    17. public class ExceptionHandler extends org.apache.struts.action.ExceptionHandler {   
    18.     /**  
    19.      * Logger for this class  
    20.      */  
    21.     private static final Log logger = LogFactory.getLog(ExceptionHandler.class);   
    22.   
    23.     /*  
    24.      * (non-Javadoc)  
    25.      */  
    26.     @Override  
    27.     public ActionForward execute(Exception ex, ExceptionConfig config, ActionMapping mapping, ActionForm formInstance, HttpServletRequest request,   
    28.             HttpServletResponse response) throws ServletException {   
    29.         if (logger.isDebugEnabled()) {   
    30.             logger.debug("execute(Exception, ExceptionConfig, ActionMapping, ActionForm, HttpServletRequest, HttpServletResponse) - start");   
    31.         }   
    32.   
    33.         logger.warn("action exception.", ex);   
    34.   
    35.         String f = (String) request.getAttribute("exceptionForward");   
    36.         request.setAttribute("javax.servlet.jsp.jspException", ex);   
    37.   
    38.         ActionForward forward = null;   
    39.         ActionMessage error = null;   
    40.         String property = null;   
    41.   
    42.         // Build the forward from the exception mapping if it exists   
    43.         // or from the form input   
    44.         if (config.getPath() != null) {   
    45.             forward = new ActionForward(config.getPath());   
    46.         } else if (f != null) {   
    47.             forward = f.indexOf(".jsp") == -1 ? mapping.findForward(f) : new ActionForward(f);   
    48.         } else {   
    49.             forward = mapping.getInputForward();   
    50.         }   
    51.   
    52.         // Figure out the error   
    53.         if (ex instanceof ModuleException) {   
    54.             error = ((ModuleException) ex).getActionMessage();   
    55.             property = ((ModuleException) ex).getProperty();   
    56.         } else {   
    57.             error = new ActionMessage(config.getKey(), ex.getMessage());   
    58.             property = error.getKey();   
    59.         }   
    60.   
    61.         this.logException(ex);   
    62.   
    63.         // Store the exception   
    64.         request.setAttribute(Globals.EXCEPTION_KEY, ex);   
    65.         this.storeException(request, property, error, forward, config.getScope());   
    66.   
    67.         if (logger.isDebugEnabled()) {   
    68.             logger.debug("execute(Exception, ExceptionConfig, ActionMapping, ActionForm, HttpServletRequest, HttpServletResponse) - end");   
    69.         }   
    70.         return forward;   
    71.     }   
    72.   
    73. }  
    package com.fengzhiyin.common;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts.Globals;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.config.ExceptionConfig;
import org.apache.struts.util.ModuleException;

public class ExceptionHandler extends org.apache.struts.action.ExceptionHandler {
	/**
	 * Logger for this class
	 */
	private static final Log logger = LogFactory.getLog(ExceptionHandler.class);

	/*
	 * (non-Javadoc)
	 */
	@Override
	public ActionForward execute(Exception ex, ExceptionConfig config, ActionMapping mapping, ActionForm formInstance, HttpServletRequest request,
			HttpServletResponse response) throws ServletException {
		if (logger.isDebugEnabled()) {
			logger.debug("execute(Exception, ExceptionConfig, ActionMapping, ActionForm, HttpServletRequest, HttpServletResponse) - start");
		}

		logger.warn("action exception.", ex);

		String f = (String) request.getAttribute("exceptionForward");
		request.setAttribute("javax.servlet.jsp.jspException", ex);

		ActionForward forward = null;
		ActionMessage error = null;
		String property = null;

		// Build the forward from the exception mapping if it exists
		// or from the form input
		if (config.getPath() != null) {
			forward = new ActionForward(config.getPath());
		} else if (f != null) {
			forward = f.indexOf(".jsp") == -1 ? mapping.findForward(f) : new ActionForward(f);
		} else {
			forward = mapping.getInputForward();
		}

		// Figure out the error
		if (ex instanceof ModuleException) {
			error = ((ModuleException) ex).getActionMessage();
			property = ((ModuleException) ex).getProperty();
		} else {
			error = new ActionMessage(config.getKey(), ex.getMessage());
			property = error.getKey();
		}

		this.logException(ex);

		// Store the exception
		request.setAttribute(Globals.EXCEPTION_KEY, ex);
		this.storeException(request, property, error, forward, config.getScope());

		if (logger.isDebugEnabled()) {
			logger.debug("execute(Exception, ExceptionConfig, ActionMapping, ActionForm, HttpServletRequest, HttpServletResponse) - end");
		}
		return forward;
	}

}
  2. 定义异常处理配置文件
    全局异常 在struts-config.xml中定义<global-exceptions />
    Xml代码 复制代码
    1. <global-exceptions><!-- 元素可以包含一个或者多个<exception> -->  
    2.     <exception    
    3.         key="error.common"<!-- <message-resources parameter="MessageResources" />中的key -->  
    4.         type="com.fengzhiyin.exception.ExistException"<!-- 指定需要处理异常类的名字 -->  
    5.         handler="com.bjnv.water.common.ExceptionHandler" <!-- 指定异常处理类默认是ExceptionHandler -->  
    6.         path="/jsp/common/error.jsp"<!-- 指定当前异常发生的时候转发的路径 -->  
    7.         scope="request"><!-- 指定ActionMessages实例存放的范围 -->  
    8.     </exception>  
    9. </global-exceptions>   
    <global-exceptions><!-- 元素可以包含一个或者多个<exception> -->
	<exception 
		key="error.common"<!-- <message-resources parameter="MessageResources" />中的key -->
		type="com.fengzhiyin.exception.ExistException"<!-- 指定需要处理异常类的名字 -->
		handler="com.bjnv.water.common.ExceptionHandler" <!-- 指定异常处理类默认是ExceptionHandler -->
		path="/jsp/common/error.jsp"<!-- 指定当前异常发生的时候转发的路径 -->
		scope="request"><!-- 指定ActionMessages实例存放的范围 -->
	</exception>
</global-exceptions>
    上述代码在struts-config.xml中定义了一个全局异常，它的作用是抛出ExistException（本处的意思是当在添加用户时候发现该用户名已经存在）异常的时候返回到error.jsp中，并且携带自定的比较规范的异常信息expired.existName，expired.existName可以在应用程序的资源配置文件中找到,如：
    　　expired.existName=你要添加的用户名称已经存在，请添加新的名称！
    局部异常 在struts-config.xml中定义<global-exceptions />
    Xml代码 复制代码
    1. <action-mappings>  
    2. 　　<action path=”/waterUser”   
    3. 　　　　    type=”**Action”   
    4. 　　　　    name=”*Form”>  
    5. 　　  <exception key=”<SPAN style="FONT-SIZE: x-small">expired.existName</SPAN>”   
    6. 　　      type=” com.fengzhiyin.exception.ExistException”   
    7. 　　      path=”/error.jsp”/>  
    8. 　　　　    <forward name=”success” path=”***”/>  
    9. 　　</action>  
    10. </action-mappings>   
    <action-mappings>
　　<action path=”/waterUser”
　　　　	type=”**Action”
　　　　	name=”*Form”>
　　	<exception key=”expired.existName”
　　		type=” com.fengzhiyin.exception.ExistException”
　　		path=”/error.jsp”/>
　　　　	<forward name=”success” path=”***”/>
　　</action>
</action-mappings>
     
  3. 创建异常信息显示页面
    Java代码 复制代码
    1. <%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>   
    2. 　　<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>   
    3. 　　<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>   
    4. 　　<html:html locale="true">   
    5. 　　<head>   
    6. 　　 <title> Exception Handler</title>   
    7. 　　 <html:base />   
    8. 　　 </head>   
    9. 　　 <body>   
    10. 　　 <h1>系统出现一个意外</h1>   
    11. 　　 请将下面的提示信息反馈给你的系统管理员:<br>   
    12. 　　 <html:errors /> <!--将在这里显示”<SPAN style="FONT-SIZE: x-small; COLOR: #0000ff">你要添加的用户名称已经存在，请添加新的名称！</SPAN>”-->   
    13. 　　 </body>   
    14. 　　</html:html>  
    <%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
　　<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>
　　<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
　　<html:html locale="true">
　　<head>
　　 <title> Exception Handler</title>
　　 <html:base />
　　 </head>
　　 <body>
　　 <h1>系统出现一个意外</h1>
　　 请将下面的提示信息反馈给你的系统管理员:<br>
　　 <html:errors /> <!--将在这里显示”你要添加的用户名称已经存在，请添加新的名称！”-->
　　 </body>
　　</html:html>
     
  4. 创建测试action
    Java代码 复制代码
    1. public class **Action extends BaseAction {   
    2. 　　 public ActionForward execute(ActionMapping mapping,   
    3. 　　  ActionForm form,   
    4. 　　  HttpServletRequest request,   
    5. 　　  HttpServletResponse response)throws Exception {   
    6. 　　   throw com.fengzhiyin.exception.ExistException();   
    7. 　　 }   
    8. }  
    public class **Action extends BaseAction {
　　 public ActionForward execute(ActionMapping mapping,
　　 	ActionForm form,
　　 	HttpServletRequest request,
　　	HttpServletResponse response)throws Exception {
　　	 throw com.fengzhiyin.exception.ExistException();
　　 }
}
          转http://fengzhiyin.iteye.com/blog/432182
分享到：
| 线程相关知识点
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    ssh项目流程和注意事项

    - 使用Spring的`@ExceptionHandler`注解处理控制器中的异常。 4. **性能优化**： - 对于Hibernate，合理配置缓存策略，减少数据库访问频率。 - 采用懒加载等技术，提升系统响应速度。 5. **安全性**： - 实现...

    JavaSSH 整合

    7. **异常处理**：项目可能会包含全局的异常处理机制，如使用Spring的`@ExceptionHandler`注解或Struts2的拦截器，来统一处理可能出现的运行时异常，提高用户体验。 8. **测试与调试**：为了保证项目的稳定性和正确...

    ssh+mysql学生成绩管理系统

    SSH框架提供了处理异常的方式，例如使用Spring的@ControllerAdvice和@ExceptionHandler注解进行全局异常捕获和处理。 这个项目是一个综合性的学习案例，涵盖了Java Web开发的基础和进阶知识，包括前端页面设计、...

    ssm和ssh框架jar包整合

    2. **异常处理**：合理配置全局异常处理，例如在Spring MVC中设置@ControllerAdvice和@ExceptionHandler。 3. **日志管理**：添加适当的日志库，如log4j或logback，以便调试和监控应用状态。 4. **事务管理**：...

    SSH整合，去lib源码

    8. **异常处理**：理解Spring的全局异常处理机制，如@ControllerAdvice和@ExceptionHandler注解。 9. **性能优化**：包括数据库查询优化、缓存策略、线程池配置等，以提升系统性能。 10. **安全控制**：Spring ...

    sshj整合开发ar包

    - **异常处理**：统一异常处理机制可以提高应用的健壮性，如使用Spring的`@ExceptionHandler`注解或Struts的全局异常处理。 - **测试**：SSHJ整合项目通常会使用JUnit和Mockito等工具进行单元测试和集成测试，保证...

    ssh对应的配置文件(xml)信息详解[归类].pdf

    通过`exception`子元素，可以指定特定异常与ExceptionHandler的映射，处理Java运行时异常。它包括`className`、`handler`、`key`、`path`、`scope`、`type`和`bundle`等属性，用于指定处理类、消息键、转发路径等。 ...

    springmvc实例

    在实际项目中，Spring MVC 可以与 Struts 和 Hibernate 整合，实现业务逻辑处理和数据持久化。在本实例中，如果标签为 "JAVA"，可能意味着涉及了 Spring MVC 与其他 Java 框架的集成。 6. **模型数据传递** Model ...

    【Java实战教程】11. 整合 Spring 与 Spring Mvc框架.haozip02.zip

    - 使用Spring MVC的异常处理机制，如@ControllerAdvice和@ExceptionHandler，来统一处理全局异常。 - 配置视图解析器，如InternalResourceViewResolver，指定视图路径前缀和后缀，以便Spring MVC能正确找到JSP或...

    spring的注解方式

    12. `@ControllerAdvice` 和 `@ExceptionHandler`：全局异常处理，可以在一个地方处理所有控制器中的异常。 13. `@Configuration` 和 `@Bean`：这两个注解一起使用，可以替代XML配置，创建和定义Bean。 在SSH集成...

Magicbox
Global site tag (gtag.js) - Google Analytics