com.opensymphony.xwork2.interceptor.PrefixMethodInvocationUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of xwork Show documentation
XWork is an command-pattern framework that is used to power WebWork as well as other applications. XWork provides an Inversion of Control container, a powerful expression language, data type conversion, validation, and pluggable configuration.
There is a newer version: 2.1.3
Show newest version
/*
 * Copyright (c) 2002-2006 by OpenSymphony
 * All rights reserved.
 */
package com.opensymphony.xwork2.interceptor;

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

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.logging.LoggerFactory;

/**
 * A utility class for invoking prefixed methods in action class.
 * 
 * Interceptors that made use of this class are:
 * 
 * 	 DefaultWorkflowInterceptor
 *   PrepareInterceptor
 * 
 * 
 * 
 * 
 * 
 * 
 * In DefaultWorkflowInterceptor
 * 
applies only when action implements {@link com.opensymphony.xwork2.Validateable}
 * 
 *    if the action class have validate{MethodName}(), it will be invoked
 *    else if the action class have validateDo{MethodName}(), it will be invoked
 *    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.
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * In PrepareInterceptor
 * Applies only when action implements Preparable
 * 
 *    if the action class have prepare{MethodName}(), it will be invoked
 *    else if the action class have prepareDo(MethodName()}(), it will be invoked
 *    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.
 * 
 * 
 * 
 * 
 * @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";

    /**
	 * 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 
	 * a prefixed method is found in the action class.
	 * 
	 * 
	 * 
	 * For example, with
	 * 
	 *   invokePrefixMethod(actionInvocation, new String[] { "prepare", "prepareDo" });
	 * 
	 * 
	 * Assuming actionInvocation.getProxy(),getMethod() returns "submit", 
	 * the order of invocation would be as follows:-
	 * 
	 *   prepareSubmit()
	 *   prepareDoSubmit()
	 * 
	 * 
	 * 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 
	 * prepareDoSubmit() exists, it will be invoked.
	 * 
	 * 
	 * 
	 * 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 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.
	 * @return a {@link Method} if one is found, else null.
	 */
	public static Method getPrefixedMethod(String[] prefixes, String methodName, Object action) {
		assert(prefixes != null);
		String capitalizedMethodName = capitalizeMethodName(methodName);
		for (int a=0; a< prefixes.length; a++) {
			String prefixedMethodName = prefixes[a]+capitalizedMethodName;
			try {
				Method method = action.getClass().getMethod(prefixedMethodName, new Class[0]);
				return method;
			}
			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 methodName.
	 * 

	 * eg. 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);
	}

}