## org.springframework.util
Class ReflectionUtils

    java.lang.Object
      org.springframework.util.ReflectionUtils

    public abstract class ReflectionUtils

extends Object

Simple utility class for working with the reflection API and handling reflection exceptions.

Only intended for internal use.

Since:
  1.2.2
Author:
  Juergen Hoeller, Rob Harrop, Rod Johnson, Costin Leau, Sam Brannen

Nested Class Summary
`static interface` `ReflectionUtils.FieldCallback` Callback interface invoked on each field in the hierarchy.
`static interface` `ReflectionUtils.FieldFilter` Callback optionally used to filter fields to be operated on by a field callback.
`static interface` `ReflectionUtils.MethodCallback` Action to take on each method.
`static interface` `ReflectionUtils.MethodFilter` Callback optionally used to method fields to be operated on by a method callback.

Field Summary
`static ReflectionUtils.FieldFilter` `COPYABLE_FIELDS` Pre-built FieldFilter that matches all non-static, non-final fields.
`static ReflectionUtils.MethodFilter` `NON_BRIDGED_METHODS` Pre-built MethodFilter that matches all non-bridge methods.
`static ReflectionUtils.MethodFilter` `USER_DECLARED_METHODS` Pre-built MethodFilter that matches all non-bridge methods which are not declared on `java.lang.Object`.

Constructor Summary
`ReflectionUtils()`

Method Summary
`static boolean` `declaresException(Method method, Class<?> exceptionType)` Determine whether the given method explicitly declares the given exception or one of its superclasses, which means that an exception of that type can be propagated as-is within a reflective invocation.
`static void` `doWithFields(Class<?> clazz, ReflectionUtils.FieldCallback fc)` Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.
`static void` `doWithFields(Class<?> clazz, ReflectionUtils.FieldCallback fc, ReflectionUtils.FieldFilter ff)` Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.
`static void` `doWithMethods(Class<?> clazz, ReflectionUtils.MethodCallback mc)` Perform the given callback operation on all matching methods of the given class and superclasses.
`static void` `doWithMethods(Class<?> clazz, ReflectionUtils.MethodCallback mc, ReflectionUtils.MethodFilter mf)` Perform the given callback operation on all matching methods of the given class and superclasses (or given interface and super-interfaces).
`static Field` `findField(Class<?> clazz, String name)` Attempt to find a `field` on the supplied `Class` with the supplied `name`.
`static Field` `findField(Class<?> clazz, String name, Class<?> type)` Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`.
`static Method` `findMethod(Class<?> clazz, String name)` Attempt to find a `Method` on the supplied class with the supplied name and no parameters.
`static Method` `findMethod(Class<?> clazz, String name, Class<?>... paramTypes)` Attempt to find a `Method` on the supplied class with the supplied name and parameter types.
`static Method[]` `getAllDeclaredMethods(Class<?> leafClass)` Get all declared methods on the leaf class and all superclasses.
`static Object` `getField(Field field, Object target)` Get the field represented by the supplied `field object` on the specified `target object`.
`static void` `handleInvocationTargetException(InvocationTargetException ex)` Handle the given invocation target exception.
`static void` `handleReflectionException(Exception ex)` Handle the given reflection exception.
`static Object` `invokeJdbcMethod(Method method, Object target)` Invoke the specified JDBC API `Method` against the supplied target object with no arguments.
`static Object` `invokeJdbcMethod(Method method, Object target, Object... args)` Invoke the specified JDBC API `Method` against the supplied target object with the supplied arguments.
`static Object` `invokeMethod(Method method, Object target)` Invoke the specified `Method` against the supplied target object with no arguments.
`static Object` `invokeMethod(Method method, Object target, Object... args)` Invoke the specified `Method` against the supplied target object with the supplied arguments.
`static boolean` `isEqualsMethod(Method method)` Determine whether the given method is an "equals" method.
`static boolean` `isHashCodeMethod(Method method)` Determine whether the given method is a "hashCode" method.
`static boolean` `isPublicStaticFinal(Field field)` Determine whether the given field is a "public static final" constant.
`static boolean` `isToStringMethod(Method method)` Determine whether the given method is a "toString" method.
`static void` `makeAccessible(Constructor<?> ctor)` Make the given constructor accessible, explicitly setting it accessible if necessary.
`static void` `makeAccessible(Field field)` Make the given field accessible, explicitly setting it accessible if necessary.
`static void` `makeAccessible(Method method)` Make the given method accessible, explicitly setting it accessible if necessary.
`static void` `rethrowException(Throwable ex)` Rethrow the given `exception`, which is presumably the target exception of an `InvocationTargetException`.
`static void` `rethrowRuntimeException(Throwable ex)` Rethrow the given `exception`, which is presumably the target exception of an `InvocationTargetException`.
`static void` `setField(Field field, Object target, Object value)` Set the field represented by the supplied `field object` on the specified `target object` to the specified `value`.
`static void` `shallowCopyFieldState(Object src, Object dest)` Given the source object and the destination, which must be the same class or a subclass, copy all fields, including inherited fields.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### COPYABLE_FIELDS

    public static ReflectionUtils.FieldFilter COPYABLE_FIELDS

  Pre-built FieldFilter that matches all non-static, non-final fields.

### NON_BRIDGED_METHODS

    public static ReflectionUtils.MethodFilter NON_BRIDGED_METHODS

  Pre-built MethodFilter that matches all non-bridge methods.

### USER_DECLARED_METHODS

    public static ReflectionUtils.MethodFilter USER_DECLARED_METHODS

  Pre-built MethodFilter that matches all non-bridge methods which are not declared on `java.lang.Object`.

Constructor Detail

### ReflectionUtils

    public ReflectionUtils()

Method Detail

### findField

    public static Field findField(Class<?> clazz,
                                  String name)

  Attempt to find a `field` on the supplied `Class` with the supplied `name`. Searches all superclasses up to `Object`.

  Parameters:
    `clazz` - the class to introspect
    `name` - the name of the field
  Returns:
    the corresponding Field object, or `null` if not found

### findField

    public static Field findField(Class<?> clazz,
                                  String name,
                                  Class<?> type)

  Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`. Searches all superclasses up to `Object`.

  Parameters:
    `clazz` - the class to introspect
    `name` - the name of the field (may be `null` if type is specified)
    `type` - the type of the field (may be `null` if name is specified)
  Returns:
    the corresponding Field object, or `null` if not found

### setField

    public static void setField(Field field,
                                Object target,
                                Object value)

  Set the field represented by the supplied `field object` on the specified `target object` to the specified `value`. In accordance with `Field.set(Object, Object)` semantics, the new value is automatically unwrapped if the underlying field has a primitive type.

  Thrown exceptions are handled via a call to `handleReflectionException(Exception)`.

  Parameters:
    `field` - the field to set
    `target` - the target object on which to set the field
    `value` - the value to set; may be `null`

### getField

    public static Object getField(Field field,
                                  Object target)

  Get the field represented by the supplied `field object` on the specified `target object`. In accordance with `Field.get(Object)` semantics, the returned value is automatically wrapped if the underlying field has a primitive type.

  Thrown exceptions are handled via a call to `handleReflectionException(Exception)`.

  Parameters:
    `field` - the field to get
    `target` - the target object from which to get the field
  Returns:
    the field's current value

### findMethod

    public static Method findMethod(Class<?> clazz,
                                    String name)

  Attempt to find a `Method` on the supplied class with the supplied name and no parameters. Searches all superclasses up to `Object`.

  Returns `null` if no `Method` can be found.

  Parameters:
    `clazz` - the class to introspect
    `name` - the name of the method
  Returns:
    the Method object, or `null` if none found

### findMethod

    public static Method findMethod(Class<?> clazz,
                                    String name,
                                    Class<?>... paramTypes)

  Attempt to find a `Method` on the supplied class with the supplied name and parameter types. Searches all superclasses up to `Object`.

  Returns `null` if no `Method` can be found.

  Parameters:
    `clazz` - the class to introspect
    `name` - the name of the method
    `paramTypes` - the parameter types of the method (may be `null` to indicate any signature)
  Returns:
    the Method object, or `null` if none found

### invokeMethod

    public static Object invokeMethod(Method method,
                                      Object target)

  Invoke the specified `Method` against the supplied target object with no arguments. The target object can be `null` when invoking a static `Method`.

  Thrown exceptions are handled via a call to `handleReflectionException(java.lang.Exception)`.

  Parameters:
    `method` - the method to invoke
    `target` - the target object to invoke the method on
  Returns:
    the invocation result, if any
  See Also:
    `invokeMethod(java.lang.reflect.Method, Object, Object[])`

### invokeMethod

    public static Object invokeMethod(Method method,
                                      Object target,
                                      Object... args)

  Invoke the specified `Method` against the supplied target object with the supplied arguments. The target object can be `null` when invoking a static `Method`.

  Thrown exceptions are handled via a call to `handleReflectionException(java.lang.Exception)`.

  Parameters:
    `method` - the method to invoke
    `target` - the target object to invoke the method on
    `args` - the invocation arguments (may be `null`)
  Returns:
    the invocation result, if any

### invokeJdbcMethod

    public static Object invokeJdbcMethod(Method method,
                                          Object target)
                                   throws SQLException

  Invoke the specified JDBC API `Method` against the supplied target object with no arguments.

  Parameters:
    `method` - the method to invoke
    `target` - the target object to invoke the method on
  Returns:
    the invocation result, if any
  Throws:
    `SQLException` - the JDBC API SQLException to rethrow (if any)
  See Also:
    `invokeJdbcMethod(java.lang.reflect.Method, Object, Object[])`

### invokeJdbcMethod

    public static Object invokeJdbcMethod(Method method,
                                          Object target,
                                          Object... args)
                                   throws SQLException

  Invoke the specified JDBC API `Method` against the supplied target object with the supplied arguments.

  Parameters:
    `method` - the method to invoke
    `target` - the target object to invoke the method on
    `args` - the invocation arguments (may be `null`)
  Returns:
    the invocation result, if any
  Throws:
    `SQLException` - the JDBC API SQLException to rethrow (if any)
  See Also:
    `invokeMethod(java.lang.reflect.Method, Object, Object[])`

### handleReflectionException

    public static void handleReflectionException(Exception ex)

  Handle the given reflection exception. Should only be called if no checked exception is expected to be thrown by the target method.

  Throws the underlying RuntimeException or Error in case of an InvocationTargetException with such a root cause. Throws an IllegalStateException with an appropriate message else.

  Parameters:
    `ex` - the reflection exception to handle

### handleInvocationTargetException

    public static void handleInvocationTargetException(InvocationTargetException ex)

  Handle the given invocation target exception. Should only be called if no checked exception is expected to be thrown by the target method.

  Throws the underlying RuntimeException or Error in case of such a root cause. Throws an IllegalStateException else.

  Parameters:
    `ex` - the invocation target exception to handle

### rethrowRuntimeException

    public static void rethrowRuntimeException(Throwable ex)

  Rethrow the given `exception`, which is presumably the target exception of an `InvocationTargetException`. Should only be called if no checked exception is expected to be thrown by the target method.

  Rethrows the underlying exception cast to an `RuntimeException` or `Error` if appropriate; otherwise, throws an `IllegalStateException`.

  Parameters:
    `ex` - the exception to rethrow
  Throws:
    `RuntimeException` - the rethrown exception

### rethrowException

    public static void rethrowException(Throwable ex)
                                 throws Exception

  Rethrow the given `exception`, which is presumably the target exception of an `InvocationTargetException`. Should only be called if no checked exception is expected to be thrown by the target method.

  Rethrows the underlying exception cast to an `Exception` or `Error` if appropriate; otherwise, throws an `IllegalStateException`.

  Parameters:
    `ex` - the exception to rethrow
  Throws:
    `Exception` - the rethrown exception (in case of a checked exception)

### declaresException

    public static boolean declaresException(Method method,
                                            Class<?> exceptionType)

  Determine whether the given method explicitly declares the given exception or one of its superclasses, which means that an exception of that type can be propagated as-is within a reflective invocation.

  Parameters:
    `method` - the declaring method
    `exceptionType` - the exception to throw
  Returns:
    `true` if the exception can be thrown as-is; `false` if it needs to be wrapped

### isPublicStaticFinal

    public static boolean isPublicStaticFinal(Field field)

  Determine whether the given field is a "public static final" constant.

  Parameters:
    `field` - the field to check

### isEqualsMethod

    public static boolean isEqualsMethod(Method method)

  Determine whether the given method is an "equals" method.

  See Also:
    `Object.equals(Object)`

### isHashCodeMethod

    public static boolean isHashCodeMethod(Method method)

  Determine whether the given method is a "hashCode" method.

  See Also:
    `Object.hashCode()`

### isToStringMethod

    public static boolean isToStringMethod(Method method)

  Determine whether the given method is a "toString" method.

  See Also:
    `Object.toString()`

### makeAccessible

    public static void makeAccessible(Field field)

  Make the given field accessible, explicitly setting it accessible if necessary. The `setAccessible(true)` method is only called when actually necessary, to avoid unnecessary conflicts with a JVM SecurityManager (if active).

  Parameters:
    `field` - the field to make accessible
  See Also:
    `AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean)`

### makeAccessible

    public static void makeAccessible(Method method)

  Make the given method accessible, explicitly setting it accessible if necessary. The `setAccessible(true)` method is only called when actually necessary, to avoid unnecessary conflicts with a JVM SecurityManager (if active).

  Parameters:
    `method` - the method to make accessible
  See Also:
    `AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean)`

### makeAccessible

    public static void makeAccessible(Constructor<?> ctor)

  Make the given constructor accessible, explicitly setting it accessible if necessary. The `setAccessible(true)` method is only called when actually necessary, to avoid unnecessary conflicts with a JVM SecurityManager (if active).

  Parameters:
    `ctor` - the constructor to make accessible
  See Also:
    `AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean)`

### doWithMethods

    public static void doWithMethods(Class<?> clazz,
                                     ReflectionUtils.MethodCallback mc)
                              throws IllegalArgumentException

  Perform the given callback operation on all matching methods of the given class and superclasses.

  The same named method occurring on subclass and superclass will appear twice, unless excluded by a `ReflectionUtils.MethodFilter`.

  Parameters:
    `clazz` - class to start looking at
    `mc` - the callback to invoke for each method
  Throws:
    `IllegalArgumentException`
  See Also:
    `doWithMethods(Class, MethodCallback, MethodFilter)`

### doWithMethods

    public static void doWithMethods(Class<?> clazz,
                                     ReflectionUtils.MethodCallback mc,
                                     ReflectionUtils.MethodFilter mf)
                              throws IllegalArgumentException

  Perform the given callback operation on all matching methods of the given class and superclasses (or given interface and super-interfaces).

  The same named method occurring on subclass and superclass will appear twice, unless excluded by the specified `ReflectionUtils.MethodFilter`.

  Parameters:
    `clazz` - class to start looking at
    `mc` - the callback to invoke for each method
    `mf` - the filter that determines the methods to apply the callback to
  Throws:
    `IllegalArgumentException`

### getAllDeclaredMethods

    public static Method[] getAllDeclaredMethods(Class<?> leafClass)
                                          throws IllegalArgumentException

  Get all declared methods on the leaf class and all superclasses. Leaf class methods are included first.

  Throws:
    `IllegalArgumentException`

### doWithFields

    public static void doWithFields(Class<?> clazz,
                                    ReflectionUtils.FieldCallback fc)
                             throws IllegalArgumentException

  Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.

  Parameters:
    `clazz` - the target class to analyze
    `fc` - the callback to invoke for each field
  Throws:
    `IllegalArgumentException`

### doWithFields

    public static void doWithFields(Class<?> clazz,
                                    ReflectionUtils.FieldCallback fc,
                                    ReflectionUtils.FieldFilter ff)
                             throws IllegalArgumentException

  Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.

  Parameters:
    `clazz` - the target class to analyze
    `fc` - the callback to invoke for each field
    `ff` - the filter that determines the fields to apply the callback to
  Throws:
    `IllegalArgumentException`

### shallowCopyFieldState

    public static void shallowCopyFieldState(Object src,
                                             Object dest)
                                      throws IllegalArgumentException

  Given the source object and the destination, which must be the same class or a subclass, copy all fields, including inherited fields. Designed to work on objects with public no-arg constructors.

  Throws:
    `IllegalArgumentException` - if the arguments are incompatible