Struts example source code file (PrefixMethodInvocationUtil.java)

This example Struts source code file (PrefixMethodInvocationUtil.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

class, class, default_invocation_methodname, default_invocation_methodname, empty_class_array, illegalaccessexception, log, method, nosuchmethodexception, object, object, prefixmethodinvocationutil, reflection, string, string

The Struts PrefixMethodInvocationUtil.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 com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.logging.LoggerFactory;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * A utility class for invoking prefixed methods in action class.
 * 
 * Interceptors that made use of this class are:
 * <ul>
 * 	 <li>DefaultWorkflowInterceptor
 *   <li>PrepareInterceptor
 * </ul>
 * 
 * <p/>
 * 
 * <!-- START SNIPPET: javadocDefaultWorkflowInterceptor -->
 * 
 * <b>In DefaultWorkflowInterceptor
 * <p>applies only when action implements {@link com.opensymphony.xwork2.Validateable}

 * <ol>
 *    <li>if the action class have validate{MethodName}(), it will be invoked
 *    <li>else if the action class have validateDo{MethodName}(), it will be invoked
 *    <li>no matter if 1] or 2] is performed, if alwaysInvokeValidate property of the interceptor is "true" (which is by default "true"), validate() will be invoked.
 * </ol>
 * 
 * <!-- END SNIPPET: javadocDefaultWorkflowInterceptor -->
 * 
 * 
 * <!-- START SNIPPET: javadocPrepareInterceptor -->
 * 
 * <b>In PrepareInterceptor
 * <p>Applies only when action implements Preparable

 * <ol>
 *    <li>if the action class have prepare{MethodName}(), it will be invoked
 *    <li>else if the action class have prepareDo(MethodName()}(), it will be invoked
 *    <li>no matter if 1] or 2] is performed, if alwaysinvokePrepare property of the interceptor is "true" (which is by default "true"), prepare() will be invoked.
 * </ol>
 * 
 * <!-- END SNIPPET: javadocPrepareInterceptor -->
 * 
 * @author Philip Luppens
 * @author tm_jee
 */
public class PrefixMethodInvocationUtil {
	
	private static final Logger LOG = LoggerFactory.getLogger(PrefixMethodInvocationUtil.class);

    private static final String DEFAULT_INVOCATION_METHODNAME = "execute";

    private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];

    /**
	 * This method will prefix <code>actionInvocation's ActionProxy's
	 * <code>method with prefixes before invoking the prefixed method.
	 * Order of the <code>prefixes is important, as this method will return once 
	 * a prefixed method is found in the action class.
	 * 
	 * <p/>
	 * 
	 * For example, with
	 * <pre>
	 *   invokePrefixMethod(actionInvocation, new String[] { "prepare", "prepareDo" });
	 * </pre>
	 * 
	 * Assuming <code>actionInvocation.getProxy(),getMethod() returns "submit", 
	 * the order of invocation would be as follows:-
	 * <ol>
	 *   <li>prepareSubmit()
	 *   <li>prepareDoSubmit()
	 * </ol>
	 * 
	 * If <code>prepareSubmit() exists, it will be invoked and this method 
	 * will return, <code>prepareDoSubmit() will NOT be invoked. 
	 * 
	 * <p/>
	 * 
	 * On the other hand, if <code>prepareDoSubmit() does not exists, and 
	 * <code>prepareDoSubmit() exists, it will be invoked.
	 * 
	 * <p/>
	 * 
	 * If none of those two methods exists, nothing will be invoked.
	 * 
	 * @param actionInvocation  the action invocation
	 * @param prefixes  prefixes for method names
	 * @throws InvocationTargetException is thrown if invocation of a method failed.
	 * @throws IllegalAccessException  is thrown if invocation of a method failed.
	 */
	public static void invokePrefixMethod(ActionInvocation actionInvocation, String[] prefixes) throws InvocationTargetException, IllegalAccessException {
		Object action = actionInvocation.getAction();
		
		String methodName = actionInvocation.getProxy().getMethod();
		
		if (methodName == null) {
			// if null returns (possible according to the docs), use the default execute 
	        methodName = DEFAULT_INVOCATION_METHODNAME;
		}
		
		Method method = getPrefixedMethod(prefixes, methodName, action);
		if (method != null) {
			method.invoke(action, new Object[0]);
		}
	}
	
	
	/**
	 * This method returns a {@link Method} in <code>action. The method 
	 * returned is found by searching for method in <code>action whose method name
	 * is equals to the result of appending each <code>prefixes
	 * to <code>methodName. Only the first method found will be returned, hence
	 * the order of <code>prefixes is important. If none is found this method
	 * will return null.
	 * 
	 * @param prefixes the prefixes to prefix the <code>methodName
	 * @param methodName the method name to be prefixed with <code>prefixes
	 * @param action the action class of which the prefixed method is to be search for.
	 * @return a {@link Method} if one is found, else <tt>null.
	 */
	public static Method getPrefixedMethod(String[] prefixes, String methodName, Object action) {
		assert(prefixes != null);
		String capitalizedMethodName = capitalizeMethodName(methodName);
        for (String prefixe : prefixes) {
            String prefixedMethodName = prefixe + capitalizedMethodName;
            try {
                return action.getClass().getMethod(prefixedMethodName, EMPTY_CLASS_ARRAY);
            }
            catch (NoSuchMethodException e) {
                // hmm -- OK, try next prefix
                if (LOG.isDebugEnabled()) {
                    LOG.debug("cannot find method [" + prefixedMethodName + "] in action [" + action + "]");
                }
            }
        }
		return null;
	}
	
	/**
	 * This method capitalized the first character of <code>methodName.
	 * <br/>
	 * eg. <code>capitalizeMethodName("someMethod"); will return "SomeMethod".
	 * 
	 * @param methodName the method name
	 * @return capitalized method name
	 */
	public static String capitalizeMethodName(String methodName) {
		assert(methodName != null);
		return methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
	}

}