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

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

import com.opensymphony.xwork2.ActionInvocation;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

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:
 * 
 * 
 * 	 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 = LogManager.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 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 (String prefixe : prefixes) {
            String prefixedMethodName = prefixe + capitalizedMethodName;
            try {
                return action.getClass().getMethod(prefixedMethodName, EMPTY_CLASS_ARRAY);
            }
            catch (NoSuchMethodException e) {
                // hmm -- OK, try next prefix
                LOG.debug("Cannot find method [{}] in action [{}]", prefixedMethodName, 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);
	}

}