public static boolean declaresException(Method method,
    Class exceptionType) 
{
		Assert.notNull(method, "Method must not be null");
		Class[] declaredExceptions = method.getExceptionTypes();
		for (int i = 0; i <  declaredExceptions.length; i++) {
			Class declaredException = declaredExceptions[i];
			if (declaredException.isAssignableFrom(exceptionType)) {
				return true;
			}
		}
		return false;
}

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.

 public static  void doWithFields(Class targetClass,
    ReflectionUtils.FieldCallback fc) throws IllegalArgumentException 
{
		doWithFields(targetClass, fc, null);
}

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

 public static  void doWithFields(Class targetClass,
    ReflectionUtils.FieldCallback fc,
    ReflectionUtils.FieldFilter ff) throws IllegalArgumentException 
{
		// Keep backing up the inheritance hierarchy.
		do {
			// Copy each field declared on this class unless it's static or file.
			Field[] fields = targetClass.getDeclaredFields();
			for (int i = 0; i <  fields.length; i++) {
				// Skip static and final fields.
				if (ff != null && !ff.matches(fields[i])) {
					continue;
				}
				try {
					fc.doWith(fields[i]);
				}
				catch (IllegalAccessException ex) {
					throw new IllegalStateException(
							"Shouldn't be illegal to access field '" + fields[i].getName() + "': " + ex);
				}
			}
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);
}

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

 public static  void doWithMethods(Class targetClass,
    ReflectionUtils.MethodCallback mc) throws IllegalArgumentException 
{
		doWithMethods(targetClass, mc, null);
}

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

 public static  void doWithMethods(Class targetClass,
    ReflectionUtils.MethodCallback mc,
    ReflectionUtils.MethodFilter mf) throws IllegalArgumentException 
{
		// Keep backing up the inheritance hierarchy.
		do {
			Method[] methods = targetClass.getDeclaredMethods();
			for (int i = 0; i <  methods.length; i++) {
				if (mf != null && !mf.matches(methods[i])) {
					continue;
				}
				try {
					mc.doWith(methods[i]);
				}
				catch (IllegalAccessException ex) {
					throw new IllegalStateException(
							"Shouldn't be illegal to access method '" + methods[i].getName() + "': " + ex);
				}
			}
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null);
}

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

 public static Field findField(Class clazz,
    String name) 
{
		return findField(clazz, name, null);
}

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

 public static Field findField(Class clazz,
    String name,
    Class type) 
{
		Assert.notNull(clazz, "Class must not be null");
		Assert.isTrue(name != null || type != null, "Either name or type of the field must be specified");
		Class searchType = clazz;
		while (!Object.class.equals(searchType) && searchType != null) {
			Field[] fields = searchType.getDeclaredFields();
			for (int i = 0; i <  fields.length; i++) {
				Field field = fields[i];
				if ((name == null || name.equals(field.getName()))
						&& (type == null || type.equals(field.getType()))) {
					return field;
				}
			}
			searchType = searchType.getSuperclass();
		}
		return null;
}

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

 public static Method findMethod(Class clazz,
    String name) 
{
		return findMethod(clazz, name, new Class[0]);
}

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.

 public static Method findMethod(Class clazz,
    String name,
    Class[] paramTypes) 
{
		Assert.notNull(clazz, "Class must not be null");
		Assert.notNull(name, "Method name must not be null");
		Class searchType = clazz;
		while (!Object.class.equals(searchType) && searchType != null) {
			Method[] methods = (searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods());
			for (int i = 0; i <  methods.length; i++) {
				Method method = methods[i];
				if (name.equals(method.getName()) &&
						(paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
					return method;
				}
			}
			searchType = searchType.getSuperclass();
		}
		return null;
}

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.

 public static Method[] getAllDeclaredMethods(Class leafClass) throws IllegalArgumentException 
{
		final List list = new ArrayList(32);
		doWithMethods(leafClass, new MethodCallback() {
			public void doWith(Method method) {
				list.add(method);
			}
		});
		return (Method[]) list.toArray(new Method[list.size()]);
}

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

 public static Object getField(Field field,
    Object target) 
{
		try {
			return field.get(target);
		}
		catch (IllegalAccessException ex) {
			handleReflectionException(ex);
			throw new IllegalStateException(
					"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
		}
}

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

 public static  void handleInvocationTargetException(InvocationTargetException ex) 
{
		rethrowRuntimeException(ex.getTargetException());
}

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.

 public static  void handleReflectionException(Exception ex) 
{
		if (ex instanceof NoSuchMethodException) {
			throw new IllegalStateException("Method not found: " + ex.getMessage());
		}
		if (ex instanceof IllegalAccessException) {
			throw new IllegalStateException("Could not access method: " + ex.getMessage());
		}
		if (ex instanceof InvocationTargetException) {
			handleInvocationTargetException((InvocationTargetException) ex);
		}
		if (ex instanceof RuntimeException) {
			throw (RuntimeException) ex;
		}
		handleUnexpectedException(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.

 public static Object invokeJdbcMethod(Method method,
    Object target) throws SQLException 
{
		return invokeJdbcMethod(method, target, null);
}

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

 public static Object invokeJdbcMethod(Method method,
    Object target,
    Object[] args) throws SQLException 
{
		try {
			return method.invoke(target, args);
		}
		catch (IllegalAccessException ex) {
			handleReflectionException(ex);
		}
		catch (InvocationTargetException ex) {
			if (ex.getTargetException() instanceof SQLException) {
				throw (SQLException) ex.getTargetException();
			}
			handleInvocationTargetException(ex);
		}
		throw new IllegalStateException("Should never get here");
}

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

 public static Object invokeMethod(Method method,
    Object target) 
{
		return invokeMethod(method, target, null);
}

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 .

 public static Object invokeMethod(Method method,
    Object target,
    Object[] args) 
{
		try {
			return method.invoke(target, args);
		}
		catch (Exception ex) {
			handleReflectionException(ex);
		}
		throw new IllegalStateException("Should never get here");
}

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 .

 public static boolean isEqualsMethod(Method method) 
{
		if (method == null || !method.getName().equals("equals")) {
			return false;
		}
		Class[] paramTypes = method.getParameterTypes();
		return (paramTypes.length == 1 && paramTypes[0] == Object.class);
}

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

 public static boolean isHashCodeMethod(Method method) 
{
		return (method != null && method.getName().equals("hashCode") &&
				method.getParameterTypes().length == 0);
}

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

 public static boolean isPublicStaticFinal(Field field) 
{
		int modifiers = field.getModifiers();
		return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
}

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

 public static boolean isToStringMethod(Method method) 
{
		return (method != null && method.getName().equals("toString") &&
				method.getParameterTypes().length == 0);
}

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

 public static  void makeAccessible(Field field) 
{
		if (!Modifier.isPublic(field.getModifiers()) ||
				!Modifier.isPublic(field.getDeclaringClass().getModifiers())) {
			field.setAccessible(true);
		}
}

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

 public static  void makeAccessible(Method method) 
{
		if (!Modifier.isPublic(method.getModifiers()) ||
				!Modifier.isPublic(method.getDeclaringClass().getModifiers())) {
			method.setAccessible(true);
		}
}

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

 public static  void makeAccessible(Constructor ctor) 
{
		if (!Modifier.isPublic(ctor.getModifiers()) ||
				!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) {
			ctor.setAccessible(true);
		}
}

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

 public static  void rethrowException(Throwable ex) throws Exception 
{
		if (ex instanceof Exception) {
			throw (Exception) ex;
		}
		if (ex instanceof Error) {
			throw (Error) ex;
		}
		handleUnexpectedException(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 Exception or Error if appropriate; otherwise, throws an IllegalStateException .

 public static  void rethrowRuntimeException(Throwable ex) 
{
		if (ex instanceof RuntimeException) {
			throw (RuntimeException) ex;
		}
		if (ex instanceof Error) {
			throw (Error) ex;
		}
		handleUnexpectedException(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 .

 public static  void setField(Field field,
    Object target,
    Object value) 
{
		try {
			field.set(target, value);
		}
		catch (IllegalAccessException ex) {
			handleReflectionException(ex);
			throw new IllegalStateException(
					"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
		}
}

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

 public static  void shallowCopyFieldState(Object src,
    Object dest) throws IllegalArgumentException 
{
		if (src == null) {
			throw new IllegalArgumentException("Source for field copy cannot be null");
		}
		if (dest == null) {
			throw new IllegalArgumentException("Destination for field copy cannot be null");
		}
		if (!src.getClass().isAssignableFrom(dest.getClass())) {
			throw new IllegalArgumentException("Destination class [" + dest.getClass().getName() +
					"] must be same or subclass as source class [" + src.getClass().getName() + "]");
		}
		doWithFields(src.getClass(), new FieldCallback() {
			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				makeAccessible(field);
				Object srcValue = field.get(src);
				field.set(dest, srcValue);
			}
		}, COPYABLE_FIELDS);
}

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.