org.springframework.beans
Class BeanUtils

java.lang.Object
  org.springframework.beans.BeanUtils

public abstract class BeanUtils
extends Object

Static convenience methods for JavaBeans: for instantiating beans, checking bean property types, copying bean properties, etc.

Mainly for use within the framework, but to some degree also useful for application classes.

Author:

Rod Johnson, Juergen Hoeller, Rob Harrop, Sam Brannen

Constructor Summary

BeanUtils()

Method Summary

static void	copyProperties(Object source, Object target) Copy the property values of the given source bean into the target bean.
static void	copyProperties(Object source, Object target, Class<?> editable) Copy the property values of the given source bean into the given target bean, only setting properties defined in the given "editable" class (or interface).
static void	copyProperties(Object source, Object target, String[] ignoreProperties) Copy the property values of the given source bean into the given target bean, ignoring the given "ignoreProperties".
static Method	findDeclaredMethod(Class<?> clazz, String methodName, Class<?>[] paramTypes) Find a method with the given method name and the given parameter types, declared on the given class or one of its superclasses.
static Method	findDeclaredMethodWithMinimalParameters(Class<?> clazz, String methodName) Find a method with the given method name and minimal parameters (best case: none), declared on the given class or one of its superclasses.
static PropertyEditor	findEditorByConvention(Class<?> targetType) Find a JavaBeans PropertyEditor following the 'Editor' suffix convention (e.g.
static Method	findMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) Find a method with the given method name and the given parameter types, declared on the given class or one of its superclasses.
static Method	findMethodWithMinimalParameters(Class<?> clazz, String methodName) Find a method with the given method name and minimal parameters (best case: none), declared on the given class or one of its superclasses.
static Method	findMethodWithMinimalParameters(Method[] methods, String methodName) Find a method with the given method name and minimal parameters (best case: none) in the given list of methods.
static PropertyDescriptor	findPropertyForMethod(Method method) Find a JavaBeans PropertyDescriptor for the given method, with the method either being the read method or the write method for that bean property.
static Class<?>	findPropertyType(String propertyName, Class<?>[] beanClasses) Determine the bean property type for the given property from the given classes/interfaces, if possible.
static PropertyDescriptor	getPropertyDescriptor(Class<?> clazz, String propertyName) Retrieve the JavaBeans PropertyDescriptors for the given property.
static PropertyDescriptor[]	getPropertyDescriptors(Class<?> clazz) Retrieve the JavaBeans PropertyDescriptors of a given class.
static MethodParameter	getWriteMethodParameter(PropertyDescriptor pd) Obtain a new MethodParameter object for the write method of the specified property.
static <T> T	instantiate(Class<T> clazz) Convenience method to instantiate a class using its no-arg constructor.
static <T> T	instantiateClass(Class<T> clazz) Convenience method to instantiate a class using its no-arg constructor.
static <T> T	instantiateClass(Constructor<T> ctor, Object... args) Convenience method to instantiate a class using the given constructor.
static boolean	isSimpleProperty(Class<?> clazz) Check if the given type represents a "simple" property: a primitive, a String or other CharSequence, a Number, a Date, a URI, a URL, a Locale, a Class, or a corresponding array.
static boolean	isSimpleValueType(Class<?> clazz) Check if the given type represents a "simple" value type: a primitive, a String or other CharSequence, a Number, a Date, a URI, a URL, a Locale or a Class.
static Method	resolveSignature(String signature, Class<?> clazz) Parse a method signature in the form methodName[([arg_list])], where arg_list is an optional, comma-separated list of fully-qualified type names, and attempts to resolve that signature against the supplied Class.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BeanUtils

public BeanUtils()

Method Detail

instantiate

public static <T> T instantiate(Class<T> clazz)
                     throws BeanInstantiationException

Convenience method to instantiate a class using its no-arg constructor. As this method doesn't try to load classes by name, it should avoid class-loading issues.

Parameters:

clazz - class to instantiate

Returns:

the new instance

Throws:

BeanInstantiationException - if the bean cannot be instantiated

instantiateClass

public static <T> T instantiateClass(Class<T> clazz)
                          throws BeanInstantiationException

Convenience method to instantiate a class using its no-arg constructor. As this method doesn't try to load classes by name, it should avoid class-loading issues.

Note that this method tries to set the constructor accessible if given a non-accessible (that is, non-public) constructor.

Parameters:

clazz - class to instantiate

Returns:

the new instance

Throws:

BeanInstantiationException - if the bean cannot be instantiated

instantiateClass

public static <T> T instantiateClass(Constructor<T> ctor,
                                     Object... args)
                          throws BeanInstantiationException

Convenience method to instantiate a class using the given constructor. As this method doesn't try to load classes by name, it should avoid class-loading issues.

Note that this method tries to set the constructor accessible if given a non-accessible (that is, non-public) constructor.

Parameters:

ctor - the constructor to instantiate

args - the constructor arguments to apply

Returns:

the new instance

Throws:

BeanInstantiationException - if the bean cannot be instantiated

findMethod

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

Find a method with the given method name and the given parameter types, declared on the given class or one of its superclasses. Prefers public methods, but will return a protected, package access, or private method too.

Checks Class.getMethod first, falling back to findDeclaredMethod. This allows to find public methods without issues even in environments with restricted Java security settings.

Parameters:

clazz - the class to check

methodName - the name of the method to find

paramTypes - the parameter types of the method to find

Returns:

the Method object, or null if not found

See Also:

Class.getMethod(java.lang.String, java.lang.Class...), findDeclaredMethod(java.lang.Class, java.lang.String, java.lang.Class[])

findDeclaredMethod

public static Method findDeclaredMethod(Class<?> clazz,
                                        String methodName,
                                        Class<?>[] paramTypes)

Find a method with the given method name and the given parameter types, declared on the given class or one of its superclasses. Will return a public, protected, package access, or private method.

Checks Class.getDeclaredMethod, cascading upwards to all superclasses.

Parameters:

clazz - the class to check

methodName - the name of the method to find

paramTypes - the parameter types of the method to find

Returns:

the Method object, or null if not found

See Also:

Class.getDeclaredMethod(java.lang.String, java.lang.Class...)

findMethodWithMinimalParameters

public static Method findMethodWithMinimalParameters(Class<?> clazz,
                                                     String methodName)
                                              throws IllegalArgumentException

Find a method with the given method name and minimal parameters (best case: none), declared on the given class or one of its superclasses. Prefers public methods, but will return a protected, package access, or private method too.

Checks Class.getMethods first, falling back to findDeclaredMethodWithMinimalParameters. This allows for finding public methods without issues even in environments with restricted Java security settings.

Parameters:

clazz - the class to check

methodName - the name of the method to find

Returns:

the Method object, or null if not found

Throws:

IllegalArgumentException - if methods of the given name were found but could not be resolved to a unique method with minimal parameters

See Also:

Class.getMethods(), findDeclaredMethodWithMinimalParameters(java.lang.Class, java.lang.String)

findDeclaredMethodWithMinimalParameters

public static Method findDeclaredMethodWithMinimalParameters(Class<?> clazz,
                                                             String methodName)
                                                      throws IllegalArgumentException

Find a method with the given method name and minimal parameters (best case: none), declared on the given class or one of its superclasses. Will return a public, protected, package access, or private method.

Checks Class.getDeclaredMethods, cascading upwards to all superclasses.

Parameters:

clazz - the class to check

methodName - the name of the method to find

Returns:

the Method object, or null if not found

Throws:

IllegalArgumentException - if methods of the given name were found but could not be resolved to a unique method with minimal parameters

See Also:

Class.getDeclaredMethods()

findMethodWithMinimalParameters

public static Method findMethodWithMinimalParameters(Method[] methods,
                                                     String methodName)
                                              throws IllegalArgumentException

Find a method with the given method name and minimal parameters (best case: none) in the given list of methods.

Parameters:

methods - the methods to check

methodName - the name of the method to find

Returns:

the Method object, or null if not found

Throws:

IllegalArgumentException - if methods of the given name were found but could not be resolved to a unique method with minimal parameters

resolveSignature

public static Method resolveSignature(String signature,
                                      Class<?> clazz)

Parse a method signature in the form methodName[([arg_list])], where arg_list is an optional, comma-separated list of fully-qualified type names, and attempts to resolve that signature against the supplied Class.

When not supplying an argument list (methodName) the method whose name matches and has the least number of parameters will be returned. When supplying an argument type list, only the method whose name and argument types match will be returned.

Note then that methodName and methodName() are not resolved in the same way. The signature methodName means the method called methodName with the least number of arguments, whereas methodName() means the method called methodName with exactly 0 arguments.

If no method can be found, then null is returned.

Parameters:

signature - the method signature as String representation

clazz - the class to resolve the method signature against

Returns:

the resolved Method

See Also:

findMethod(java.lang.Class, java.lang.String, java.lang.Class...), findMethodWithMinimalParameters(java.lang.Class, java.lang.String)

getPropertyDescriptors

public static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz)
                                                   throws BeansException

Retrieve the JavaBeans PropertyDescriptors of a given class.

Parameters:

clazz - the Class to retrieve the PropertyDescriptors for

Returns:

an array of PropertyDescriptors for the given class

Throws:

BeansException - if PropertyDescriptor look fails

getPropertyDescriptor

public static PropertyDescriptor getPropertyDescriptor(Class<?> clazz,
                                                       String propertyName)
                                                throws BeansException

Retrieve the JavaBeans PropertyDescriptors for the given property.

Parameters:

clazz - the Class to retrieve the PropertyDescriptor for

propertyName - the name of the property

Returns:

the corresponding PropertyDescriptor, or null if none

Throws:

BeansException - if PropertyDescriptor lookup fails

findPropertyForMethod

public static PropertyDescriptor findPropertyForMethod(Method method)
                                                throws BeansException

Find a JavaBeans PropertyDescriptor for the given method, with the method either being the read method or the write method for that bean property.

Parameters:

method - the method to find a corresponding PropertyDescriptor for

Returns:

the corresponding PropertyDescriptor, or null if none

Throws:

BeansException - if PropertyDescriptor lookup fails

findEditorByConvention

public static PropertyEditor findEditorByConvention(Class<?> targetType)

Find a JavaBeans PropertyEditor following the 'Editor' suffix convention (e.g. "mypackage.MyDomainClass" -> "mypackage.MyDomainClassEditor").

Compatible to the standard JavaBeans convention as implemented by PropertyEditorManager but isolated from the latter's registered default editors for primitive types.

Parameters:

targetType - the type to find an editor for

Returns:

the corresponding editor, or null if none found

findPropertyType

public static Class<?> findPropertyType(String propertyName,
                                        Class<?>[] beanClasses)

Determine the bean property type for the given property from the given classes/interfaces, if possible.

Parameters:

propertyName - the name of the bean property

beanClasses - the classes to check against

Returns:

the property type, or Object.class as fallback

getWriteMethodParameter

public static MethodParameter getWriteMethodParameter(PropertyDescriptor pd)

Obtain a new MethodParameter object for the write method of the specified property.

Parameters:

pd - the PropertyDescriptor for the property

Returns:

a corresponding MethodParameter object

isSimpleProperty

public static boolean isSimpleProperty(Class<?> clazz)

Check if the given type represents a "simple" property: a primitive, a String or other CharSequence, a Number, a Date, a URI, a URL, a Locale, a Class, or a corresponding array.

Used to determine properties to check for a "simple" dependency-check.

Parameters:

clazz - the type to check

Returns:

whether the given type represents a "simple" property

See Also:

AbstractBeanDefinition.DEPENDENCY_CHECK_SIMPLE, AbstractAutowireCapableBeanFactory.checkDependencies(java.lang.String, org.springframework.beans.factory.support.AbstractBeanDefinition, java.beans.PropertyDescriptor[], org.springframework.beans.PropertyValues)

isSimpleValueType

public static boolean isSimpleValueType(Class<?> clazz)

Check if the given type represents a "simple" value type: a primitive, a String or other CharSequence, a Number, a Date, a URI, a URL, a Locale or a Class.

Parameters:

clazz - the type to check

Returns:

whether the given type represents a "simple" value type

copyProperties

public static void copyProperties(Object source,
                                  Object target)
                           throws BeansException

Copy the property values of the given source bean into the target bean.

Note: The source and target classes do not have to match or even be derived from each other, as long as the properties match. Any bean properties that the source bean exposes but the target bean does not will silently be ignored.

This is just a convenience method. For more complex transfer needs, consider using a full BeanWrapper.

Parameters:

source - the source bean

target - the target bean

Throws:

BeansException - if the copying failed

See Also:

BeanWrapper

copyProperties

public static void copyProperties(Object source,
                                  Object target,
                                  Class<?> editable)
                           throws BeansException

Copy the property values of the given source bean into the given target bean, only setting properties defined in the given "editable" class (or interface).

Note: The source and target classes do not have to match or even be derived from each other, as long as the properties match. Any bean properties that the source bean exposes but the target bean does not will silently be ignored.

This is just a convenience method. For more complex transfer needs, consider using a full BeanWrapper.

Parameters:

source - the source bean

target - the target bean

editable - the class (or interface) to restrict property setting to

Throws:

BeansException - if the copying failed

See Also:

BeanWrapper

copyProperties

public static void copyProperties(Object source,
                                  Object target,
                                  String[] ignoreProperties)
                           throws BeansException

Copy the property values of the given source bean into the given target bean, ignoring the given "ignoreProperties".

Note: The source and target classes do not have to match or even be derived from each other, as long as the properties match. Any bean properties that the source bean exposes but the target bean does not will silently be ignored.

This is just a convenience method. For more complex transfer needs, consider using a full BeanWrapper.

Parameters:

source - the source bean

target - the target bean

ignoreProperties - array of property names to ignore

Throws:

BeansException - if the copying failed

See Also:

BeanWrapper