* Note: Since 2.5.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. *
- * + * * * *Interceptor parameters:
@@ -85,7 +85,10 @@ * * * @author Jason Carreira + * + * @deprecated since 6.7.0, use {@link org.apache.struts2.interceptor.ConversionErrorInterceptor} instead. */ +@Deprecated public class ConversionErrorInterceptor extends MethodFilterInterceptor { public static final String ORIGINAL_PROPERTY_OVERRIDE = "original.property.override"; diff --git a/core/src/main/java/com/opensymphony/xwork2/interceptor/DefaultWorkflowInterceptor.java b/core/src/main/java/com/opensymphony/xwork2/interceptor/DefaultWorkflowInterceptor.java index 05749ae195..d238e1ceb3 100644 --- a/core/src/main/java/com/opensymphony/xwork2/interceptor/DefaultWorkflowInterceptor.java +++ b/core/src/main/java/com/opensymphony/xwork2/interceptor/DefaultWorkflowInterceptor.java @@ -32,7 +32,7 @@ /** * *- * An interceptor that makes sure there are not validation, conversion or action errors before allowing the interceptor chain to continue. + * An interceptor that makes sure there are not validation, conversion or action errors before allowing the interceptor chain to continue. * If a single FieldError or ActionError (including the ones replicated by the Message Store Interceptor in a redirection) is found, the INPUT result will be triggered. * This interceptor does not perform any validation. *
@@ -132,7 +132,10 @@ * @author Alexandru Popescu * @author Philip Luppens * @author tm_jee + * + * @deprecated since 6.7.0, use {@link org.apache.struts2.interceptor.DefaultWorkflowInterceptor} instead. */ +@Deprecated public class DefaultWorkflowInterceptor extends MethodFilterInterceptor { private static final long serialVersionUID = 7563014655616490865L; diff --git a/core/src/main/java/com/opensymphony/xwork2/interceptor/ExceptionMappingInterceptor.java b/core/src/main/java/com/opensymphony/xwork2/interceptor/ExceptionMappingInterceptor.java index e60550ca69..3bb70bcb8a 100644 --- a/core/src/main/java/com/opensymphony/xwork2/interceptor/ExceptionMappingInterceptor.java +++ b/core/src/main/java/com/opensymphony/xwork2/interceptor/ExceptionMappingInterceptor.java @@ -20,8 +20,8 @@ import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.config.entities.ExceptionMappingConfig; -import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import org.apache.struts2.dispatcher.HttpParameters; import java.util.List; @@ -153,7 +153,10 @@ * * @author Matthew E. Porter (matthew dot porter at metissian dot com) * @author Claus Ibsen + * + * @deprecated since 6.7.0, use {@link org.apache.struts2.interceptor.ExceptionMappingInterceptor} instead. */ +@Deprecated public class ExceptionMappingInterceptor extends AbstractInterceptor { private static final Logger LOG = LogManager.getLogger(ExceptionMappingInterceptor.class); diff --git a/core/src/main/java/com/opensymphony/xwork2/interceptor/LoggingInterceptor.java b/core/src/main/java/com/opensymphony/xwork2/interceptor/LoggingInterceptor.java index 6ba498b3cb..3f012288c2 100644 --- a/core/src/main/java/com/opensymphony/xwork2/interceptor/LoggingInterceptor.java +++ b/core/src/main/java/com/opensymphony/xwork2/interceptor/LoggingInterceptor.java @@ -59,7 +59,10 @@ * * * @author Jason Carreira + * + * @deprecated since 6.7.0, use {@link org.apache.struts2.interceptor.LoggingInterceptor} instead. */ +@Deprecated public class LoggingInterceptor extends AbstractInterceptor { private static final Logger LOG = LogManager.getLogger(LoggingInterceptor.class); private static final String FINISH_MESSAGE = "Finishing execution stack for action "; diff --git a/core/src/main/java/com/opensymphony/xwork2/interceptor/ModelDrivenInterceptor.java b/core/src/main/java/com/opensymphony/xwork2/interceptor/ModelDrivenInterceptor.java index f513deb1c6..84170b6696 100644 --- a/core/src/main/java/com/opensymphony/xwork2/interceptor/ModelDrivenInterceptor.java +++ b/core/src/main/java/com/opensymphony/xwork2/interceptor/ModelDrivenInterceptor.java @@ -71,10 +71,13 @@ * </action> * * - * + * * @author tm_jee * @version $Date$ $Id$ + * + * @deprecated since 6.7.0, use {@link org.apache.struts2.interceptor.ModelDrivenInterceptor} instead. */ +@Deprecated public class ModelDrivenInterceptor extends AbstractInterceptor { protected boolean refreshModelBeforeResult = false; diff --git a/core/src/main/java/com/opensymphony/xwork2/interceptor/ParameterRemoverInterceptor.java b/core/src/main/java/com/opensymphony/xwork2/interceptor/ParameterRemoverInterceptor.java index c0f83765c2..f33ebf6e27 100644 --- a/core/src/main/java/com/opensymphony/xwork2/interceptor/ParameterRemoverInterceptor.java +++ b/core/src/main/java/com/opensymphony/xwork2/interceptor/ParameterRemoverInterceptor.java @@ -66,7 +66,10 @@ * ... * </action> * + * + * @deprecated since 6.7.0, use {@link org.apache.struts2.interceptor.ParameterRemoverInterceptor} instead. */ +@Deprecated public class ParameterRemoverInterceptor extends AbstractInterceptor { private static final Logger LOG = LogManager.getLogger(ParameterRemoverInterceptor.class); diff --git a/core/src/main/java/com/opensymphony/xwork2/interceptor/PrefixMethodInvocationUtil.java b/core/src/main/java/com/opensymphony/xwork2/interceptor/PrefixMethodInvocationUtil.java index 040080824e..0ac840c7a8 100644 --- a/core/src/main/java/com/opensymphony/xwork2/interceptor/PrefixMethodInvocationUtil.java +++ b/core/src/main/java/com/opensymphony/xwork2/interceptor/PrefixMethodInvocationUtil.java @@ -19,8 +19,8 @@ package com.opensymphony.xwork2.interceptor; import com.opensymphony.xwork2.ActionInvocation; -import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -28,7 +28,7 @@ /** ** A utility class for invoking prefixed methods in action class. - * + * * Interceptors that made use of this class are: *
*applies only when action implements {@link com.opensymphony.xwork2.Validateable}
*Applies only when action implements Preparable
*
* This method will prefix actionInvocation's ActionProxy's
* method with prefixes before invoking the prefixed method.
- * Order of the prefixes is important, as this method will return once
+ * Order of the prefixes is important, as this method will return once
* a prefixed method is found in the action class.
*
- * Assuming actionInvocation.getProxy(),getMethod() returns "submit",
+ * Assuming actionInvocation.getProxy(),getMethod() returns "submit",
* the order of invocation would be as follows:-
*
- * If prepareSubmit() exists, it will be invoked and this method
- * will return, prepareDoSubmit() will NOT be invoked.
+ * If prepareSubmit() exists, it will be invoked and this method
+ * will return, prepareDoSubmit() will NOT be invoked.
*
- * On the other hand, if prepareDoSubmit() does not exists, and
+ * On the other hand, if prepareDoSubmit() does not exists, and
* prepareDoSubmit() exists, it will be invoked.
*
action. The method
+ * This method returns a {@link Method} in action. The method
* returned is found by searching for method in action whose method name
* is equals to the result of appending each prefixes
* to methodName. Only the first method found will be returned, hence
* the order of prefixes is important. If none is found this method
* will return null.
- *
+ *
* @param prefixes the prefixes to prefix the methodName
* @param methodName the method name to be prefixed with prefixes
* @param action the action class of which the prefixed method is to be search for.
@@ -162,7 +165,7 @@ public static Method getPrefixedMethod(String[] prefixes, String methodName, Obj
}
return null;
}
-
+
/**
*
* This method capitalized the first character of methodName.
diff --git a/core/src/main/java/com/opensymphony/xwork2/interceptor/PrepareInterceptor.java b/core/src/main/java/com/opensymphony/xwork2/interceptor/PrepareInterceptor.java
index e4d5af634f..43bb12c2b8 100644
--- a/core/src/main/java/com/opensymphony/xwork2/interceptor/PrepareInterceptor.java
+++ b/core/src/main/java/com/opensymphony/xwork2/interceptor/PrepareInterceptor.java
@@ -96,7 +96,10 @@
* @author Philip Luppens
* @author tm_jee
* @see com.opensymphony.xwork2.Preparable
+ *
+ * @deprecated since 6.7.0, use {@link org.apache.struts2.interceptor.PrepareInterceptor} instead.
*/
+@Deprecated
public class PrepareInterceptor extends MethodFilterInterceptor {
private static final long serialVersionUID = -5216969014510719786L;
diff --git a/core/src/main/java/com/opensymphony/xwork2/interceptor/ScopedModelDrivenInterceptor.java b/core/src/main/java/com/opensymphony/xwork2/interceptor/ScopedModelDrivenInterceptor.java
index ae2266be0e..03473034d1 100644
--- a/core/src/main/java/com/opensymphony/xwork2/interceptor/ScopedModelDrivenInterceptor.java
+++ b/core/src/main/java/com/opensymphony/xwork2/interceptor/ScopedModelDrivenInterceptor.java
@@ -36,7 +36,7 @@
*
*
This interceptor only activates on actions that implement the {@link ScopedModelDriven} interface. If * detected, it will retrieve the model class from the configured scope, then provide it to the Action.
- * + * * * *Interceptor parameters:
@@ -46,7 +46,7 @@ ** - * + * * <-- Basic usage --> * <interceptor name="scopedModelDriven" class="com.opensymphony.interceptor.ScopedModelDrivenInterceptor" /> - * + * * <-- Using all available parameters --> * <interceptor name="gangsterForm" class="com.opensymphony.interceptor.ScopedModelDrivenInterceptor"> * <param name="scope">session</param> * <param name="name">gangsterForm</param> * <param name="className">com.opensymphony.example.GangsterForm</param> * </interceptor> - * + * * *+ * + * @deprecated since 6.7.0, use {@link org.apache.struts2.interceptor.ScopedModelDrivenInterceptor} instead. */ +@Deprecated public class ScopedModelDrivenInterceptor extends AbstractInterceptor { private static final Class[] EMPTY_CLASS_ARRAY = new Class[0]; - + private static final String GET_MODEL = "getModel"; private String scope; private String name; private String className; private ObjectFactory objectFactory; - + @Inject public void setObjectFactory(ObjectFactory factory) { this.objectFactory = factory; } - + protected Object resolveModel(ObjectFactory factory, ActionContext actionContext, String modelClassName, String modelScope, String modelName) throws Exception { Object model; Map
Action's alias expressions should be in the form of #{ "name1" : "alias1", "name2" : "alias2" }.
+ * This means that assuming an action (or something else in the stack) has a value for the expression named name1 and the
+ * action this interceptor is applied to has a setter named alias1, alias1 will be set with the value from
+ * name1.
+ *
Interceptor parameters:
+ * + * + * + *Extending the interceptor:
+ * + * + * + * This interceptor does not have any known extension points. + * + * + * + *Example code:
+ * + *
+ *
+ * <action name="someAction" class="com.examples.SomeAction">
+ * <!-- The value for the foo parameter will be applied as if it were named bar -->
+ * <param name="aliases">#{ 'foo' : 'bar' }</param>
+ *
+ * <interceptor-ref name="alias"/>
+ * <interceptor-ref name="basicStack"/>
+ * <result name="success">good_result.ftl</result>
+ * </action>
+ *
+ *
+ *
+ * @author Matthew Payne
+ */
+public class AliasInterceptor extends AbstractInterceptor {
+
+ private static final Logger LOG = LogManager.getLogger(AliasInterceptor.class);
+
+ private static final String DEFAULT_ALIAS_KEY = "aliases";
+ protected String aliasesKey = DEFAULT_ALIAS_KEY;
+
+ protected ValueStackFactory valueStackFactory;
+ protected LocalizedTextProvider localizedTextProvider;
+ protected boolean devMode = false;
+
+ private ExcludedPatternsChecker excludedPatterns;
+ private AcceptedPatternsChecker acceptedPatterns;
+
+ @Inject(StrutsConstants.STRUTS_DEVMODE)
+ public void setDevMode(String mode) {
+ this.devMode = Boolean.parseBoolean(mode);
+ }
+
+ @Inject
+ public void setValueStackFactory(ValueStackFactory valueStackFactory) {
+ this.valueStackFactory = valueStackFactory;
+ }
+
+ @Inject
+ public void setLocalizedTextProvider(LocalizedTextProvider localizedTextProvider) {
+ this.localizedTextProvider = localizedTextProvider;
+ }
+
+ @Inject
+ public void setExcludedPatterns(ExcludedPatternsChecker excludedPatterns) {
+ this.excludedPatterns = excludedPatterns;
+ }
+
+ @Inject
+ public void setAcceptedPatterns(AcceptedPatternsChecker acceptedPatterns) {
+ this.acceptedPatterns = acceptedPatterns;
+ }
+
+ /**
+ * + * Sets the name of the action parameter to look for the alias map. + *
+ * + *
+ * Default is aliases.
+ *
+ * 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); + } + +} diff --git a/core/src/main/java/org/apache/struts2/interceptor/ChainingInterceptor.java b/core/src/main/java/org/apache/struts2/interceptor/ChainingInterceptor.java new file mode 100644 index 0000000000..fd3c25a65d --- /dev/null +++ b/core/src/main/java/org/apache/struts2/interceptor/ChainingInterceptor.java @@ -0,0 +1,275 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.struts2.interceptor; + +import com.opensymphony.xwork2.ActionChainResult; +import com.opensymphony.xwork2.inject.Inject; +import com.opensymphony.xwork2.util.CompoundRoot; +import com.opensymphony.xwork2.util.ProxyUtil; +import com.opensymphony.xwork2.util.TextParseUtil; +import com.opensymphony.xwork2.util.reflection.ReflectionProvider; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.struts2.ActionInvocation; +import org.apache.struts2.Result; +import org.apache.struts2.StrutsConstants; +import org.apache.struts2.Unchainable; +import org.apache.struts2.util.ValueStack; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Map; + + +/** + * + *+ * An interceptor that copies all the properties of every object in the value stack to the currently executing object, + * except for any object that implements {@link Unchainable}. A collection of optional includes and + * excludes may be provided to control how and which parameters are copied. Only includes or excludes may be + * specified. Specifying both results in undefined behavior. See the javadocs for {@link ReflectionProvider#copy(Object, Object, + * Map, Collection, Collection)} for more information. + *
+ * + *
+ * Note: It is important to remember that this interceptor does nothing if there are no objects already on the stack.
+ *
This means two things:
+ *
One, you can safely apply it to all your actions without any worry of adverse affects.
+ *
Two, it is up to you to ensure an object exists in the stack prior to invoking this action. The most typical way this is done
+ * is through the use of the chain result type, which combines with this interceptor to make up the action
+ * chaining feature.
+ *
+ * Note: By default Errors, Field errors and Message aren't copied during chaining, to change the behaviour you can specify + * the below three constants in struts.properties or struts.xml: + *
+ * + *+ * Example: + *
+ * + *+ * <constant name="struts.xwork.chaining.copyErrors" value="true"/> + *+ * + *
+ * Note: By default actionErrors and actionMessages are excluded when copping object's properties. + *
+ * + * Interceptor parameters: + * + *+ * There are no known extension points to this interceptor. + *
+ * + * Example code: + * + * + *+ * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="basicStack"/> + * <result name="success" type="chain">otherAction</result> + * </action> + *+ * + *
+ * <action name="otherAction" class="com.examples.OtherAction"> + * <interceptor-ref name="chain"/> + * <interceptor-ref name="basicStack"/> + * <result name="success">good_result.ftl</result> + * </action> + *+ * + * + * + * @author mrdon + * @author tm_jee ( tm_jee(at)yahoo.co.uk ) + * @see ActionChainResult + */ +public class ChainingInterceptor extends AbstractInterceptor { + + private static final Logger LOG = LogManager.getLogger(ChainingInterceptor.class); + + private static final String ACTION_ERRORS = "actionErrors"; + private static final String FIELD_ERRORS = "fieldErrors"; + private static final String ACTION_MESSAGES = "actionMessages"; + + private boolean copyMessages = false; + private boolean copyErrors = false; + private boolean copyFieldErrors = false; + + protected Collection
+ * This interceptor adds any error found in the {@link ActionContext}'s conversionErrors map as a field error (provided + * that the action implements {@link com.opensymphony.xwork2.interceptor.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). + *
+ * + *+ * Note: Since 2.5.2, this interceptor extends {@link com.opensymphony.xwork2.interceptor.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. + *
+ * + * + * + *Interceptor parameters:
+ * + * + * + *Extending the interceptor:
+ * + * + * + * 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. + * + * + * + *Example code:
+ * + *+ * + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="params"/> + * <interceptor-ref name="conversionError"/> + * <result name="success">good_result.ftl</result> + * </action> + * + *+ * + * @author Jason Carreira + */ +public class ConversionErrorInterceptor extends MethodFilterInterceptor { + + 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 doIntercept(ActionInvocation invocation) throws Exception { + + ActionContext invocationContext = invocation.getInvocationContext(); + Map
+ * An interceptor that makes sure there are not validation, conversion or action errors before allowing the interceptor chain to continue. + * If a single FieldError or ActionError (including the ones replicated by the Message Store Interceptor in a redirection) is found, the INPUT result will be triggered. + * This interceptor does not perform any validation. + *
+ * + *+ * This interceptor does nothing if the name of the method being invoked is specified in the excludeMethods + * parameter. excludeMethods accepts a comma-delimited list of method names. For example, requests to + * foo!input.action and foo!back.action will be skipped by this interceptor if you set the + * excludeMethods parameter to "input, back". + *
+ * + *+ * Note: As this method extends off MethodFilterInterceptor, it is capable of + * deciding if it is applicable only to selective methods in the action class. This is done by adding param tags + * for the interceptor element, naming either a list of excluded method names and/or a list of included method + * names, whereby includeMethods overrides excludedMethods. A single * sign is interpreted as wildcard matching + * all methods for both parameters. + * See {@link com.opensymphony.xwork2.interceptor.MethodFilterInterceptor} for more info. + *
+ * + *+ * This interceptor also supports the following interfaces which can implemented by actions: + *
+ * + *+ * You can also use InputConfig annotation to change result name returned when validation errors occurred. + *
+ * + * + * + *Interceptor parameters:
+ * + * + *Extending the interceptor:
+ * + * + * + *There are no known extension points for this interceptor.
+ * + * + * + *Example code:
+ * + *+ * + * + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="params"/> + * <interceptor-ref name="validation"/> + * <interceptor-ref name="workflow"/> + * <result name="success">good_result.ftl</result> + * </action> + * + * <-- In this case myMethod as well as mySecondMethod of the action class + * will not pass through the workflow process --> + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="params"/> + * <interceptor-ref name="validation"/> + * <interceptor-ref name="workflow"> + * <param name="excludeMethods">myMethod,mySecondMethod</param> + * </interceptor-ref name="workflow"> + * <result name="success">good_result.ftl</result> + * </action> + * + * <-- In this case, the result named "error" will be used when + * an action / field error is found --> + * <-- The Interceptor will only be applied for myWorkflowMethod method of action + * classes, since this is the only included method while any others are excluded --> + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="params"/> + * <interceptor-ref name="validation"/> + * <interceptor-ref name="workflow"> + * <param name="inputResultName">error</param> + * <param name="excludeMethods">*</param> + * <param name="includeMethods">myWorkflowMethod</param> + * </interceptor-ref> + * <result name="success">good_result.ftl</result> + * </action> + * + * + *+ * + * @author Jason Carreira + * @author Rainer Hermanns + * @author Alexandru Popescu + * @author Philip Luppens + * @author tm_jee + */ +public class DefaultWorkflowInterceptor extends MethodFilterInterceptor { + + private static final long serialVersionUID = 7563014655616490865L; + + private static final Logger LOG = LogManager.getLogger(DefaultWorkflowInterceptor.class); + + private static final Class[] EMPTY_CLASS_ARRAY = new Class[0]; + + private String inputResultName = Action.INPUT; + + /** + * Set the
inputResultName (result name to be returned when
+ * a action / field error is found registered). Default to {@link Action#INPUT}
+ *
+ * @param inputResultName what result name to use when there was validation error(s).
+ */
+ public void setInputResultName(String inputResultName) {
+ this.inputResultName = inputResultName;
+ }
+
+ /**
+ * Intercept {@link ActionInvocation} and returns a inputResultName
+ * when action / field errors is found registered.
+ *
+ * @param invocation the action invocation
+ * @return String result name
+ */
+ @Override
+ protected String doIntercept(ActionInvocation invocation) throws Exception {
+ Object action = invocation.getAction();
+
+ if (action instanceof ValidationAware) {
+ ValidationAware validationAwareAction = (ValidationAware) action;
+
+ if (validationAwareAction.hasErrors()) {
+ LOG.debug("Errors on action [{}], returning result name [{}]", validationAwareAction, inputResultName);
+
+ String resultName = inputResultName;
+ resultName = processValidationWorkflowAware(action, resultName);
+ resultName = processInputConfig(action, invocation.getProxy().getMethod(), resultName);
+ resultName = processValidationErrorAware(action, resultName);
+
+ return resultName;
+ }
+ }
+
+ return invocation.invoke();
+ }
+
+ /**
+ * Process {@link com.opensymphony.xwork2.interceptor.ValidationWorkflowAware} interface
+ *
+ * @param action action object
+ * @param currentResultName current result name
+ *
+ * @return result name
+ */
+ private String processValidationWorkflowAware(final Object action, final String currentResultName) {
+ String resultName = currentResultName;
+ if (action instanceof ValidationWorkflowAware) {
+ resultName = ((ValidationWorkflowAware) action).getInputResultName();
+ LOG.debug("Changing result name from [{}] to [{}] because of processing [{}] interface applied to [{}]",
+ currentResultName, resultName, ValidationWorkflowAware.class.getSimpleName(), action);
+ }
+ return resultName;
+ }
+
+ /**
+ * Process {@link InputConfig} annotation applied to method
+ * @param action action object
+ * @param method method
+ * @param currentResultName current result name
+ *
+ * @return result name
+ *
+ * @throws Exception in case of any errors
+ */
+ protected String processInputConfig(final Object action, final String method, final String currentResultName) throws Exception {
+ String resultName = currentResultName;
+ InputConfig annotation = MethodUtils.getAnnotation(action.getClass().getMethod(method, EMPTY_CLASS_ARRAY),
+ InputConfig.class ,true,true);
+ if (annotation != null) {
+ if (StringUtils.isNotEmpty(annotation.methodName())) {
+ resultName = (String) MethodUtils.invokeMethod(action, true, annotation.methodName());
+ } else {
+ resultName = annotation.resultName();
+ }
+ LOG.debug("Changing result name from [{}] to [{}] because of processing annotation [{}] on action [{}]",
+ currentResultName, resultName, InputConfig.class.getSimpleName(), action);
+ }
+ return resultName;
+ }
+
+ /**
+ * Notify action if it implements {@link com.opensymphony.xwork2.interceptor.ValidationErrorAware} interface
+ *
+ * @param action action object
+ * @param currentResultName current result name
+ *
+ * @return result name
+ * @see com.opensymphony.xwork2.interceptor.ValidationErrorAware
+ */
+ protected String processValidationErrorAware(final Object action, final String currentResultName) {
+ String resultName = currentResultName;
+ if (action instanceof ValidationErrorAware) {
+ resultName = ((ValidationErrorAware) action).actionErrorOccurred(currentResultName);
+ LOG.debug("Changing result name from [{}] to [{}] because of processing interface [{}] on action [{}]",
+ currentResultName, resultName, ValidationErrorAware.class.getSimpleName(), action);
+ }
+ return resultName;
+ }
+
+}
diff --git a/core/src/main/java/org/apache/struts2/interceptor/ExceptionMappingInterceptor.java b/core/src/main/java/org/apache/struts2/interceptor/ExceptionMappingInterceptor.java
new file mode 100644
index 0000000000..277fc33dfc
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/interceptor/ExceptionMappingInterceptor.java
@@ -0,0 +1,324 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.struts2.interceptor;
+
+import com.opensymphony.xwork2.config.entities.ExceptionMappingConfig;
+import com.opensymphony.xwork2.interceptor.ExceptionHolder;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ActionInvocation;
+import org.apache.struts2.dispatcher.HttpParameters;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * + * This interceptor forms the core functionality of the exception handling feature. Exception handling allows you to map + * an exception to a result code, just as if the action returned a result code instead of throwing an unexpected + * exception. When an exception is encountered, it is wrapped with an {@link ExceptionHolder} and pushed on the stack, + * providing easy access to the exception from within your result. + *
+ * + *+ * Note: While you can configure exception mapping in your configuration file at any point, the configuration + * will not have any effect if this interceptor is not in the interceptor stack for your actions. It is recommended that + * you make this interceptor the first interceptor on the stack, ensuring that it has full access to catch any + * exception, even those caused by other interceptors. + *
+ * + * + * + *Interceptor parameters:
+ * + * + * + *trace, debug, info, warn, error, fatal)? - defaut is debugcom.mycompany.app).
+ * Default is to use com.opensymphony.xwork2.interceptor.ExceptionMappingInterceptor.+ * The parameters above enables us to log all thrown exceptions with stacktace in our own logfile, + * and present a friendly webpage (with no stacktrace) to the end user. + *
+ * + * + * + *Extending the interceptor:
+ * + * + *+ * If you want to add custom handling for publishing the Exception, you may override + * {@link #publishException(ActionInvocation, ExceptionHolder)}. The default implementation + * pushes the given ExceptionHolder on value stack. A custom implementation could add additional logging etc. + *
+ * + * + *Example code:
+ * + *+ * + * <xwork> + * <package name="default" extends="xwork-default"> + * <global-results> + * <result name="error" type="freemarker">error.ftl</result> + * </global-results> + * + * <global-exception-mappings> + * <exception-mapping exception="java.lang.Exception" result="error"/> + * </global-exception-mappings> + * + * <action name="test"> + * <interceptor-ref name="exception"/> + * <interceptor-ref name="basicStack"/> + * <exception-mapping exception="com.acme.CustomException" result="custom_error"/> + * <result name="custom_error">custom_error.ftl</result> + * <result name="success" type="freemarker">test.ftl</result> + * </action> + * </package> + * </xwork> + * + *+ * + *
+ * This second example will also log the exceptions using our own category
+ * com.mycompany.app.unhandled at WARN level.
+ *
+ * + * <xwork> + * <package name="something" extends="xwork-default"> + * <interceptors> + * <interceptor-stack name="exceptionmappingStack"> + * <interceptor-ref name="exception"> + * <param name="logEnabled">true</param> + * <param name="logCategory">com.mycompany.app.unhandled</param> + * <param name="logLevel">WARN</param> + * </interceptor-ref> + * <interceptor-ref name="i18n"/> + * <interceptor-ref name="staticParams"/> + * <interceptor-ref name="params"/> + * <interceptor-ref name="validation"> + * <param name="excludeMethods">input,back,cancel,browse</param> + * </interceptor-ref> + * </interceptor-stack> + * </interceptors> + * + * <default-interceptor-ref name="exceptionmappingStack"/> + * + * <global-results> + * <result name="unhandledException">/unhandled-exception.jsp</result> + * </global-results> + * + * <global-exception-mappings> + * <exception-mapping exception="java.lang.Exception" result="unhandledException"/> + * </global-exception-mappings> + * + * <action name="exceptionDemo" class="org.apache.struts2.showcase.exceptionmapping.ExceptionMappingAction"> + * <exception-mapping exception="org.apache.struts2.showcase.exceptionmapping.ExceptionMappingException" + * result="damm"/> + * <result name="input">index.jsp</result> + * <result name="success">success.jsp</result> + * <result name="damm">damm.jsp</result> + * </action> + * + * </package> + * </xwork> + * + *+ * + * @author Matthew E. Porter (matthew dot porter at metissian dot com) + * @author Claus Ibsen + */ +public class ExceptionMappingInterceptor extends AbstractInterceptor { + + private static final Logger LOG = LogManager.getLogger(ExceptionMappingInterceptor.class); + + protected Logger categoryLogger; + protected boolean logEnabled = false; + protected String logCategory; + protected String logLevel; + + + public boolean isLogEnabled() { + return logEnabled; + } + + public void setLogEnabled(boolean logEnabled) { + this.logEnabled = logEnabled; + } + + public String getLogCategory() { + return logCategory; + } + + public void setLogCategory(String logCatgory) { + this.logCategory = logCatgory; + } + + public String getLogLevel() { + return logLevel; + } + + public void setLogLevel(String logLevel) { + this.logLevel = logLevel; + } + + @Override + public String intercept(ActionInvocation invocation) throws Exception { + String result; + + try { + result = invocation.invoke(); + } catch (Exception e) { + if (isLogEnabled()) { + handleLogging(e); + } + List
+ * This interceptor logs the start and end of the execution an action (in English-only, not internationalized).
+ *
+ * Note:: This interceptor will log at INFO level.
+ *
+ * + * <!-- prints out a message before and after the immediate action execution --> + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="completeStack"/> + * <interceptor-ref name="logger"/> + * <result name="success">good_result.ftl</result> + * </action> + * + * <!-- prints out a message before any more interceptors continue and after they have finished --> + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="logger"/> + * <interceptor-ref name="completeStack"/> + * <result name="success">good_result.ftl</result> + * </action> + * + *+ * + * @author Jason Carreira + */ +public class LoggingInterceptor extends AbstractInterceptor { + private static final Logger LOG = LogManager.getLogger(LoggingInterceptor.class); + private static final String FINISH_MESSAGE = "Finishing execution stack for action "; + private static final String START_MESSAGE = "Starting execution stack for action "; + + @Override + public String intercept(ActionInvocation invocation) throws Exception { + logMessage(invocation, START_MESSAGE); + String result = invocation.invoke(); + logMessage(invocation, FINISH_MESSAGE); + return result; + } + + private void logMessage(ActionInvocation invocation, String baseMessage) { + if (LOG.isInfoEnabled()) { + StringBuilder message = new StringBuilder(baseMessage); + String namespace = invocation.getProxy().getNamespace(); + + if ((namespace != null) && (namespace.trim().length() > 0)) { + message.append(namespace).append("/"); + } + + message.append(invocation.getProxy().getActionName()); + LOG.info(message.toString()); + } + } + +} diff --git a/core/src/main/java/org/apache/struts2/interceptor/ModelDrivenInterceptor.java b/core/src/main/java/org/apache/struts2/interceptor/ModelDrivenInterceptor.java new file mode 100644 index 0000000000..d2679ebd68 --- /dev/null +++ b/core/src/main/java/org/apache/struts2/interceptor/ModelDrivenInterceptor.java @@ -0,0 +1,148 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.struts2.interceptor; + +import com.opensymphony.xwork2.util.CompoundRoot; +import org.apache.struts2.ActionInvocation; +import org.apache.struts2.ModelDriven; +import org.apache.struts2.interceptor.parameter.ParametersInterceptor; +import org.apache.struts2.util.ValueStack; + +/** + * + * + * Watches for {@link ModelDriven} actions and adds the action's model on to the value stack. + * + *
Note: The ModelDrivenInterceptor must come before the both {@link StaticParametersInterceptor} and + * {@link ParametersInterceptor} if you want the parameters to be applied to the model. + *
+ *Note: The ModelDrivenInterceptor will only push the model into the stack when the + * model is not null, else it will be ignored. + *
+ * + * + * + *Interceptor parameters:
+ * + * + * + *Extending the interceptor:
+ * + * + * + * There are no known extension points to this interceptor. + * + * + * + *Example code:
+ * + *+ * + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="modelDriven"/> + * <interceptor-ref name="basicStack"/> + * <result name="success">good_result.ftl</result> + * </action> + * + *+ * + * @author tm_jee + * @version $Date$ $Id$ + */ +public class ModelDrivenInterceptor extends AbstractInterceptor { + + protected boolean refreshModelBeforeResult = false; + + public void setRefreshModelBeforeResult(boolean val) { + this.refreshModelBeforeResult = val; + } + + @Override + public String intercept(ActionInvocation invocation) throws Exception { + Object action = invocation.getAction(); + + if (action instanceof ModelDriven) { + ModelDriven modelDriven = (ModelDriven) action; + ValueStack stack = invocation.getStack(); + Object model = modelDriven.getModel(); + if (model != null) { + stack.push(model); + } + if (refreshModelBeforeResult) { + invocation.addPreResultListener(new RefreshModelBeforeResult(modelDriven, model)); + } + } + return invocation.invoke(); + } + + /** + * Refreshes the model instance on the value stack, if it has changed + */ + protected static class RefreshModelBeforeResult implements PreResultListener { + private Object originalModel; + protected ModelDriven action; + + + public RefreshModelBeforeResult(ModelDriven action, Object model) { + this.originalModel = model; + this.action = action; + } + + public void beforeResult(ActionInvocation invocation, String resultCode) { + ValueStack stack = invocation.getStack(); + CompoundRoot root = stack.getRoot(); + + boolean needsRefresh = true; + Object newModel = action.getModel(); + + // Check to see if the new model instance is already on the stack + if (newModel != null) { + for (Object item : root) { + if (item == newModel) { + needsRefresh = false; + break; + } + } + } + + // Add the new model on the stack + if (needsRefresh) { + + // Clear off the old model instance + if (originalModel != null) { + root.remove(originalModel); + } + if (newModel != null) { + stack.push(newModel); + } + } + } + } +} diff --git a/core/src/main/java/org/apache/struts2/interceptor/ParameterRemoverInterceptor.java b/core/src/main/java/org/apache/struts2/interceptor/ParameterRemoverInterceptor.java new file mode 100644 index 0000000000..ad72d58530 --- /dev/null +++ b/core/src/main/java/org/apache/struts2/interceptor/ParameterRemoverInterceptor.java @@ -0,0 +1,124 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.struts2.interceptor; + +import com.opensymphony.xwork2.util.TextParseUtil; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.struts2.ActionContext; +import org.apache.struts2.ActionInvocation; +import org.apache.struts2.action.NoParameters; +import org.apache.struts2.dispatcher.HttpParameters; +import org.apache.struts2.dispatcher.Parameter; + +import java.util.Collections; +import java.util.Set; + +/** + * This is a simple XWork interceptor that allows parameters (matching + * one of the paramNames attribute csv value) to be + * removed from the parameter map if they match a certain value + * (matching one of the paramValues attribute csv value), before they + * are set on the action. A typical usage would be to want a dropdown/select + * to map onto a boolean value on an action. The select had the options + * none, yes and no with values -1, true and false. The true and false would + * map across correctly. However the -1 would be set to false. + * This was not desired as one might needed the value on the action to stay null. + * This interceptor fixes this by preventing the parameter from ever reaching + * the action. + * + *
+ * No intended extension point + * + *
+ * <action name="sample" class="org.martingilday.Sample"> + * <interceptor-ref name="paramRemover"> + * <param name="paramNames">aParam,anotherParam</param> + * <param name="paramValues">--,-1</param> + * </interceptor-ref> + * <interceptor-ref name="defaultStack" /> + * ... + * </action> + *+ */ +public class ParameterRemoverInterceptor extends AbstractInterceptor { + + private static final Logger LOG = LogManager.getLogger(ParameterRemoverInterceptor.class); + + private Set
paramNames and paramValues.
+ *
+ * @see AbstractInterceptor
+ */
+ @Override
+ public String intercept(ActionInvocation invocation) throws Exception {
+ if (!(invocation.getAction() instanceof NoParameters)
+ && (null != this.paramNames)) {
+ ActionContext ac = invocation.getInvocationContext();
+ HttpParameters parameters = ac.getParameters();
+
+ if (parameters != null) {
+ for (String removeName : paramNames) {
+ try {
+ Parameter parameter = parameters.get(removeName);
+ if (parameter.isDefined() && this.paramValues.contains(parameter.getValue())) {
+ parameters.remove(removeName);
+ }
+ } catch (Exception e) {
+ LOG.error("Failed to convert parameter to string", e);
+ }
+ }
+ }
+ }
+ return invocation.invoke();
+ }
+
+ /**
+ * Allows paramNames attribute to be set as comma-separated-values (csv).
+ *
+ * @param paramNames the paramNames to set
+ */
+ public void setParamNames(String paramNames) {
+ this.paramNames = TextParseUtil.commaDelimitedStringToSet(paramNames);
+ }
+
+ /**
+ * Allows paramValues attribute to be set as a comma-separated-values (csv).
+ *
+ * @param paramValues the paramValues to set
+ */
+ public void setParamValues(String paramValues) {
+ this.paramValues = TextParseUtil.commaDelimitedStringToSet(paramValues);
+ }
+
+}
diff --git a/core/src/main/java/org/apache/struts2/interceptor/PrepareInterceptor.java b/core/src/main/java/org/apache/struts2/interceptor/PrepareInterceptor.java
new file mode 100644
index 0000000000..dd54045f41
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/interceptor/PrepareInterceptor.java
@@ -0,0 +1,177 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.struts2.interceptor;
+
+import org.apache.struts2.Preparable;
+import com.opensymphony.xwork2.interceptor.PrefixMethodInvocationUtil;
+import org.apache.struts2.ActionInvocation;
+
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ *
+ *
+ * This interceptor calls prepare() on actions which implement
+ * {@link Preparable}. This interceptor is very useful for any situation where
+ * you need to ensure some logic runs before the actual execute method runs.
+ *
+ * + * A typical use of this is to run some logic to load an object from the + * database so that when parameters are set they can be set on this object. For + * example, suppose you have a User object with two properties: id and + * name. Provided that the params interceptor is called twice (once + * before and once after this interceptor), you can load the User object using + * the id property, and then when the second params interceptor is called the + * parameter user.name will be set, as desired, on the actual object + * loaded from the database. See the example for more info. + *
+ *+ * Note: Since XWork 2.0.2, this interceptor extends {@link com.opensymphony.xwork2.interceptor.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. + *
+ * + *+ * Update: Added logic to execute a prepare{MethodName} and conditionally + * the a general prepare() Method, depending on the 'alwaysInvokePrepare' parameter/property + * which is by default true. This allows us to run some logic based on the method + * name we specify in the {@link com.opensymphony.xwork2.ActionProxy}. For example, you can specify a + * prepareInput() method that will be run before the invocation of the input method. + *
+ * + * + * + *Interceptor parameters:
+ * + * + * + *Extending the interceptor:
+ * + * + * + * There are no known extension points to this interceptor. + * + * + * + *Example code:
+ * + *+ * + * <!-- Calls the params interceptor twice, allowing you to + * pre-load data for the second time parameters are set --> + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="params"/> + * <interceptor-ref name="prepare"/> + * <interceptor-ref name="basicStack"/> + * <result name="success">good_result.ftl</result> + * </action> + * + *+ * + * @author Jason Carreira + * @author Philip Luppens + * @author tm_jee + * @see Preparable + */ +public class PrepareInterceptor extends MethodFilterInterceptor { + + private static final long serialVersionUID = -5216969014510719786L; + + private final static String PREPARE_PREFIX = "prepare"; + private final static String ALT_PREPARE_PREFIX = "prepareDo"; + + private boolean alwaysInvokePrepare = true; + private boolean firstCallPrepareDo = false; + + /** + * Sets if the
prepare method should always be executed.
+ * + * Default is true. + *
+ * + * @param alwaysInvokePrepare ifprepare should always be executed or not.
+ */
+ public void setAlwaysInvokePrepare(String alwaysInvokePrepare) {
+ this.alwaysInvokePrepare = Boolean.parseBoolean(alwaysInvokePrepare);
+ }
+
+ /**
+ * Sets if the prepareDoXXX method should be called first
+ * + * Default is false for backward compatibility + *
+ * @param firstCallPrepareDo ifprepareDoXXX should be called first
+ */
+ public void setFirstCallPrepareDo(String firstCallPrepareDo) {
+ this.firstCallPrepareDo = Boolean.parseBoolean(firstCallPrepareDo);
+ }
+
+ @Override
+ public String doIntercept(ActionInvocation invocation) throws Exception {
+ Object action = invocation.getAction();
+
+ if (action instanceof Preparable) {
+ try {
+ String[] prefixes;
+ if (firstCallPrepareDo) {
+ prefixes = new String[] {ALT_PREPARE_PREFIX, PREPARE_PREFIX};
+ } else {
+ prefixes = new String[] {PREPARE_PREFIX, ALT_PREPARE_PREFIX};
+ }
+ PrefixMethodInvocationUtil.invokePrefixMethod(invocation, prefixes);
+ }
+ catch (InvocationTargetException e) {
+ /*
+ * The invoked method threw an exception and reflection wrapped it
+ * in an InvocationTargetException.
+ * If possible re-throw the original exception so that normal
+ * exception handling will take place.
+ */
+ Throwable cause = e.getCause();
+ if (cause instanceof Exception) {
+ throw (Exception) cause;
+ } else if(cause instanceof Error) {
+ throw (Error) cause;
+ } else {
+ /*
+ * The cause is not an Exception or Error (must be Throwable) so
+ * just re-throw the wrapped exception.
+ */
+ throw e;
+ }
+ }
+
+ if (alwaysInvokePrepare) {
+ ((Preparable) action).prepare();
+ }
+ }
+
+ return invocation.invoke();
+ }
+
+}
diff --git a/core/src/main/java/org/apache/struts2/interceptor/ScopedModelDrivenInterceptor.java b/core/src/main/java/org/apache/struts2/interceptor/ScopedModelDrivenInterceptor.java
new file mode 100644
index 0000000000..181f560dce
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/interceptor/ScopedModelDrivenInterceptor.java
@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.struts2.interceptor;
+
+import com.opensymphony.xwork2.ObjectFactory;
+import com.opensymphony.xwork2.config.entities.ActionConfig;
+import com.opensymphony.xwork2.inject.Inject;
+import org.apache.struts2.ActionContext;
+import org.apache.struts2.ActionInvocation;
+import org.apache.struts2.StrutsException;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+
+/**
+ *
+ *
+ * An interceptor that enables scoped model-driven actions.
+ *
+ * This interceptor only activates on actions that implement the {@link com.opensymphony.xwork2.interceptor.ScopedModelDriven} interface. If + * detected, it will retrieve the model class from the configured scope, then provide it to the Action.
+ * + * + * + *Interceptor parameters:
+ * + * + * + *Extending the interceptor:
+ * + * + * + * There are no known extension points for this interceptor. + * + * + * + *Example code:
+ * + *+ * + * + * <-- Basic usage --> + * <interceptor name="scopedModelDriven" class="com.opensymphony.interceptor.ScopedModelDrivenInterceptor" /> + * + * <-- Using all available parameters --> + * <interceptor name="gangsterForm" class="com.opensymphony.interceptor.ScopedModelDrivenInterceptor"> + * <param name="scope">session</param> + * <param name="name">gangsterForm</param> + * <param name="className">com.opensymphony.example.GangsterForm</param> + * </interceptor> + * + * + *+ */ +public class ScopedModelDrivenInterceptor extends AbstractInterceptor { + + private static final Class[] EMPTY_CLASS_ARRAY = new Class[0]; + + private static final String GET_MODEL = "getModel"; + private String scope; + private String name; + private String className; + private ObjectFactory objectFactory; + + @Inject + public void setObjectFactory(ObjectFactory factory) { + this.objectFactory = factory; + } + + protected Object resolveModel(ObjectFactory factory, ActionContext actionContext, String modelClassName, String modelScope, String modelName) throws Exception { + Object model; + Map
Parameters are typically defined with <param> elements within xwork.xml.
+ * + * + * + *Interceptor parameters:
+ * + * + * + *Extending the interceptor:
+ * + * + * + *There are no extension points to this interceptor.
+ * + * + * + *Example code:
+ * + *+ * + * <action name="someAction" class="com.examples.SomeAction"> + * <interceptor-ref name="staticParams"> + * <param name="parse">true</param> + * <param name="overwrite">false</param> + * </interceptor-ref> + * <result name="success">good_result.ftl</result> + * </action> + * + *+ * + * @author Patrick Lightbody + */ +public class StaticParametersInterceptor extends AbstractInterceptor { + + private boolean parse; + private boolean overwrite; + private boolean merge = true; + private boolean devMode = false; + + private static final Logger LOG = LogManager.getLogger(StaticParametersInterceptor.class); + + private ValueStackFactory valueStackFactory; + private LocalizedTextProvider localizedTextProvider; + + @Inject + public void setValueStackFactory(ValueStackFactory valueStackFactory) { + this.valueStackFactory = valueStackFactory; + } + + @Inject(StrutsConstants.STRUTS_DEVMODE) + public void setDevMode(String mode) { + devMode = BooleanUtils.toBoolean(mode); + } + + @Inject + public void setLocalizedTextProvider(LocalizedTextProvider localizedTextProvider) { + this.localizedTextProvider = localizedTextProvider; + } + + public void setParse(String value) { + this.parse = BooleanUtils.toBoolean(value); + } + + public void setMerge(String value) { + this.merge = BooleanUtils.toBoolean(value); + } + + /** + * Overwrites already existing parameters from other sources. + * Static parameters are the successor over previously set parameters, if true. + * + * @param value enable overwrites of already existing parameters from other sources + */ + public void setOverwrite(String value) { + this.overwrite = BooleanUtils.toBoolean(value); + } + + @Override + public String intercept(ActionInvocation invocation) throws Exception { + ActionConfig config = invocation.getProxy().getConfig(); + Object action = invocation.getAction(); + + final Map