public abstract class BeanUtils extends Object
Mainly for internal use within the framework, but to some degree also useful for application classes. Consider Apache Commons BeanUtils, BULL - Bean Utils Light Library, or similar third-party frameworks for more comprehensive bean utilities.
Constructor and Description |
---|
BeanUtils() |
Modifier and Type | Method and Description |
---|---|
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 PropertyDescriptor |
findPropertyForMethod(Method method,
Class<?> clazz)
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
PropertyDescriptor s 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<?> clazz,
Class<T> assignableTo)
Instantiate a class using its no-arg constructor and return the new instance
as the specified assignable type.
|
static <T> T |
instantiateClass(Class<T> clazz)
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, an enum, 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 . |
public static <T> T instantiate(Class<T> clazz) throws BeanInstantiationException
clazz
- class to instantiateBeanInstantiationException
- if the bean cannot be instantiatedClass.newInstance()
public static <T> T instantiateClass(Class<T> clazz) throws BeanInstantiationException
Note that this method tries to set the constructor accessible if given a non-accessible (that is, non-public) constructor.
clazz
- class to instantiateBeanInstantiationException
- if the bean cannot be instantiatedConstructor.newInstance(java.lang.Object...)
public static <T> T instantiateClass(Class<?> clazz, Class<T> assignableTo) throws BeanInstantiationException
Useful in cases where the type of the class to instantiate (clazz) is not available, but the type desired (assignableTo) is known.
Note that this method tries to set the constructor accessible if given a non-accessible (that is, non-public) constructor.
clazz
- class to instantiateassignableTo
- type that clazz must be assignableToBeanInstantiationException
- if the bean cannot be instantiatedConstructor.newInstance(java.lang.Object...)
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException
Note that this method tries to set the constructor accessible if given a non-accessible (that is, non-public) constructor.
ctor
- the constructor to instantiateargs
- the constructor arguments to applyBeanInstantiationException
- if the bean cannot be instantiatedConstructor.newInstance(java.lang.Object...)
public static Method findMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)
Checks Class.getMethod
first, falling back to
findDeclaredMethod
. This allows to find public methods
without issues even in environments with restricted Java security settings.
clazz
- the class to checkmethodName
- the name of the method to findparamTypes
- the parameter types of the method to findnull
if not foundClass.getMethod(java.lang.String, java.lang.Class<?>...)
,
findDeclaredMethod(java.lang.Class<?>, java.lang.String, java.lang.Class<?>...)
public static Method findDeclaredMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)
Checks Class.getDeclaredMethod
, cascading upwards to all superclasses.
clazz
- the class to checkmethodName
- the name of the method to findparamTypes
- the parameter types of the method to findnull
if not foundClass.getDeclaredMethod(java.lang.String, java.lang.Class<?>...)
public static Method findMethodWithMinimalParameters(Class<?> clazz, String methodName) throws IllegalArgumentException
Checks Class.getMethods
first, falling back to
findDeclaredMethodWithMinimalParameters
. This allows for finding public
methods without issues even in environments with restricted Java security settings.
clazz
- the class to checkmethodName
- the name of the method to findnull
if not foundIllegalArgumentException
- if methods of the given name were found but
could not be resolved to a unique method with minimal parametersClass.getMethods()
,
findDeclaredMethodWithMinimalParameters(java.lang.Class<?>, java.lang.String)
public static Method findDeclaredMethodWithMinimalParameters(Class<?> clazz, String methodName) throws IllegalArgumentException
Checks Class.getDeclaredMethods
, cascading upwards to all superclasses.
clazz
- the class to checkmethodName
- the name of the method to findnull
if not foundIllegalArgumentException
- if methods of the given name were found but
could not be resolved to a unique method with minimal parametersClass.getDeclaredMethods()
public static Method findMethodWithMinimalParameters(Method[] methods, String methodName) throws IllegalArgumentException
methods
- the methods to checkmethodName
- the name of the method to findnull
if not foundIllegalArgumentException
- if methods of the given name were found but
could not be resolved to a unique method with minimal parameterspublic static Method resolveSignature(String signature, Class<?> clazz)
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.
signature
- the method signature as String representationclazz
- the class to resolve the method signature againstfindMethod(java.lang.Class<?>, java.lang.String, java.lang.Class<?>...)
,
findMethodWithMinimalParameters(java.lang.Class<?>, java.lang.String)
public static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz) throws BeansException
PropertyDescriptor
s of a given class.clazz
- the Class to retrieve the PropertyDescriptors forPropertyDescriptors
for the given classBeansException
- if PropertyDescriptor look failspublic static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String propertyName) throws BeansException
PropertyDescriptors
for the given property.clazz
- the Class to retrieve the PropertyDescriptor forpropertyName
- the name of the propertynull
if noneBeansException
- if PropertyDescriptor lookup failspublic static PropertyDescriptor findPropertyForMethod(Method method) throws BeansException
PropertyDescriptor
for the given method,
with the method either being the read method or the write method for
that bean property.method
- the method to find a corresponding PropertyDescriptor for,
introspecting its declaring classnull
if noneBeansException
- if PropertyDescriptor lookup failspublic static PropertyDescriptor findPropertyForMethod(Method method, Class<?> clazz) throws BeansException
PropertyDescriptor
for the given method,
with the method either being the read method or the write method for
that bean property.method
- the method to find a corresponding PropertyDescriptor forclazz
- the (most specific) class to introspect for descriptorsnull
if noneBeansException
- if PropertyDescriptor lookup failspublic static PropertyEditor findEditorByConvention(Class<?> targetType)
Compatible to the standard JavaBeans convention as implemented by
PropertyEditorManager
but isolated from the latter's
registered default editors for primitive types.
targetType
- the type to find an editor fornull
if none foundpublic static Class<?> findPropertyType(String propertyName, Class<?>... beanClasses)
propertyName
- the name of the bean propertybeanClasses
- the classes to check againstObject.class
as fallbackpublic static MethodParameter getWriteMethodParameter(PropertyDescriptor pd)
pd
- the PropertyDescriptor for the propertypublic static boolean isSimpleProperty(Class<?> clazz)
Used to determine properties to check for a "simple" dependency-check.
clazz
- the type to checkAbstractBeanDefinition.DEPENDENCY_CHECK_SIMPLE
,
AbstractAutowireCapableBeanFactory.checkDependencies(java.lang.String, org.springframework.beans.factory.support.AbstractBeanDefinition, java.beans.PropertyDescriptor[], org.springframework.beans.PropertyValues)
public static boolean isSimpleValueType(Class<?> clazz)
clazz
- the type to checkpublic static void copyProperties(Object source, Object target) throws BeansException
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.
source
- the source beantarget
- the target beanBeansException
- if the copying failedBeanWrapper
public static void copyProperties(Object source, Object target, Class<?> editable) throws BeansException
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.
source
- the source beantarget
- the target beaneditable
- the class (or interface) to restrict property setting toBeansException
- if the copying failedBeanWrapper
public static void copyProperties(Object source, Object target, String... ignoreProperties) throws BeansException
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.
source
- the source beantarget
- the target beanignoreProperties
- array of property names to ignoreBeansException
- if the copying failedBeanWrapper