ReflectUtil

package jp.co.ntt.ansl.picax.acc.common.util;

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

/**
* some refact utilities for java class refact
*
*/
public class ReflectUtil {

    /**
     * invoke object method
     *
     * @param target the object to run method
     * @param methodName method name
     * @return object
     */
    public static Object invoke(Object target, String methodName) {
        return invoke(target, methodName, null);
    }

    /**
     * invoke object method
     *
     * @param target the object to run method
     * @param methodName method name
     * @param paramValues parameter values
     * @return object
     */
    public static Object invoke(Object target, String methodName, Object[] paramValues) {
        Class[] parameterTypes = getClassArray(paramValues);
        return invoke(target, methodName, parameterTypes, paramValues);
    }

    /**
     * invoke object method
     *
     * @param target the object to run method
     * @param methodName method name
     * @param paramTypes parameter types
     * @param paramValues parameter values
     * @return object
     */
    public static Object invoke(Object target, String methodName, Class[] paramTypes, Object[] paramValues) {
        try {
            Class clazz = target.getClass();
            Method method = clazz.getDeclaredMethod(methodName, paramTypes);
            return invoke(target, method, paramValues);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * invoke the target object method
     *
     * @param target the target object
     * @param method the method to execute
     * @param paramValues the method parameters
     * @return object of result
     */
    public static Object invoke(Object target, Method method, Object[] paramValues) {
        boolean accessible = method.isAccessible();
        try {
            method.setAccessible(true);
            if (Modifier.isStatic(method.getModifiers())) {
                return method.invoke(null, paramValues);
            } else {
                return method.invoke(target, paramValues);
            }
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } finally {
            method.setAccessible(accessible);
        }
    }

    /**
     * judge if the object has the given method by name
     *
     * @param obj the object to judge
     * @param methodName the method name
     * @param paramTypes the parameterTypes
     * @return true or false
     */
    public static boolean hasMethod(Object obj, String methodName, Class[] paramTypes) {
        Class clazz = obj.getClass();
        try {
            clazz.getDeclaredMethod(methodName, paramTypes);
            return true;
        } catch (NoSuchMethodException e) {
            return false;
        }
    }

    /**
     * invoke the target class method
     *
     * @param clazz the clazz to run parameter
     * @param methodName the method to execute
     * @param paramValues the method parameters
     * @return object of result
     */
    public static Object invokeStatic(Class clazz, String methodName, Object[] paramValues) {
        try {
            Class[] parameterTypes = getClassArray(paramValues);;
            Method method = clazz.getDeclaredMethod(methodName,parameterTypes);
            return invokeStatic(method, paramValues);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (SecurityException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * invoke the target class method
     *
     * @param clazz the clazz to run parameter
     * @param methodName the method to execute
     * @param paramTypes the method parameter types
     * @param paramValues the method parameters
     * @return object of result
     */
    public static Object invokeStatic(Class clazz, String methodName, Class[] paramTypes, Object[] paramValues) {
        try {
            Method method = clazz.getDeclaredMethod(methodName,paramTypes);
            return invokeStatic(method, paramValues);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (SecurityException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * invoke the target class method
     *
     * @param clazz the clazz to run parameter
     * @param methodName the method to execute
     * @return object of result
     */
    public static Object invokeStatic(Class clazz, String methodName) {
        try {
            Method method = clazz.getDeclaredMethod(methodName,null);
            return invokeStatic(method, null);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (SecurityException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * invoke the target class method
     *
     * @param method the method to execute
     * @param paramValues the method parameters
     * @return object of result
     */
    public static Object invokeStatic(Method method, Object[] paramValues) {
        boolean accessible = method.isAccessible();
        try {
            method.setAccessible(true);
            if (Modifier.isStatic(method.getModifiers())) {
                return method.invoke(null, paramValues);
            } else {
                throw new RuntimeException("can not run none static class without object");
            }
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } finally {
            method.setAccessible(accessible);
        }
    }

    /**
     * judge if the object has the given method by name
     *
     * @param clazz the object to judge
     * @param methodName the method name
     * @param paramTypes the parameterTypes
     * @return true or false
     */
    public static boolean hasStaticMethod(Class clazz, String methodName, Class[] paramTypes) {
        try {
            clazz.getDeclaredMethod(methodName, paramTypes);
            return true;
        } catch (NoSuchMethodException e) {
            return false;
        }
    }

    /**
     * get class types according to the objects
     *
     * @param objects
     * @return null if the array is null
     */
    public static Class[] getClassArray(Object[] objects) {
        if(objects==null) return null;
        int arguments = objects.length;
        Class objectTypes [] = new Class[arguments];
        for (int i = 0; i < arguments; i++) {
            objectTypes[i] = objects[i].getClass();
        }
        return objectTypes;
    }
}