Utility reflection methods focussed on methods in general rather than properties in particular.
Known Limitations
Accessing Public Methods In A Default Access Superclass
There is an issue when invoking public methods contained in a default access superclass.
Reflection locates these methods fine and correctly assigns them as public.
However, an
IllegalAccessException
is thrown if the method is invoked.
MethodUtils
contains a workaround for this situation.
It will attempt to call
setAccessible
on this method.
If this call succeeds, then the method can be invoked as normal.
This call will only succeed when the application has sufficient security privilages.
If this call fails then a warning will be logged and the method may fail.
getAccessibleMethod
public static Method getAccessibleMethod(Class clazz,
String methodName,
Class parameterType)
Return an accessible method (that is, one that can be invoked via
reflection) with given name and a single parameter. If no such method
can be found, return null
.
Basically, a convenience wrapper that constructs a Class
array for you.
clazz
- get method from this classmethodName
- get method with this nameparameterType
- taking this type of parameter
getAccessibleMethod
public static Method getAccessibleMethod(Class clazz,
String methodName,
Class[] parameterTypes)
Return an accessible method (that is, one that can be invoked via
reflection) with given name and parameters. If no such method
can be found, return null
.
This is just a convenient wrapper for
getAccessibleMethod(Method method)
.
clazz
- get method from this classmethodName
- get method with this nameparameterTypes
- with these parameters types
getAccessibleMethod
public static Method getAccessibleMethod(Method method)
Return an accessible method (that is, one that can be invoked via
reflection) that implements the specified Method. If no such method
can be found, return null
.
method
- The method that we wish to call
getAccessibleMethodFromInterfaceNest
private static Method getAccessibleMethodFromInterfaceNest(Class clazz,
String methodName,
parameterTypes[] )
Return an accessible method (that is, one that can be invoked via
reflection) that implements the specified method, by scanning through
all implemented interfaces and subinterfaces. If no such method
can be found, return
null
.
There isn't any good reason why this method must be private.
It is because there doesn't seem any reason why other classes should
call this rather than the higher level methods.
clazz
- Parent class for the interfaces to be checkedmethodName
- Method name of the method we wish to call
getMatchingAccessibleMethod
public static Method getMatchingAccessibleMethod(Class clazz,
String methodName,
Class[] parameterTypes)
Find an accessible method that matches the given name and has compatible parameters.
Compatible parameters mean that every method parameter is assignable from
the given parameters.
In other words, it finds a method with the given name
that will take the parameters given.
This method is slightly undeterminstic since it loops
through methods names and return the first matching method.
This method is used by
invokeMethod(Object object,String methodName,Object [] args,Class[] parameterTypes)
.
This method can match primitive parameter by passing in wrapper classes.
For example, a
Boolean
will match a primitive
boolean
parameter.
clazz
- find method in this classmethodName
- find method with this nameparameterTypes
- find method with compatible parameters
getPrimitiveType
public static Class getPrimitiveType(Class wrapperType)
Gets the class for the primitive type corresponding to the primitive wrapper class given.
For example, an instance of Boolean.class
returns a boolean.class
.
- the primitive type class corresponding to the given wrapper class,
null if no match is found
getPrimitiveWrapper
public static Class getPrimitiveWrapper(Class primitiveType)
Gets the wrapper object class for the given primitive type class.
For example, passing boolean.class
returns Boolean.class
primitiveType
- the primitive type class for which a match is to be found
- the wrapper type associated with the given primitive
or null if no match is found
invokeExactMethod
public static Object invokeExactMethod(Object object,
String methodName,
Object arg)
throws NoSuchMethodException,
IllegalAccessException,
InvocationTargetException
Invoke a method whose parameter type matches exactly the object
type.
This is a convenient wrapper for
invokeExactMethod(Object object,String methodName,Object [] args)
.
object
- invoke method on this objectmethodName
- get method with this namearg
- use this argument
invokeExactMethod
public static Object invokeExactMethod(Object object,
String methodName,
Object[] args)
throws NoSuchMethodException,
IllegalAccessException,
InvocationTargetException
Invoke a method whose parameter types match exactly the object
types.
This uses reflection to invoke the method obtained from a call to
getAccessibleMethod
.
object
- invoke method on this objectmethodName
- get method with this nameargs
- use these arguments - treat null as empty array
invokeExactMethod
public static Object invokeExactMethod(Object object,
String methodName,
Object[] args,
Class[] parameterTypes)
throws NoSuchMethodException,
IllegalAccessException,
InvocationTargetException
Invoke a method whose parameter types match exactly the parameter
types given.
This uses reflection to invoke the method obtained from a call to
getAccessibleMethod
.
object
- invoke method on this objectmethodName
- get method with this nameargs
- use these arguments - treat null as empty arrayparameterTypes
- match these parameters - treat null as empty array
invokeMethod
public static Object invokeMethod(Object object,
String methodName,
Object arg)
throws NoSuchMethodException,
IllegalAccessException,
InvocationTargetException
Invoke a named method whose parameter type matches the object type.
The behaviour of this method is less deterministic
than
invokeExactMethod
.
It loops through all methods with names that match
and then executes the first it finds with compatable parameters.
This method supports calls to methods taking primitive parameters
via passing in wrapping classes. So, for example, a
Boolean
class
would match a
boolean
primitive.
This is a convenient wrapper for
invokeMethod(Object object,String methodName,Object [] args)
.
object
- invoke method on this objectmethodName
- get method with this namearg
- use this argument
invokeMethod
public static Object invokeMethod(Object object,
String methodName,
Object[] args)
throws NoSuchMethodException,
IllegalAccessException,
InvocationTargetException
Invoke a named method whose parameter type matches the object type.
The behaviour of this method is less deterministic
than
invokeExactMethod(Object object,String methodName,Object [] args)
.
It loops through all methods with names that match
and then executes the first it finds with compatable parameters.
This method supports calls to methods taking primitive parameters
via passing in wrapping classes. So, for example, a
Boolean
class
would match a
boolean
primitive.
This is a convenient wrapper for
invokeMethod(Object object,String methodName,Object [] args,Class[] parameterTypes)
.
object
- invoke method on this objectmethodName
- get method with this nameargs
- use these arguments - treat null as empty array
invokeMethod
public static Object invokeMethod(Object object,
String methodName,
Object[] args,
Class[] parameterTypes)
throws NoSuchMethodException,
IllegalAccessException,
InvocationTargetException
Invoke a named method whose parameter type matches the object type.
The behaviour of this method is less deterministic
than
invokeExactMethod(Object object,String methodName,Object [] args,Class[] parameterTypes)
.
It loops through all methods with names that match
and then executes the first it finds with compatable parameters.
This method supports calls to methods taking primitive parameters
via passing in wrapping classes. So, for example, a
Boolean
class
would match a
boolean
primitive.
object
- invoke method on this objectmethodName
- get method with this nameargs
- use these arguments - treat null as empty arrayparameterTypes
- match these parameters - treat null as empty array
isAssignmentCompatible
public static final boolean isAssignmentCompatible(Class parameterType,
Class parameterization)
Determine whether a type can be used as a parameter in a method invocation.
This method handles primitive conversions correctly.
In order words, it will match a
Boolean
to a
boolean
,
a
Long
to a
long
,
a
Float
to a
float
,
a
Integer
to a
int
,
and a
Double
to a
double
.
Now logic widening matches are allowed.
For example, a
Long
will not match a
int
.
parameterType
- the type of parameter accepted by the methodparameterization
- the type of parameter being tested
- true if the assignement is compatible.
toNonPrimitiveClass
public static Class toNonPrimitiveClass(Class clazz)
Find a non primitive representation for given primitive class.
clazz
- the class to find a representation for, not null
- the original class if it not a primitive. Otherwise the wrapper class. Not null