Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright 2002-2008 the original author or authors.
3
   *
4
   * Licensed under the Apache License, Version 2.0 (the "License");
5
   * you may not use this file except in compliance with the License.
6
   * You may obtain a copy of the License at
7
   *
8
   *      http://www.apache.org/licenses/LICENSE-2.0
9
   *
10
  * Unless required by applicable law or agreed to in writing, software
11
  * distributed under the License is distributed on an "AS IS" BASIS,
12
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
  * See the License for the specific language governing permissions and
14
  * limitations under the License.
15
  */
16
 
17
 package org.springframework.beans;
18
 
25
 import java.net.URI;
26
 import java.net.URL;
29
 import java.util.Date;
30
 import java.util.List;
32
 import java.util.Map;
34
 
37
 
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(s):
Rod Johnson
Juergen Hoeller
Rob Harrop
54
 
55
 public abstract class BeanUtils {
56
 
57
 	private static final Log logger = LogFactory.getLog(BeanUtils.class);
58
 
59
 	private static final Map unknownEditorTypes = Collections.synchronizedMap(new WeakHashMap());
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
71
 
72
 	public static Object instantiateClass(Class clazz) throws BeanInstantiationException {
73
 		Assert.notNull(clazz, "Class must not be null");
74
 		if (clazz.isInterface()) {
75
 			throw new BeanInstantiationException(clazz, "Specified class is an interface");
76
 		}
77
 		try {
78
 			return instantiateClass(clazz.getDeclaredConstructor((Class[]) null), null);
79
 		}
80
 		catch (NoSuchMethodException ex) {
81
 			throw new BeanInstantiationException(clazz, "No default constructor found", ex);
82
 		}
83
 	}
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
95
 
96
 	public static Object instantiateClass(Constructor ctor, Object[] args) throws BeanInstantiationException {
97
 		Assert.notNull(ctor, "Constructor must not be null");
98
 		try {
99
 			ReflectionUtils.makeAccessible(ctor);
100
			return ctor.newInstance(args);
101
		}
102
		catch (InstantiationException ex) {
104
					"Is it an abstract class?", ex);
105
		}
106
		catch (IllegalAccessException ex) {
108
					"Has the class definition changed? Is the constructor accessible?", ex);
109
		}
112
					"Illegal arguments for constructor", ex);
113
		}
116
					"Constructor threw exception", ex.getTargetException());
117
		}
118
	}
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:
java.lang.Class.getMethod(java.lang.String,java.lang.Class[])
findDeclaredMethod(java.lang.Class,java.lang.String,java.lang.Class[])
134
	public static Method findMethod(Class clazz, String methodName, Class[] paramTypes) {
135
		try {
136
			return clazz.getMethod(methodName, paramTypes);
137
		}
138
		catch (NoSuchMethodException ex) {
139
			return findDeclaredMethod(clazz, methodName, paramTypes);
140
		}
141
	}
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:
java.lang.Class.getDeclaredMethod(java.lang.String,java.lang.Class[])
154
	public static Method findDeclaredMethod(Class clazz, String methodName, Class[] paramTypes) {
155
		try {
156
			return clazz.getDeclaredMethod(methodName, paramTypes);
157
		}
158
		catch (NoSuchMethodException ex) {
159
			if (clazz.getSuperclass() != null) {
160
				return findDeclaredMethod(clazz.getSuperclass(), methodName, paramTypes);
161
			}
162
			return null;
163
		}
164
	}
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 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
Returns:
the Method object, or null if not found
Throws:
java.lang.IllegalArgumentException if methods of the given name were found but could not be resolved to a unique method with minimal parameters
See also:
java.lang.Class.getMethods()
findDeclaredMethodWithMinimalParameters(java.lang.Class,java.lang.String)
181
	public static Method findMethodWithMinimalParameters(Class clazz, String methodName)
184
		Method targetMethod = doFindMethodWithMinimalParameters(clazz.getDeclaredMethods(), methodName);
185
		if (targetMethod == null) {
186
			return findDeclaredMethodWithMinimalParameters(clazz, methodName);
187
		}
188
		return targetMethod;
189
	}
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:
java.lang.IllegalArgumentException if methods of the given name were found but could not be resolved to a unique method with minimal parameters
See also:
java.lang.Class.getDeclaredMethods()
203
	public static Method findDeclaredMethodWithMinimalParameters(Class clazz, String methodName)
206
		Method targetMethod = doFindMethodWithMinimalParameters(clazz.getDeclaredMethods(), methodName);
207
		if (targetMethod == null && clazz.getSuperclass() != null) {
209
		}
210
		return targetMethod;
211
	}
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:
java.lang.IllegalArgumentException if methods of the given name were found but could not be resolved to a unique method with minimal parameters
222
	private static Method doFindMethodWithMinimalParameters(Method[] methods, String methodName)
225
		Method targetMethod = null;
226
		int numMethodsFoundWithCurrentMinimumArgs = 0;
227
		for (int i = 0; i < methods.length; i++) {
228
			if (methods[i].getName().equals(methodName)) {
229
				int numParams = methods[i].getParameterTypes().length;
230
				if (targetMethod == null ||
231
						numParams < targetMethod.getParameterTypes().length) {
232
					targetMethod = methods[i];
233
					numMethodsFoundWithCurrentMinimumArgs = 1;
234
				}
235
				else {
236
					if (targetMethod.getParameterTypes().length == numParams) {
237
						// Additional candidate with same length.
238
						numMethodsFoundWithCurrentMinimumArgs++;
239
					}
240
				}
241
			}
242
		}
243
		if (numMethodsFoundWithCurrentMinimumArgs > 1) {
244
			throw new IllegalArgumentException("Cannot resolve method '" + methodName +
245
					"' to a unique method. Attempted to resolve to overloaded method with " +
246
					"the least number of parameters, but there were " +
247
					numMethodsFoundWithCurrentMinimumArgs + " candidates.");
248
		}
249
		return targetMethod;
250
	}
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)
270
	public static Method resolveSignature(String signature, Class clazz) {
271
		Assert.hasText(signature, "'signature' must not be empty");
272
		Assert.notNull(clazz, "Class must not be null");
274
		int firstParen = signature.indexOf("(");
275
		int lastParen = signature.indexOf(")");
277
		if (firstParen > -1 && lastParen == -1) {
278
			throw new IllegalArgumentException("Invalid method signature '" + signature +
279
					"': expected closing ')' for args list");
280
		}
281
		else if (lastParen > -1 && firstParen == -1) {
282
			throw new IllegalArgumentException("Invalid method signature '" + signature +
283
					"': expected opening '(' for args list");
284
		}
285
		else if (firstParen == -1 && lastParen == -1) {
286
			return findMethodWithMinimalParameters(clazz, signature);
287
		}
288
		else {
289
			String methodName = signature.substring(0, firstParen);
290
			String[] parameterTypeNames =
291
					StringUtils.commaDelimitedListToStringArray(signature.substring(firstParen + 1, lastParen));
292
			Class[] parameterTypes = new Class[parameterTypeNames.length];
293
			for (int i = 0; i < parameterTypeNames.length; i++) {
294
				String parameterTypeName = parameterTypeNames[i].trim();
295
				try {
296
					parameterTypes[i] = ClassUtils.forName(parameterTypeName, clazz.getClassLoader());
297
				}
298
				catch (Throwable ex) {
299
					throw new IllegalArgumentException("Invalid method signature: unable to resolve type [" +
300
							parameterTypeName + "] for argument " + i + ". Root cause: " + ex);
301
				}
302
			}
303
			return findMethod(clazz, methodName, parameterTypes);
304
		}
305
	}
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
314
	public static PropertyDescriptor[] getPropertyDescriptors(Class clazz) throws BeansException {
315
		CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);
317
	}
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
326
	public static PropertyDescriptor getPropertyDescriptor(Class clazz, String propertyName)
327
			throws BeansException {
329
		CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);
330
		return cr.getPropertyDescriptor(propertyName);
331
	}
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
341
	public static PropertyDescriptor findPropertyForMethod(Method method) throws BeansException {
342
		Assert.notNull(method, "Method must not be null");
344
		for (int i = 0; i < pds.length; i++) {
345
			PropertyDescriptor pd = pds[i];
346
			if (method.equals(pd.getReadMethod()) || method.equals(pd.getWriteMethod())) {
347
				return pd;
348
			}
349
		}
350
		return null;
351
	}
Find a JavaBeans PropertyEditor following the 'Editor' suffix convention (e.g. "mypackage.MyDomainClass" -> "mypackage.MyDomainClassEditor").

Compatible to the standard JavaBeans convention as implemented by java.beans.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
362
	public static PropertyEditor findEditorByConvention(Class targetType) {
363
		if (targetType == null || targetType.isArray() || .containsKey(targetType)) {
364
			return null;
365
		}
366
		ClassLoader cl = targetType.getClassLoader();
367
		if (cl == null) {
368
			cl = ClassLoader.getSystemClassLoader();
369
			if (cl == null) {
370
				return null;
371
			}
372
		}
373
		String editorName = targetType.getName() + "Editor";
374
		try {
375
			Class editorClass = cl.loadClass(editorName);
376
			if (!PropertyEditor.class.isAssignableFrom(editorClass)) {
377
				.warn("Editor class [" + editorName +
378
						"] does not implement [java.beans.PropertyEditor] interface");
380
				return null;
381
			}
382
			return (PropertyEditor) instantiateClass(editorClass);
383
		}
384
		catch (ClassNotFoundException ex) {
386
				.debug("No property editor [" + editorName + "] found for type " +
387
						targetType.getName() + " according to 'Editor' suffix convention");
388
			}
390
			return null;
391
		}
392
	}
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
401
	public static Class findPropertyType(String propertyName, Class[] beanClasses) {
402
		if (beanClasses != null) {
403
			for (int i = 0; i < beanClasses.length; i++) {
404
				PropertyDescriptor pd = getPropertyDescriptor(beanClasses[i], propertyName);
405
				if (pd != null) {
406
					return pd.getPropertyType();
407
				}
408
			}
409
		}
410
		return Object.class;
411
	}
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
420
		if (pd instanceof GenericTypeAwarePropertyDescriptor) {
421
			return new MethodParameter(
423
		}
424
		else {
425
			return new MethodParameter(pd.getWriteMethod(), 0);
426
		}
427
	}
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:
org.springframework.beans.factory.support.AbstractBeanDefinition.DEPENDENCY_CHECK_SIMPLE
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.checkDependencies(java.lang.String,org.springframework.beans.factory.support.AbstractBeanDefinition,java.beans.PropertyDescriptor[],org.springframework.beans.PropertyValues)
439
	public static boolean isSimpleProperty(Class clazz) {
440
		Assert.notNull(clazz, "Class must not be null");
441
		return isSimpleValueType(clazz) || (clazz.isArray() && isSimpleValueType(clazz.getComponentType()));
442
	}
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
451
	public static boolean isSimpleValueType(Class clazz) {
452
		return ClassUtils.isPrimitiveOrWrapper(clazz) || CharSequence.class.isAssignableFrom(clazz) ||
453
				Number.class.isAssignableFrom(clazz) || Date.class.isAssignableFrom(clazz) ||
454
				clazz.equals(URI.class) || clazz.equals(URL.class) ||
455
				clazz.equals(Locale.class) || clazz.equals(Class.class);
456
	}
Determine if the given target type is assignable from the given value type, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.

Deprecated:
as of Spring 2.0, in favor of ClassUtils.isAssignable
Parameters:
targetType the target type
valueType the value type that should be assigned to the target type
Returns:
if the target type is assignable from the value type
See also:
org.springframework.util.ClassUtils.isAssignable(java.lang.Class,java.lang.Class)
468
	public static boolean isAssignable(Class targetType, Class valueType) {
469
		return ClassUtils.isAssignable(targetType, valueType);
470
	}
Determine if the given type is assignable from the given value, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.

Deprecated:
as of Spring 2.0, in favor of ClassUtils.isAssignableValue
Parameters:
type the target type
value the value that should be assigned to the type
Returns:
if the type is assignable from the value
See also:
org.springframework.util.ClassUtils.isAssignableValue(java.lang.Class,java.lang.Object)
482
	public static boolean isAssignable(Class type, Object value) {
483
		return ClassUtils.isAssignableValue(type, value);
484
	}
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
499
	public static void copyProperties(Object source, Object target) throws BeansException {
500
		copyProperties(source, target, null, null);
501
	}
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
517
	public static void copyProperties(Object source, Object target, Class editable)
518
			throws BeansException {
520
		copyProperties(source, target, editable, null);
521
	}
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
537
	public static void copyProperties(Object source, Object target, String[] ignoreProperties)
538
			throws BeansException {
540
		copyProperties(source, target, null, ignoreProperties);
541
	}
Copy the property values of the given source bean into the given 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.

Parameters:
source the source bean
target the target bean
editable the class (or interface) to restrict property setting to
ignoreProperties array of property names to ignore
Throws:
BeansException if the copying failed
See also:
BeanWrapper
555
	private static void copyProperties(Object source, Object target, Class editable, String[] ignoreProperties)
556
			throws BeansException {
558
		Assert.notNull(source, "Source must not be null");
559
		Assert.notNull(target, "Target must not be null");
561
		Class actualEditable = target.getClass();
562
		if (editable != null) {
563
			if (!editable.isInstance(target)) {
564
				throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
565
						"] not assignable to Editable class [" + editable.getName() + "]");
566
			}
567
			actualEditable = editable;
568
		}
569
		PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
570
		List ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;
572
		for (int i = 0; i < targetPds.length; i++) {
573
			PropertyDescriptor targetPd = targetPds[i];
574
			if (targetPd.getWriteMethod() != null &&
575
					(ignoreProperties == null || (!ignoreList.contains(targetPd.getName())))) {
576
				PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
577
				if (sourcePd != null && sourcePd.getReadMethod() != null) {
578
					try {
579
						Method readMethod = sourcePd.getReadMethod();
580
						if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
581
							readMethod.setAccessible(true);
582
						}
583
						Object value = readMethod.invoke(source, new Object[0]);
584
						Method writeMethod = targetPd.getWriteMethod();
585
						if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
586
							writeMethod.setAccessible(true);
587
						}
588
						writeMethod.invoke(target, new Object[] {value});
589
					}
590
					catch (Throwable ex) {
591
						throw new FatalBeanException("Could not copy properties from source to target", ex);
592
					}
593
				}
594
			}
595
		}
596
	}
New to GrepCode? Check out our FAQ X