Struts(十九)：类型转换、类型转换错误消息及显示

• 类型转换概念

1、从html表单页面到一个Action对象，类型转化是从字符串到一个非字符串：html并没有“类型”的概念，每个表单输入的信息都只可能是一个字符串或者一个字符串数组，但是在服务器端，必须把String字符串转化为一种特定的数据类型；

2、在Struts2中，把请求参数映射到Action的属性的工作由ParametersInterceptor拦截器负责，它默认是defaultStack拦截器栈中的一员。Parameters拦截器可以自动完成字符串和基本类型之间转换。

ParameterInterceptor：

 /*
  * Copyright 2002-2007,2009 The Apache Software Foundation.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.opensymphony.xwork2.interceptor;

 import com.opensymphony.xwork2.ActionContext;
 import com.opensymphony.xwork2.ActionInvocation;
 import com.opensymphony.xwork2.security.AcceptedPatternsChecker;
 import com.opensymphony.xwork2.security.ExcludedPatternsChecker;
 import com.opensymphony.xwork2.ValidationAware;
 import com.opensymphony.xwork2.XWorkConstants;
 import com.opensymphony.xwork2.conversion.impl.InstantiatingNullHandler;
 import com.opensymphony.xwork2.conversion.impl.XWorkConverter;
 import com.opensymphony.xwork2.inject.Inject;
 import com.opensymphony.xwork2.util.ClearableValueStack;
 import com.opensymphony.xwork2.util.LocalizedTextUtil;
 import com.opensymphony.xwork2.util.MemberAccessValueStack;
 import com.opensymphony.xwork2.util.ValueStack;
 import com.opensymphony.xwork2.util.ValueStackFactory;
 import com.opensymphony.xwork2.util.logging.Logger;
 import com.opensymphony.xwork2.util.logging.LoggerFactory;
 import com.opensymphony.xwork2.util.reflection.ReflectionContextState;

 import java.util.Collection;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.TreeMap;

 /**
  * <!-- START SNIPPET: description -->
  * This interceptor sets all parameters on the value stack.
  *
  * This interceptor gets all parameters from {@link ActionContext#getParameters()} and sets them on the value stack by
  * calling {@link ValueStack#setValue(String, Object)}, typically resulting in the values submitted in a form
  * request being applied to an action in the value stack. Note that the parameter map must contain a String key and
  * often containers a String[] for the value.
  *
  * The interceptor takes one parameter named 'ordered'. When set to true action properties are guaranteed to be
  * set top-down which means that top action's properties are set first. Then it's subcomponents properties are set.
  * The reason for this order is to enable a 'factory' pattern. For example, let's assume that one has an action
  * that contains a property named 'modelClass' that allows to choose what is the underlying implementation of model.
  * By assuring that modelClass property is set before any model properties are set, it's possible to choose model
  * implementation during action.setModelClass() call. Similiarily it's possible to use action.setPrimaryKey()
  * property set call to actually load the model class from persistent storage. Without any assumption on parameter
  * order you have to use patterns like 'Preparable'.
  *
  * Because parameter names are effectively OGNL statements, it is important that security be taken in to account.
  * This interceptor will not apply any values in the parameters map if the expression contains an assignment (=),
  * multiple expressions (,), or references any objects in the context (#). This is all done in the {@link
  * #acceptableName(String)} method. In addition to this method, if the action being invoked implements the {@link
  * ParameterNameAware} interface, the action will be consulted to determine if the parameter should be set.
  *
  * In addition to these restrictions, a flag ({@link ReflectionContextState#DENY_METHOD_EXECUTION}) is set such that
  * no methods are allowed to be invoked. That means that any expression such as <i>person.doSomething()</i> or
  * <i>person.getName()</i> will be explicitely forbidden. This is needed to make sure that your application is not
  * exposed to attacks by malicious users.
  *
  * While this interceptor is being invoked, a flag ({@link ReflectionContextState#CREATE_NULL_OBJECTS}) is turned
  * on to ensure that any null reference is automatically created - if possible. See the type conversion documentation
  * and the {@link InstantiatingNullHandler} javadocs for more information.
  *
  * Finally, a third flag ({@link XWorkConverter#REPORT_CONVERSION_ERRORS}) is set that indicates any errors when
  * converting the the values to their final data type (String[] -&gt; int) an unrecoverable error occured. With this
  * flag set, the type conversion errors will be reported in the action context. See the type conversion documentation
  * and the {@link XWorkConverter} javadocs for more information.
  *
  * If you are looking for detailed logging information about your parameters, turn on DEBUG level logging for this
  * interceptor. A detailed log of all the parameter keys and values will be reported.
  *
  * <b>Note:</b> Since XWork 2.0.2, this interceptor extends {@link MethodFilterInterceptor}, therefore being
  * able to deal with excludeMethods / includeMethods parameters. See [Workflow Interceptor]
  * (class {@link DefaultWorkflowInterceptor}) for documentation and examples on how to use this feature.
  * <!-- END SNIPPET: description -->
  *
  * <u>Interceptor parameters:</u>
  *
  * <!-- START SNIPPET: parameters -->
  *
  * <ul>
  * <li>ordered - set to true if you want the top-down property setter behaviour</li>
  * <li>acceptParamNames - a comma delimited list of regular expressions to describe a whitelist of accepted parameter names.
  * Don't change the default unless you know what you are doing in terms of security implications</li>
  * <li>excludeParams - a comma delimited list of regular expressions to describe a blacklist of not allowed parameter names</li>
  * <li>paramNameMaxLength - the maximum length of parameter names; parameters with longer names will be ignored; the default is 100 characters</li>
  * </ul>
  *
  * <!-- END SNIPPET: parameters -->
  *
  *  <u>Extending the interceptor:</u>
  *
  * <!-- START SNIPPET: extending -->
  *
  *  The best way to add behavior to this interceptor is to utilize the {@link ParameterNameAware} interface in your
  * actions. However, if you wish to apply a global rule that isn't implemented in your action, then you could extend
  * this interceptor and override the {@link #acceptableName(String)} method.
  *
  * <!-- END SNIPPET: extending -->
  *
  *
  * <!-- START SNIPPET: extending-warning -->
  * Using {@link ParameterNameAware} could be dangerous as {@link ParameterNameAware#acceptableParameterName(String)} takes precedence
  * over ParametersInterceptor which means if ParametersInterceptor excluded given parameter name you can accept it with
  * {@link ParameterNameAware#acceptableParameterName(String)}.
  *
  * The best idea is to define very tight restrictions with ParametersInterceptor and relax them per action with
  * {@link ParameterNameAware#acceptableParameterName(String)}
  * <!-- END SNIPPET: extending-warning -->
  *
  *
  * <u>Example code:</u>
  *
  * <pre>
  * <!-- START SNIPPET: example -->
  * &lt;action name="someAction" class="com.examples.SomeAction"&gt;
  *     &lt;interceptor-ref name="params"/&gt;
  *     &lt;result name="success"&gt;good_result.ftl&lt;/result&gt;
  * &lt;/action&gt;
  * <!-- END SNIPPET: example -->
  * </pre>
  *
  * @author Patrick Lightbody
  */
 public class ParametersInterceptor extends MethodFilterInterceptor {

     private static final Logger LOG = LoggerFactory.getLogger(ParametersInterceptor.class);

     protected static final int PARAM_NAME_MAX_LENGTH = 100;

     private int paramNameMaxLength = PARAM_NAME_MAX_LENGTH;
     private boolean devMode = false;

     protected boolean ordered = false;

     private ValueStackFactory valueStackFactory;
     private ExcludedPatternsChecker excludedPatterns;
     private AcceptedPatternsChecker acceptedPatterns;

     @Inject
     public void setValueStackFactory(ValueStackFactory valueStackFactory) {
         this.valueStackFactory = valueStackFactory;
     }

     @Inject(XWorkConstants.DEV_MODE)
     public void setDevMode(String mode) {
         devMode = "true".equalsIgnoreCase(mode);
     }

     @Inject
     public void setExcludedPatterns(ExcludedPatternsChecker excludedPatterns) {
         this.excludedPatterns = excludedPatterns;
     }

     @Inject
     public void setAcceptedPatterns(AcceptedPatternsChecker acceptedPatterns) {
         this.acceptedPatterns = acceptedPatterns;
     }

     /**
      * If the param name exceeds the configured maximum length it will not be
      * accepted.
      *
      * @param paramNameMaxLength Maximum length of param names
      */
     public void setParamNameMaxLength(int paramNameMaxLength) {
         this.paramNameMaxLength = paramNameMaxLength;
     }

     static private int countOGNLCharacters(String s) {
         int count = 0;
         for (int i = s.length() - 1; i >= 0; i--) {
             char c = s.charAt(i);
             if (c == '.' || c == '[') count++;
         }
         return count;
     }

     /**
      * Compares based on number of '.' and '[' characters (fewer is higher)
      */
     static final Comparator<String> rbCollator = new Comparator<String>() {
         public int compare(String s1, String s2) {
             int l1 = countOGNLCharacters(s1),
                 l2 = countOGNLCharacters(s2);
             return l1 < l2 ? -1 : (l2 < l1 ? 1 : s1.compareTo(s2));
         }

     };

     @Override
     public String doIntercept(ActionInvocation invocation) throws Exception {
         Object action = invocation.getAction();
         if (!(action instanceof NoParameters)) {
             ActionContext ac = invocation.getInvocationContext();
             final Map<String, Object> parameters = retrieveParameters(ac);

             if (LOG.isDebugEnabled()) {
                 LOG.debug("Setting params " + getParameterLogMap(parameters));
             }

             if (parameters != null) {
                 Map<String, Object> contextMap = ac.getContextMap();
                 try {
                     ReflectionContextState.setCreatingNullObjects(contextMap, true);
                     ReflectionContextState.setDenyMethodExecution(contextMap, true);
                     ReflectionContextState.setReportingConversionErrors(contextMap, true);

                     ValueStack stack = ac.getValueStack();
                     setParameters(action, stack, parameters);
                 } finally {
                     ReflectionContextState.setCreatingNullObjects(contextMap, false);
                     ReflectionContextState.setDenyMethodExecution(contextMap, false);
                     ReflectionContextState.setReportingConversionErrors(contextMap, false);
                 }
             }
         }
         return invocation.invoke();
     }

     /**
      * Gets the parameter map to apply from wherever appropriate
      *
      * @param ac The action context
      * @return The parameter map to apply
      */
     protected Map<String, Object> retrieveParameters(ActionContext ac) {
         return ac.getParameters();
     }

     /**
      * Adds the parameters into context's ParameterMap
      *
      * @param ac        The action context
      * @param newParams The parameter map to apply
      *                  <p/>
      *                  In this class this is a no-op, since the parameters were fetched from the same location.
      *                  In subclasses both retrieveParameters() and addParametersToContext() should be overridden.
      */
     protected void addParametersToContext(ActionContext ac, Map<String, Object> newParams) {
     }

     protected void setParameters(final Object action, ValueStack stack, final Map<String, Object> parameters) {
         Map<String, Object> params;
         Map<String, Object> acceptableParameters;
         if (ordered) {
             params = new TreeMap<String, Object>(getOrderedComparator());
             acceptableParameters = new TreeMap<String, Object>(getOrderedComparator());
             params.putAll(parameters);
         } else {
             params = new TreeMap<String, Object>(parameters);
             acceptableParameters = new TreeMap<String, Object>();
         }

         for (Map.Entry<String, Object> entry : params.entrySet()) {
             String name = entry.getKey();
             Object value = entry.getValue();
             if (isAcceptableParameter(name, action)) {
                 acceptableParameters.put(name, entry.getValue());
             }
         }

         ValueStack newStack = valueStackFactory.createValueStack(stack);
         boolean clearableStack = newStack instanceof ClearableValueStack;
         if (clearableStack) {
             //if the stack's context can be cleared, do that to prevent OGNL
             //from having access to objects in the stack, see XW-641
             ((ClearableValueStack)newStack).clearContextValues();
             Map<String, Object> context = newStack.getContext();
             ReflectionContextState.setCreatingNullObjects(context, true);
             ReflectionContextState.setDenyMethodExecution(context, true);
             ReflectionContextState.setReportingConversionErrors(context, true);

             //keep locale from original context
             context.put(ActionContext.LOCALE, stack.getContext().get(ActionContext.LOCALE));
         }

         boolean memberAccessStack = newStack instanceof MemberAccessValueStack;
         if (memberAccessStack) {
             //block or allow access to properties
             //see WW-2761 for more details
             MemberAccessValueStack accessValueStack = (MemberAccessValueStack) newStack;
             accessValueStack.setAcceptProperties(acceptedPatterns.getAcceptedPatterns());
             accessValueStack.setExcludeProperties(excludedPatterns.getExcludedPatterns());
         }

         for (Map.Entry<String, Object> entry : acceptableParameters.entrySet()) {
             String name = entry.getKey();
             Object value = entry.getValue();
             try {
                 newStack.setParameter(name, value);
             } catch (RuntimeException e) {
                 if (devMode) {
                     notifyDeveloperParameterException(action, name, e.getMessage());
                 }
             }
         }

         if (clearableStack && (stack.getContext() != null) && (newStack.getContext() != null))
             stack.getContext().put(ActionContext.CONVERSION_ERRORS, newStack.getContext().get(ActionContext.CONVERSION_ERRORS));

         addParametersToContext(ActionContext.getContext(), acceptableParameters);
     }

     protected void notifyDeveloperParameterException(Object action, String property, String message) {
         String developerNotification = LocalizedTextUtil.findText(ParametersInterceptor.class, "devmode.notification",
                 ActionContext.getContext().getLocale(), "Developer Notification:\n{0}",
                 new Object[]{
                         "Unexpected Exception caught setting '" + property + "' on '" + action.getClass() + ": " + message
                 }
         );
         LOG.error(developerNotification);
         // see https://issues.apache.org/jira/browse/WW-4066
         if (action instanceof ValidationAware) {
             Collection<String> messages = ((ValidationAware) action).getActionMessages();
             messages.add(message);
             ((ValidationAware) action).setActionMessages(messages);
         }
     }

     /**
      * Checks if name of parameter can be accepted or thrown away
      *
      * @param name parameter name
      * @param action current action
      * @return true if parameter is accepted
      */
     protected boolean isAcceptableParameter(String name, Object action) {
         ParameterNameAware parameterNameAware = (action instanceof ParameterNameAware) ? (ParameterNameAware) action : null;
         return acceptableName(name) && (parameterNameAware == null || parameterNameAware.acceptableParameterName(name));
     }

     /**
      * Gets an instance of the comparator to use for the ordered sorting.  Override this
      * method to customize the ordering of the parameters as they are set to the
      * action.
      *
      * @return A comparator to sort the parameters
      */
     protected Comparator<String> getOrderedComparator() {
         return rbCollator;
     }

     protected String getParameterLogMap(Map<String, Object> parameters) {
         if (parameters == null) {
             return "NONE";
         }

         StringBuilder logEntry = new StringBuilder();
         for (Map.Entry entry : parameters.entrySet()) {
             logEntry.append(String.valueOf(entry.getKey()));
             logEntry.append(" => ");
             if (entry.getValue() instanceof Object[]) {
                 Object[] valueArray = (Object[]) entry.getValue();
                 logEntry.append("[ ");
                 if (valueArray.length > 0 ) {
                     for (int indexA = 0; indexA < (valueArray.length - 1); indexA++) {
                         Object valueAtIndex = valueArray[indexA];
                         logEntry.append(String.valueOf(valueAtIndex));
                         logEntry.append(", ");
                     }
                     logEntry.append(String.valueOf(valueArray[valueArray.length - 1]));
                 }
                 logEntry.append(" ] ");
             } else {
                 logEntry.append(String.valueOf(entry.getValue()));
             }
         }

         return logEntry.toString();
     }

     protected boolean acceptableName(String name) {
         boolean accepted = isWithinLengthLimit(name) && !isExcluded(name) && isAccepted(name);
         if (devMode && accepted) { // notify only when in devMode
             LOG.debug("Parameter [#0] was accepted and will be appended to action!", name);
         }
         return accepted;
     }

     protected boolean isWithinLengthLimit( String name ) {
         boolean matchLength = name.length() <= paramNameMaxLength;
         if (!matchLength) {
             notifyDeveloper("Parameter [#0] is too long, allowed length is [#1]", name, String.valueOf(paramNameMaxLength));
         }
         return matchLength;
     }

     protected boolean isAccepted(String paramName) {
         AcceptedPatternsChecker.IsAccepted result = acceptedPatterns.isAccepted(paramName);
         if (result.isAccepted()) {
             return true;
         }
         notifyDeveloper("Parameter [#0] didn't match accepted pattern [#1]!", paramName, result.getAcceptedPattern());
         return false;
     }

     protected boolean isExcluded(String paramName) {
         ExcludedPatternsChecker.IsExcluded result = excludedPatterns.isExcluded(paramName);
         if (result.isExcluded()) {
             notifyDeveloper("Parameter [#0] matches excluded pattern [#1]!", paramName, result.getExcludedPattern());
             return true;
         }
         return false;
     }

     private void notifyDeveloper(String message, String... parameters) {
         if (devMode) {
             LOG.warn(message, parameters);
         } else {
             if (LOG.isDebugEnabled()) {
                 LOG.debug(message, parameters);
             }
         }
     }

     /**
      * Whether to order the parameters or not
      *
      * @return True to order
      */
     public boolean isOrdered() {
         return ordered;
     }

     /**
      * Set whether to order the parameters by object depth or not
      *
      * @param ordered True to order them
      */
     public void setOrdered(boolean ordered) {
         this.ordered = ordered;
     }

     /**
      * Sets a comma-delimited list of regular expressions to match
      * parameters that are allowed in the parameter map (aka whitelist).
      * <p/>
      * Don't change the default unless you know what you are doing in terms
      * of security implications.
      *
      * @param commaDelim A comma-delimited list of regular expressions
      */
     public void setAcceptParamNames(String commaDelim) {
         acceptedPatterns.setAcceptedPatterns(commaDelim);
     }

     /**
      * Sets a comma-delimited list of regular expressions to match
      * parameters that should be removed from the parameter map.
      *
      * @param commaDelim A comma-delimited list of regular expressions
      */
     public void setExcludeParams(String commaDelim) {
         excludedPatterns.setExcludedPatterns(commaDelim);
     }

 }

• 类型转换错误消息及显示

如果类型转换失败：

1、若Action类没有实现ValidationAware接口：Struts在遇到类型转换错误时，仍会调用其Action的方法，就好像什么都没有发生一样；

struts.xml

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE struts PUBLIC
     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
     "http://struts.apache.org/dtds/struts-2.3.dtd">
 <struts>
     <constant name="struts.ognl.allowStaticMethodAccess" value="true" />
     <constant name="struts.devMode" value="false" />
     <package name="default" namespace="/" extends="struts-default">
         <global-results>
             <result name="error">/error.jsp</result>
         </global-results>
         <global-exception-mappings>
             <exception-mapping result="error"
                 exception="java.lang.ArithmeticException"></exception-mapping>
         </global-exception-mappings>
         <action name="myAction" class="com.dx.actions.MyAction" method="save">
             <result>/success.jsp</result>
         </action>
     </package>
 </struts>

MyAction.java

 /**
  * @author Administrator
  *
  */
 package com.dx.actions;

 public class MyAction {
     private Integer age;
     public Integer getAge() {
         return age;
     }
     public void setAge(Integer age) {
         this.age = age;
     }

     public String save() {

         return "success";
     }
 }

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <s:form action="myAction">
        <s:textfield name="age" label="Age"></s:textfield>
        <s:submit label="提交"></s:submit>
    </s:form>
</body>
</html>

访问index.jsp，输入“abc”则出现错误，但是依然调转到success.jsp.

2、若Action类实现ValidationAware接口：Struts在遇到类型转换错误时，将不会继续调用其Action方法：Struts将检查相关action元素的声明是否包含这一个name=input的result。如果有，Struts将把控制权转交给那个result元素；如没有input result，Struts将抛出一个异常。

修改MyAction.java页面，使其继承com.opensymphony.xwork2.ActionSupport类，因为com.opensymphony.xwork2.ActionSupport实现了com.opensymphony.xwork2.ValidationAware接口。

/**
 * @author Administrator
 *
 */
package com.dx.actions;

import com.opensymphony.xwork2.ActionSupport;

public class MyAction extends ActionSupport {
    private Integer age;
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }

    public String save() {

        return "success";
    }
}

com.opensymphony.xwork2.ActionSupport

/*
 * Copyright 2002-2006,2009 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.opensymphony.xwork2;

import com.opensymphony.xwork2.inject.Container;
import com.opensymphony.xwork2.inject.Inject;
import com.opensymphony.xwork2.util.ValueStack;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.logging.LoggerFactory;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;

/**
 * Provides a default implementation for the most common actions.
 * See the documentation for all the interfaces this class implements for more detailed information.
 */
public class ActionSupport implements Action, Validateable, ValidationAware, TextProvider, LocaleProvider, Serializable {

    protected static Logger LOG = LoggerFactory.getLogger(ActionSupport.class);

    private final ValidationAwareSupport validationAware = new ValidationAwareSupport();

    private transient TextProvider textProvider;
    private Container container;

    public void setActionErrors(Collection<String> errorMessages) {
        validationAware.setActionErrors(errorMessages);
    }

    public Collection<String> getActionErrors() {
        return validationAware.getActionErrors();
    }

    public void setActionMessages(Collection<String> messages) {
        validationAware.setActionMessages(messages);
    }

    public Collection<String> getActionMessages() {
        return validationAware.getActionMessages();
    }

    /**
     * @deprecated Use {@link #getActionErrors()}.
     */
    @Deprecated
    public Collection<String> getErrorMessages() {
        return getActionErrors();
    }

    /**
     * @deprecated Use {@link #getFieldErrors()}.
     */
    @Deprecated
    public Map<String, List<String>> getErrors() {
        return getFieldErrors();
    }

    public void setFieldErrors(Map<String, List<String>> errorMap) {
        validationAware.setFieldErrors(errorMap);
    }

    public Map<String, List<String>> getFieldErrors() {
        return validationAware.getFieldErrors();
    }

    public Locale getLocale() {
        ActionContext ctx = ActionContext.getContext();
        if (ctx != null) {
            return ctx.getLocale();
        } else {
            if (LOG.isDebugEnabled()) {
            LOG.debug("Action context not initialized");
            }
            return null;
        }
    }

    public boolean hasKey(String key) {
        return getTextProvider().hasKey(key);
    }

    public String getText(String aTextName) {
        return getTextProvider().getText(aTextName);
    }

    public String getText(String aTextName, String defaultValue) {
        return getTextProvider().getText(aTextName, defaultValue);
    }

    public String getText(String aTextName, String defaultValue, String obj) {
        return getTextProvider().getText(aTextName, defaultValue, obj);
    }

    public String getText(String aTextName, List<?> args) {
        return getTextProvider().getText(aTextName, args);
    }

    public String getText(String key, String[] args) {
        return getTextProvider().getText(key, args);
    }

    public String getText(String aTextName, String defaultValue, List<?> args) {
        return getTextProvider().getText(aTextName, defaultValue, args);
    }

    public String getText(String key, String defaultValue, String[] args) {
        return getTextProvider().getText(key, defaultValue, args);
    }

    public String getText(String key, String defaultValue, List<?> args, ValueStack stack) {
        return getTextProvider().getText(key, defaultValue, args, stack);
    }

    public String getText(String key, String defaultValue, String[] args, ValueStack stack) {
        return getTextProvider().getText(key, defaultValue, args, stack);
    }

    /**
     * Dedicated method to support I10N and conversion errors
     *
     * @param key message which contains formatting string
     * @param expr that should be formatted
     * @return formatted expr with format specified by key
     */
    public String getFormatted(String key, String expr) {
        Map<String, Object> conversionErrors = ActionContext.getContext().getConversionErrors();
        if (conversionErrors.containsKey(expr)) {
            String[] vals = (String[]) conversionErrors.get(expr);
            return vals[0];
        } else {
            final ValueStack valueStack = ActionContext.getContext().getValueStack();
            final Object val = valueStack.findValue(expr);
            return getText(key, Arrays.asList(val));
        }
    }

    public ResourceBundle getTexts() {
        return getTextProvider().getTexts();
    }

    public ResourceBundle getTexts(String aBundleName) {
        return getTextProvider().getTexts(aBundleName);
    }

    public void addActionError(String anErrorMessage) {
        validationAware.addActionError(anErrorMessage);
    }

    public void addActionMessage(String aMessage) {
        validationAware.addActionMessage(aMessage);
    }

    public void addFieldError(String fieldName, String errorMessage) {
        validationAware.addFieldError(fieldName, errorMessage);
    }

    public String input() throws Exception {
        return INPUT;
    }

    /**
     * A default implementation that does nothing an returns "success".
     * <p/>
     * Subclasses should override this method to provide their business logic.
     * <p/>
     * See also {@link com.opensymphony.xwork2.Action#execute()}.
     *
     * @return returns {@link #SUCCESS}
     * @throws Exception can be thrown by subclasses.
     */
    public String execute() throws Exception {
        return SUCCESS;
    }

    public boolean hasActionErrors() {
        return validationAware.hasActionErrors();
    }

    public boolean hasActionMessages() {
        return validationAware.hasActionMessages();
    }

    public boolean hasErrors() {
        return validationAware.hasErrors();
    }

    public boolean hasFieldErrors() {
        return validationAware.hasFieldErrors();
    }

    /**
     * Clears field errors. Useful for Continuations and other situations
     * where you might want to clear parts of the state on the same action.
     */
    public void clearFieldErrors() {
        validationAware.clearFieldErrors();
    }

    /**
     * Clears action errors. Useful for Continuations and other situations
     * where you might want to clear parts of the state on the same action.
     */
    public void clearActionErrors() {
        validationAware.clearActionErrors();
    }

    /**
     * Clears messages. Useful for Continuations and other situations
     * where you might want to clear parts of the state on the same action.
     */
    public void clearMessages() {
        validationAware.clearMessages();
    }

    /**
     * Clears all errors. Useful for Continuations and other situations
     * where you might want to clear parts of the state on the same action.
     */
    public void clearErrors() {
        validationAware.clearErrors();
    }

    /**
     * Clears all errors and messages. Useful for Continuations and other situations
     * where you might want to clear parts of the state on the same action.
     */
    public void clearErrorsAndMessages() {
        validationAware.clearErrorsAndMessages();
    }

    /**
     * A default implementation that validates nothing.
     * Subclasses should override this method to provide validations.
     */
    public void validate() {
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    /**
     * <!-- START SNIPPET: pause-method -->
     * Stops the action invocation immediately (by throwing a PauseException) and causes the action invocation to return
     * the specified result, such as {@link #SUCCESS}, {@link #INPUT}, etc.
     * <p/>
     * <p/>
     * The next time this action is invoked (and using the same continuation ID), the method will resume immediately
     * after where this method was called, with the entire call stack in the execute method restored.
     * <p/>
     * <p/>
     * Note: this method can <b>only</b> be called within the {@link #execute()} method.
     * <!-- END SNIPPET: pause-method -->
     *
     * @param result the result to return - the same type of return value in the {@link #execute()} method.
     */
    public void pause(String result) {
    }

    /**
     * If called first time it will create {@link com.opensymphony.xwork2.TextProviderFactory},
     * inject dependency (if {@link com.opensymphony.xwork2.inject.Container} is accesible) into in,
     * then will create new {@link com.opensymphony.xwork2.TextProvider} and store it in a field
     * for future references and at the returns reference to that field
     *
     * @return reference to field with TextProvider
     */
    private TextProvider getTextProvider() {
        if (textProvider == null) {
            TextProviderFactory tpf = new TextProviderFactory();
            if (container != null) {
                container.inject(tpf);
            }
            textProvider = tpf.createInstance(getClass(), this);
        }
        return textProvider;
    }

    @Inject
    public void setContainer(Container container) {
        this.container = container;
    }

}

com.opensymphony.xwork2.ValidationAware

/*
 * Copyright 2002-2007,2009 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.opensymphony.xwork2;

import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * ValidationAware classes can accept Action (class level) or field level error messages. Action level messages are kept
 * in a Collection. Field level error messages are kept in a Map from String field name to a List of field error msgs.
 *
 * @author plightbo
 */
public interface ValidationAware {

    /**
     * Set the Collection of Action-level String error messages.
     *
     * @param errorMessages Collection of String error messages
     */
    void setActionErrors(Collection<String> errorMessages);

    /**
     * Get the Collection of Action-level error messages for this action. Error messages should not
     * be added directly here, as implementations are free to return a new Collection or an
     * Unmodifiable Collection.
     *
     * @return Collection of String error messages
     */
    Collection<String> getActionErrors();

    /**
     * Set the Collection of Action-level String messages (not errors).
     *
     * @param messages Collection of String messages (not errors).
     */
    void setActionMessages(Collection<String> messages);

    /**
     * Get the Collection of Action-level messages for this action. Messages should not be added
     * directly here, as implementations are free to return a new Collection or an Unmodifiable
     * Collection.
     *
     * @return Collection of String messages
     */
    Collection<String> getActionMessages();

    /**
     * Set the field error map of fieldname (String) to Collection of String error messages.
     *
     * @param errorMap field error map
     */
    void setFieldErrors(Map<String, List<String>> errorMap);

    /**
     * Get the field specific errors associated with this action. Error messages should not be added
     * directly here, as implementations are free to return a new Collection or an Unmodifiable
     * Collection.
     *
     * @return Map with errors mapped from fieldname (String) to Collection of String error messages
     */
    Map<String, List<String>> getFieldErrors();

    /**
     * Add an Action-level error message to this Action.
     *
     * @param anErrorMessage  the error message
     */
    void addActionError(String anErrorMessage);

    /**
     * Add an Action-level message to this Action.
     *
     * @param aMessage  the message
     */
    void addActionMessage(String aMessage);

    /**
     * Add an error message for a given field.
     *
     * @param fieldName    name of field
     * @param errorMessage the error message
     */
    void addFieldError(String fieldName, String errorMessage);

    /**
     * Check whether there are any Action-level error messages.
     *
     * @return true if any Action-level error messages have been registered
     */
    boolean hasActionErrors();

    /**
     * Checks whether there are any Action-level messages.
     *
     * @return true if any Action-level messages have been registered
     */
    boolean hasActionMessages();

    /**
     * Checks whether there are any action errors or field errors.
     * <p/>
     * <b>Note</b>: that this does not have the same meaning as in WW 1.x.
     *
     * @return <code>(hasActionErrors() || hasFieldErrors())</code>
     */
    boolean hasErrors();

    /**
     * Check whether there are any field errors associated with this action.
     *
     * @return whether there are any field errors
     */
    boolean hasFieldErrors();

}

访问index.jsp，输入“abc”则出现错误，但是发现跳转到404错误页面（而且后台抛出了异常信息）：

修改struts.xml

        <action name="myAction" class="com.dx.actions.MyAction" method="save">
            <result>/success.jsp</result>
            <result name="input">/index.jsp</result>
        </action>

访问index.jsp，输入“abc”则出现错误，但是发现跳转到index.jsp页面（而且后台并没有抛出了异常信息）：

•  类型转换错误消息的定制：

1、作为默认的defaultStack拦截器栈的一员，com.opensymphony.xwork2.interceptor.ConversionErrorInterceptor

/*
 * Copyright 2002-2007,2009 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.opensymphony.xwork2.interceptor;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.ValidationAware;
import com.opensymphony.xwork2.conversion.impl.XWorkConverter;
import com.opensymphony.xwork2.util.ValueStack;
import org.apache.commons.lang3.StringEscapeUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * <!-- START SNIPPET: description -->
 * ConversionErrorInterceptor adds conversion errors from the ActionContext to the Action's field errors.
 *
 * <p/>
 * This interceptor adds any error found in the {@link ActionContext}'s conversionErrors map as a field error (provided
 * that the action implements {@link ValidationAware}). In addition, any field that contains a validation error has its
 * original value saved such that any subsequent requests for that value return the original value rather than the value
 * in the action. This is important because if the value "abc" is submitted and can't be converted to an int, we want to
 * display the original string ("abc") again rather than the int value (likely 0, which would make very little sense to
 * the user).
 *
 *
 * <!-- END SNIPPET: description -->
 *
 * <p/> <u>Interceptor parameters:</u>
 *
 * <!-- START SNIPPET: parameters -->
 *
 * <ul>
 *
 * <li>None</li>
 *
 * </ul>
 *
 * <!-- END SNIPPET: parameters -->
 *
 * <p/> <u>Extending the interceptor:</u>
 *
 * <p/>
 *
 * <!-- START SNIPPET: extending -->
 *
 * Because this interceptor is not web-specific, it abstracts the logic for whether an error should be added. This
 * allows for web-specific interceptors to use more complex logic in the {@link #shouldAddError} method for when a value
 * has a conversion error but is null or empty or otherwise indicates that the value was never actually entered by the
 * user.
 *
 * <!-- END SNIPPET: extending -->
 *
 * <p/> <u>Example code:</u>
 *
 * <pre>
 * <!-- START SNIPPET: example -->
 * &lt;action name="someAction" class="com.examples.SomeAction"&gt;
 *     &lt;interceptor-ref name="params"/&gt;
 *     &lt;interceptor-ref name="conversionError"/&gt;
 *     &lt;result name="success"&gt;good_result.ftl&lt;/result&gt;
 * &lt;/action&gt;
 * <!-- END SNIPPET: example -->
 * </pre>
 *
 * @author Jason Carreira
 */
public class ConversionErrorInterceptor extends AbstractInterceptor {

    public static final String ORIGINAL_PROPERTY_OVERRIDE = "original.property.override";

    protected Object getOverrideExpr(ActionInvocation invocation, Object value) {
        return escape(value);
    }

    protected String escape(Object value) {
        return "\"" + StringEscapeUtils.escapeJava(String.valueOf(value)) + "\"";
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {

        ActionContext invocationContext = invocation.getInvocationContext();
        Map<String, Object> conversionErrors = invocationContext.getConversionErrors();
        ValueStack stack = invocationContext.getValueStack();

        HashMap<Object, Object> fakie = null;

        for (Map.Entry<String, Object> entry : conversionErrors.entrySet()) {
            String propertyName = entry.getKey();
            Object value = entry.getValue();

            if (shouldAddError(propertyName, value)) {
                String message = XWorkConverter.getConversionErrorMessage(propertyName, stack);

                Object action = invocation.getAction();
                if (action instanceof ValidationAware) {
                    ValidationAware va = (ValidationAware) action;
                    va.addFieldError(propertyName, message);
                }

                if (fakie == null) {
                    fakie = new HashMap<Object, Object>();
                }

                fakie.put(propertyName, getOverrideExpr(invocation, value));
            }
        }

        if (fakie != null) {
            // if there were some errors, put the original (fake) values in place right before the result
            stack.getContext().put(ORIGINAL_PROPERTY_OVERRIDE, fakie);
            invocation.addPreResultListener(new PreResultListener() {
                public void beforeResult(ActionInvocation invocation, String resultCode) {
                    Map<Object, Object> fakie = (Map<Object, Object>) invocation.getInvocationContext().get(ORIGINAL_PROPERTY_OVERRIDE);

                    if (fakie != null) {
                        invocation.getStack().setExprOverrides(fakie);
                    }
                }
            });
        }
        return invocation.invoke();
    }

    protected boolean shouldAddError(String propertyName, Object value) {
        return true;
    }
}

拦截器负责添加与类型转化有关的错误（前提Action类必须实现了ValidationAware接口）和保存各请求参数的原始值。

2、若字段标签使用的不是Simple主题，则非法输入字段将导致有一条以下格式的出错信息：

Invalid field value for field "fieldName".

如果使用simple主题时，及不会出现提示错误信息：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <s:debug></s:debug>
    <s:form action="myAction" theme="simple">
        <s:textfield name="age" label="Age"></s:textfield>
        <s:submit label="提交"></s:submit>
    </s:form>
</body>
</html>

但输入“abc”时：

3、覆盖默认的出错信息：

-在对应的Action类所在的包中新建ActionClassName.properties文件，ClassName即为包含着输入字段的Action类的类名；

-在该属性文件中添加如下键值对：invalid.fieldvalue.fieldname=xxx

invalid.fieldvalue.age=错误的年龄格式

4、定制出错误的格式：

-每一条出错误都被打包在一个html span元素里，可以通过覆盖其行标为errorMessage的那个css样式改变出错误的格式；

-新建template.simple包，新建filederror.ftl文件，把struts2-core.jar下的template.simple下的filederror.ftl文件内容拷贝到新建的fielderror.ftl中，并对其进行编辑。

5、显示错误消息：如果simple主题，可以通过EL(${fieldError})或者<s:fielderror fieldName="fieldName"></s:fielderror>标签显示错误消息。

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <s:debug></s:debug>
    <s:form action="myAction" theme="simple">
        <s:textfield name="age" label="Age"></s:textfield>${fieldErrors.age[0]}*
        <s:fielderror fieldName="age"></s:fielderror>
        <s:submit label="提交"></s:submit>
    </s:form>
</body>
</html>

访问index.jsp，输入“abc”则出现错误，但是发现跳转到index.jsp页面：