Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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.

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 targetClass, 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 targetClass, 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 targetClass, ReflectionUtils.MethodCallback mc)` Perform the given callback operation on all matching methods of the given class and superclasses.
`static void` | `doWithMethods(Class targetClass, ReflectionUtils.MethodCallback mc, ReflectionUtils.MethodFilter mf)` Perform the given callback operation on all matching methods of the given class and superclasses.
`static Field` | `findField(Class clazz, String name, Class type)` Attempt to find a `field` on the supplied `Class` with the supplied `name` and `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 void` | `handleInvocationTargetException(InvocationTargetException ex)` Handle the given invocation target exception.
`static void` | `handleReflectionException(Exception ex)` Handle the given reflection exception.
`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` | `isPublicStaticFinal(Field field)` Determine whether the given field is a "public static final" constant.
`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` | `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.

Constructor Detail

### ReflectionUtils

    public ReflectionUtils()

Method Detail

### 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 `type`. Searches all superclasses up to `Object`.

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

### 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`

### 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
  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
  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

### 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

### 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 targetClass,
                                     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:
    `targetClass` - 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 targetClass,
                                     ReflectionUtils.MethodCallback mc,
                                     ReflectionUtils.MethodFilter mf)
                              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 the specified `ReflectionUtils.MethodFilter`.

  Parameters:
    `targetClass` - 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 targetClass,
                                    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:
    `targetClass` - the target class to analyze
    `fc` - the callback to invoke for each field
  Throws:
    `IllegalArgumentException`

### doWithFields

    public static void doWithFields(Class targetClass,
                                    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:
    `targetClass` - 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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2007 The Spring Framework.