Java Code Examples for org.apache.commons.lang.ArrayUtils#EMPTY_OBJECT_ARRAY

/**
 * <p>Invoke a named method whose parameter type matches the object type.</p>
 *
 * <p>This method delegates the method search to {@link #getMatchingAccessibleMethod(Class, String, Class[])}.</p>
 *
 * <p>This method supports calls to methods taking primitive parameters 
 * via passing in wrapping classes. So, for example, a <code>Boolean</code> object
 * would match a <code>boolean</code> primitive.</p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the method invoked
 * @throws IllegalAccessException if the requested method is not accessible via reflection
 */
public static Object invokeMethod(Object object, String methodName,
        Object[] args, Class[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Method method = getMatchingAccessibleMethod(object.getClass(),
            methodName, parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on object: "
                + object.getClass().getName());
    }
    return method.invoke(object, args);
}
 

/**
 * <p>Invoke a method whose parameter types match exactly the parameter
 * types given.</p>
 *
 * <p>This uses reflection to invoke the method obtained from a call to
 * <code>getAccessibleMethod()</code>.</p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactMethod(Object object, String methodName,
        Object[] args, Class[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    Method method = getAccessibleMethod(object.getClass(), methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on object: "
                + object.getClass().getName());
    }
    return method.invoke(object, args);
}
 

/**
 * <p>Returns new instance of <code>klazz</code> created using constructor
 * with signature <code>parameterTypes</code> and actual arguments
 * <code>args</code>.</p>
 * 
 * <p>The signatures should be assignment compatible.</p>
 * 
 * @param cls the class to be constructed.
 * @param args actual argument array
 * @param parameterTypes parameter types array
 * @return new instance of <code>klazz</code>
 * 
 * @throws NoSuchMethodException if matching constructor cannot be found
 * @throws IllegalAccessException thrown on the constructor's invocation
 * @throws InvocationTargetException thrown on the constructor's invocation
 * @throws InstantiationException thrown on the constructor's invocation
 * @see Constructor#newInstance
 */
public static Object invokeConstructor(Class cls, Object[] args, Class[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
        InstantiationException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Constructor ctor = getMatchingAccessibleConstructor(cls, parameterTypes);
    if (null == ctor) {
        throw new NoSuchMethodException("No such accessible constructor on object: "
                + cls.getName());
    }
    return ctor.newInstance(args);
}
 

/**
 * <p>Returns new instance of <code>klazz</code> created using constructor
 * with signature <code>parameterTypes</code> and actual arguments
 * <code>args</code>.</p>
 * 
 * <p>The signatures should match exactly.</p>
 * 
 * @param cls the class to be constructed.
 * @param args actual argument array
 * @param parameterTypes parameter types array
 * @return new instance of <code>klazz</code>
 * 
 * @throws NoSuchMethodException if matching constructor cannot be found
 * @throws IllegalAccessException thrown on the constructor's invocation
 * @throws InvocationTargetException thrown on the constructor's invocation
 * @throws InstantiationException thrown on the constructor's invocation
 * @see Constructor#newInstance
 */
public static Object invokeExactConstructor(Class cls, Object[] args,
        Class[] parameterTypes) throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException, InstantiationException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    Constructor ctor = getAccessibleConstructor(cls, parameterTypes);
    if (null == ctor) {
        throw new NoSuchMethodException("No such accessible constructor on object: "
                + cls.getName());
    }
    return ctor.newInstance(args);
}
 

/**
 * <p>Invoke a static method whose parameter types match exactly the parameter
 * types given.</p>
 *
 * <p>This uses reflection to invoke the method obtained from a call to
 * {@link #getAccessibleMethod(Class, String, Class[])}.</p>
 *
 * @param cls invoke static method on this class
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactStaticMethod(Class cls, String methodName,
        Object[] args, Class[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    Method method = getAccessibleMethod(cls, methodName, parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on class: " + cls.getName());
    }
    return method.invoke(null, args);
}
 

/**
 * <p>Invoke a named static method whose parameter type matches the object type.</p>
 *
 * <p>This method delegates the method search to {@link #getMatchingAccessibleMethod(Class, String, Class[])}.</p>
 *
 * <p>This method supports calls to methods taking primitive parameters 
 * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
 * would match a <code>boolean</code> primitive.</p>
 *
 *
 * @param cls invoke static method on this class
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeStaticMethod(Class cls, String methodName,
        Object[] args, Class[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Method method = getMatchingAccessibleMethod(cls, methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on class: " + cls.getName());
    }
    return method.invoke(null, args);
}
 

/**
 * <p>Returns new instance of <code>klazz</code> created using the actual
 * arguments <code>args</code>. The formal parameter types are inferred from
 * the actual values of <code>args</code>. See
 * {@link #invokeExactConstructor(Class, Object[], Class[])} for more
 * details.</p>
 * <p>The signatures should be assignment compatible.</p>
 *
 * @param cls the class to be constructed.
 * @param args actual argument array
 * @return new instance of <code>klazz</code>
 * 
 * @throws NoSuchMethodException If the constructor cannot be found
 * @throws IllegalAccessException If an error occurs accessing the
 * constructor
 * @throws InvocationTargetException If an error occurs invoking the
 * constructor
 * @throws InstantiationException If an error occurs instantiating the class
 * 
 * @see #invokeConstructor(java.lang.Class, java.lang.Object[],
 * java.lang.Class[])
 */
public static Object invokeConstructor(Class cls, Object[] args)
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
        InstantiationException {
    if (null == args) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Class parameterTypes[] = new Class[args.length];
    for (int i = 0; i < args.length; i++) {
        parameterTypes[i] = args[i].getClass();
    }
    return invokeConstructor(cls, args, parameterTypes);
}
 

/**
 * <p>Returns new instance of <code>klazz</code> created using the actual
 * arguments <code>args</code>. The formal parameter types are inferred from
 * the actual values of <code>args</code>. See
 * {@link #invokeExactConstructor(Class, Object[], Class[])} for more
 * details.</p>
 *
 * <p>The signatures should match exactly.</p>
 *
 * @param cls the class to be constructed.
 * @param args actual argument array
 * @return new instance of <code>klazz</code>
 * 
 * @throws NoSuchMethodException If the constructor cannot be found
 * @throws IllegalAccessException If an error occurs accessing the
 * constructor
 * @throws InvocationTargetException If an error occurs invoking the
 * constructor
 * @throws InstantiationException If an error occurs instantiating the class
 * 
 * @see #invokeExactConstructor(java.lang.Class, java.lang.Object[],
 * java.lang.Class[])
 */
public static Object invokeExactConstructor(Class cls, Object[] args)
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
        InstantiationException {
    if (null == args) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    int arguments = args.length;
    Class parameterTypes[] = new Class[arguments];
    for (int i = 0; i < arguments; i++) {
        parameterTypes[i] = args[i].getClass();
    }
    return invokeExactConstructor(cls, args, parameterTypes);
}
 

/**
 * <p>Invoke a named method whose parameter type matches the object type.</p>
 *
 * <p>This method delegates the method search to {@link #getMatchingAccessibleMethod(Class, String, Class[])}.</p>
 *
 * <p>This method supports calls to methods taking primitive parameters 
 * via passing in wrapping classes. So, for example, a <code>Boolean</code> object
 * would match a <code>boolean</code> primitive.</p>
 *
 * <p> This is a convenient wrapper for
 * {@link #invokeMethod(Object object,String methodName, Object[] args, Class[] parameterTypes)}.
 * </p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the method invoked
 * @throws IllegalAccessException if the requested method is not accessible via reflection
 */
public static Object invokeMethod(Object object, String methodName,
        Object[] args) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    int arguments = args.length;
    Class[] parameterTypes = new Class[arguments];
    for (int i = 0; i < arguments; i++) {
        parameterTypes[i] = args[i].getClass();
    }
    return invokeMethod(object, methodName, args, parameterTypes);
}
 

/**
 * <p>Invoke a method whose parameter types match exactly the object
 * types.</p>
 *
 * <p> This uses reflection to invoke the method obtained from a call to
 * <code>getAccessibleMethod()</code>.</p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactMethod(Object object, String methodName,
        Object[] args) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    int arguments = args.length;
    Class[] parameterTypes = new Class[arguments];
    for (int i = 0; i < arguments; i++) {
        parameterTypes[i] = args[i].getClass();
    }
    return invokeExactMethod(object, methodName, args, parameterTypes);
}
 

/**
 * <p>Invoke a named static method whose parameter type matches the object type.</p>
 *
 * <p>This method delegates the method search to {@link #getMatchingAccessibleMethod(Class, String, Class[])}.</p>
 *
 * <p>This method supports calls to methods taking primitive parameters 
 * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
 * would match a <code>boolean</code> primitive.</p>
 *
 * <p> This is a convenient wrapper for
 * {@link #invokeStaticMethod(Class objectClass,String methodName,Object [] args,Class[] parameterTypes)}.
 * </p>
 *
 * @param cls invoke static method on this class
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeStaticMethod(Class cls, String methodName,
        Object[] args) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    int arguments = args.length;
    Class[] parameterTypes = new Class[arguments];
    for (int i = 0; i < arguments; i++) {
        parameterTypes[i] = args[i].getClass();
    }
    return invokeStaticMethod(cls, methodName, args, parameterTypes);
}
 

/**
 * <p>Invoke a static method whose parameter types match exactly the object
 * types.</p>
 *
 * <p> This uses reflection to invoke the method obtained from a call to
 * {@link #getAccessibleMethod(Class, String, Class[])}.</p>
 *
 * @param cls invoke static method on this class
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactStaticMethod(Class cls, String methodName,
        Object[] args) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    int arguments = args.length;
    Class[] parameterTypes = new Class[arguments];
    for (int i = 0; i < arguments; i++) {
        parameterTypes[i] = args[i].getClass();
    }
    return invokeExactStaticMethod(cls, methodName, args, parameterTypes);
}