Struts example source code file (Interceptor.java)

This example Struts source code file (Interceptor.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Struts tags/keywords

exception, exception, interceptor, interceptor, io, serializable, serializable, string, string

The Struts Interceptor.java source code

/*
 * 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.interceptor;

import com.opensymphony.xwork2.ActionInvocation;

import java.io.Serializable;


/**
 * <!-- START SNIPPET: introduction -->
 * <p/>
 * An interceptor is a stateless class that follows the interceptor pattern, as
 * found in {@link  javax.servlet.Filter} and in AOP languages.
 * <p/>
 * <p/>
 * <p/>
 * Interceptors are objects that dynamically intercept Action invocations.
 * They provide the developer with the opportunity to define code that can be executed
 * before and/or after the execution of an action. They also have the ability
 * to prevent an action from executing. Interceptors provide developers a way to
 * encapulate common functionality in a re-usable form that can be applied to
 * one or more Actions.
 * <p/>
 * <p/>
 * <p/>
 * Interceptors <b>must be stateless and not assume that a new instance will be created for each request or Action.
 * Interceptors may choose to either short-circuit the {@link ActionInvocation} execution and return a return code
 * (such as {@link com.opensymphony.xwork2.Action#SUCCESS}), or it may choose to do some processing before
 * and/or after delegating the rest of the procesing using {@link ActionInvocation#invoke()}.
 * <p/>
 * <!-- END SNIPPET: introduction -->
 * <p/>
 * <p/>
 * <p/>
 * <!-- START SNIPPET: parameterOverriding -->
 * <p/>
 * Interceptor's parameter could be overriden through the following ways :-
 * <p/>
 * <p/>
 * <p/>
 * <b>Method 1:
 * <pre>
 * <action name="myAction" class="myActionClass">
 *     <interceptor-ref name="exception"/>
 *     <interceptor-ref name="alias"/>
 *     <interceptor-ref name="params"/>
 *     <interceptor-ref name="servletConfig"/>
 *     <interceptor-ref name="prepare"/>
 *     <interceptor-ref name="i18n"/>
 *     <interceptor-ref name="chain"/>
 *     <interceptor-ref name="modelDriven"/>
 *     <interceptor-ref name="fileUpload"/>
 *     <interceptor-ref name="staticParams"/>
 *     <interceptor-ref name="params"/>
 *     <interceptor-ref name="conversionError"/>
 *     <interceptor-ref name="validation">
 *     <param name="excludeMethods">myValidationExcudeMethod</param>
 *     </interceptor-ref>
 *     <interceptor-ref name="workflow">
 *     <param name="excludeMethods">myWorkflowExcludeMethod</param>
 *     </interceptor-ref>
 * </action>
 * </pre>
 * <p/>
 * <b>Method 2:
 * <pre>
 * <action name="myAction" class="myActionClass">
 *   <interceptor-ref name="defaultStack">
 *     <param name="validation.excludeMethods">myValidationExcludeMethod</param>
 *     <param name="workflow.excludeMethods">myWorkflowExcludeMethod</param>
 *   </interceptor-ref>
 * </action>
 * </pre>
 * <p/>
 * <p/>
 * <p/>
 * In the first method, the whole default stack is copied and the parameter then
 * changed accordingly.
 * <p/>
 * <p/>
 * <p/>
 * In the second method, the 'interceptor-ref' refer to an existing
 * interceptor-stack, namely defaultStack in this example, and override the validator
 * and workflow interceptor excludeMethods typically in this case. Note that in the
 * 'param' tag, the name attribute contains a dot (.) the word before the dot(.)
 * specifies the interceptor name whose parameter is to be overridden and the word after
 * the dot (.) specifies the parameter itself. Essetially it is as follows :-
 * <p/>
 * <pre>
 *    <interceptor-name>.<parameter-name>
 * </pre>
 * <p/>
 * <b>Note also that in this case the 'interceptor-ref' name attribute
 * is used to indicate an interceptor stack which makes sense as if it is referring
 * to the interceptor itself it would be just using Method 1 describe above.
 * <p/>
 * <!-- END SNIPPET: parameterOverriding -->
 * <p/>
 * <p/>
 * <b>Nested Interceptor param overriding
 * <p/>
 * <!-- START SNIPPET: nestedParameterOverriding -->
 * <p/>
 * Interceptor stack parameter overriding could be nested into as many level as possible, though it would
 * be advisable not to nest it too deep as to avoid confusion, For example,
 * <pre>
 * <interceptor name="interceptor1" class="foo.bar.Interceptor1" />
 * <interceptor name="interceptor2" class="foo.bar.Interceptor2" />
 * <interceptor name="interceptor3" class="foo.bar.Interceptor3" />
 * <interceptor name="interceptor4" class="foo.bar.Interceptor4" />
 * <interceptor-stack name="stack1">
 *     <interceptor-ref name="interceptor1" />
 * </interceptor-stack>
 * <interceptor-stack name="stack2">
 *     <interceptor-ref name="intercetor2" />
 *     <interceptor-ref name="stack1" />
 * </interceptor-stack>
 * <interceptor-stack name="stack3">
 *     <interceptor-ref name="interceptor3" />
 *     <interceptor-ref name="stack2" />
 * </interceptor-stack>
 * <interceptor-stack name="stack4">
 *     <interceptor-ref name="interceptor4" />
 *     <interceptor-ref name="stack3" />
 *  </interceptor-stack>
 * </pre>
 * Assuming the interceptor has the following properties
 * <table border="1" width="100%">
 * <tr>
 * <td>Interceptor