GrepCode: org.springframework.beans.BeanUtils (.java) - Class

Maven-Central
/
org.springframework / spring-beans
/
1.2.1

3.1.1.RELEASE
2.5.1
2.5
1.2.7
1.2.6
1.2.5
1.2.3
1.2.2
1.2.1
/
org.springframework.beans.BeanUtils
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
  /*
2
   * Copyright 2002-2005 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
 
19
 import java.beans.PropertyDescriptor;
20
 import java.lang.reflect.Constructor;
21
 import java.lang.reflect.InvocationTargetException;
22
 import java.lang.reflect.Method;
23
 import java.lang.reflect.Modifier;
24
 import java.util.Arrays;
25
 import java.util.HashMap;
26
 import java.util.List;
27
 import java.util.Map;
28
 
29
 import org.springframework.util.Assert;

 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 JohnsonJuergen HoellerRob Harrop
41
 
42
 public abstract class BeanUtils {

	
 Map with primitive wrapper type as key and corresponding primitive
 type as value, for example: Integer.class -> int.class
 
47
 
48
 	private static final Map primitiveWrapperTypeMap = new HashMap(8);
49
 	static {
50
 		primitiveWrapperTypeMap.put(Boolean.class, boolean.class);
51
 		primitiveWrapperTypeMap.put(Byte.class, byte.class);
52
 		primitiveWrapperTypeMap.put(Character.class, char.class);
53
 		primitiveWrapperTypeMap.put(Short.class, short.class);
54
 		primitiveWrapperTypeMap.put(Integer.class, int.class);
55
 		primitiveWrapperTypeMap.put(Long.class, long.class);
56
 		primitiveWrapperTypeMap.put(Float.class, float.class);
57
 		primitiveWrapperTypeMap.put(Double.class, double.class);
58
 	}

	
 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 (i.e. non-public) constructor.
 
 Parameters:clazz class to instantiate Returns:the new instance
68
 
69
 	public static Object instantiateClass(Class clazz) throws BeansException {
70
 		Assert.notNull(clazz, "clazz must not be null");
71
 		if (clazz.isInterface()) {
72
 			throw new FatalBeanException(
73
 					"Class [" + clazz.getName() + "] cannot be instantiated: it is an interface");
74
 		}
75
 		try {
76
 			return instantiateClass(clazz.getDeclaredConstructor((Class[]) null), null);
77
 		}
78
 		catch (NoSuchMethodException ex) {
79
 			throw new FatalBeanException("Could not instantiate class [" + clazz.getName() +
80
 					"]: no default constructor found", ex);
81
 		}
82
 	}

	
 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 (i.e. non-public) constructor.
 
 Parameters:ctor constructor to instantiate Returns:the new instance
92
 
93
 	public static Object instantiateClass(Constructor ctor, Object[] args) throws BeansException {
94
 		Assert.notNull(ctor, "ctor must not be null");
95
 		try {
96
 			if (!Modifier.isPublic(ctor.getModifiers()) ||
97
 					!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) {
98
 				ctor.setAccessible(true);
99
 			}
100
			return ctor.newInstance(args);
101
		}
102
		catch (InstantiationException ex) {
103
			throw new FatalBeanException("Could not instantiate class [" + ctor.getDeclaringClass().getName() +
104
					"]: Is it an abstract class?", ex);
105
		}
106
		catch (IllegalAccessException ex) {
107
			throw new FatalBeanException("Could not instantiate class [" + ctor.getDeclaringClass().getName() +
108
					"]: Has the class definition changed? Is the constructor accessible?", ex);
109
		}
110
		catch (IllegalArgumentException ex) {
111
			throw new FatalBeanException("Could not instantiate class [" + ctor.getDeclaringClass().getName() +
112
					"]: illegal args for constructor", ex);
113
		}
114
		catch (InvocationTargetException ex) {
115
			throw new FatalBeanException("Could not instantiate class [" + ctor.getDeclaringClass().getName() +
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 checkmethodName the name of the method to findparamTypes 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[])
133
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 checkmethodName the name of the method to findparamTypes 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[])
153
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 checkmethodName the name of the method to find Returns:the method object, or null if not found See also:java.lang.Class.getMethods()findDeclaredMethodWithMinimalParameters(java.lang.Class,java.lang.String)
178
179
	public static Method findMethodWithMinimalParameters(Class clazz, String methodName) {
180
		Method[] methods = clazz.getMethods();
181
		Method targetMethod = null;
182
		for (int i = 0; i < methods.length; i++) {
183
			if (methods[i].getName().equals(methodName)) {
184
				if (targetMethod == null ||
185
						methods[i].getParameterTypes().length < targetMethod.getParameterTypes().length) {
186
					targetMethod = methods[i];
187
				}
188
			}
189
		}
190
		if (targetMethod != null) {
191
			return targetMethod;
192
		}
193
		else {
194
			return findDeclaredMethodWithMinimalParameters(clazz, methodName);
195
		}
196
	}

	
 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 checkmethodName the name of the method to find Returns:the method object, or null if not found See also:java.lang.Class.getDeclaredMethods()
207
208
	public static Method findDeclaredMethodWithMinimalParameters(Class clazz, String methodName) {
209
		Method[] methods = clazz.getDeclaredMethods();
210
		Method targetMethod = null;
211
		for (int i = 0; i < methods.length; i++) {
212
			if (methods[i].getName().equals(methodName)) {
213
				if (targetMethod == null ||
214
						methods[i].getParameterTypes().length < targetMethod.getParameterTypes().length) {
215
					targetMethod = methods[i];
216
				}
217
			}
218
		}
219
		if (targetMethod != null) {
220
			return targetMethod;
221
		}
222
		else {
223
			if (clazz.getSuperclass() != null) {
224
				return findDeclaredMethodWithMinimalParameters(clazz.getSuperclass(), methodName);
225
			}
226
			return null;
227
		}
228
	}

	
 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.
 For example used in a bean factory's constructor resolution.
 
 Parameters:type the target typevalue the value that should be assigned to the type Returns:if the type is assignable from the value
238
239
	public static boolean isAssignable(Class type, Object value) {
240
		Assert.notNull(type, "type must not be null");
241
		return (value != null ? isAssignable(type, value.getClass()) : !type.isPrimitive());
242
	}

	
 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.
 For example used in BeanWrapperImpl's custom editor matrching.
 
 Parameters:targetType the target typevalueType the value type that should be assigned to the target type Returns:if the target type is assignable from the value type
252
253
	public static boolean isAssignable(Class targetType, Class valueType) {
254
		Assert.notNull(targetType, "targetType must not be null");
255
		Assert.notNull(valueType, "valueType must not be null");
256
		return (targetType.isAssignableFrom(valueType) ||
257
				targetType.equals(primitiveWrapperTypeMap.get(valueType)));
258
	}

	
 Check if the given class represents a "simple" property,
 i.e. a primitive, a String, a Class, or a corresponding array.
 Used to determine properties to check for a "simple" dependency-check.
 
 See also:org.springframework.beans.factory.support.AbstractBeanDefinition.DEPENDENCY_CHECK_SIMPLEorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.checkDependencies(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition,org.springframework.beans.BeanWrapper,org.springframework.beans.PropertyValues)
266
267
	public static boolean isSimpleProperty(Class clazz) {
268
		Assert.notNull(clazz, "clazz must not be null");
269
		return clazz.isPrimitive() || isPrimitiveArray(clazz) ||
270
				isPrimitiveWrapper(clazz) || isPrimitiveWrapperArray(clazz) ||
271
				clazz.equals(String.class) || clazz.equals(String[].class) ||
272
				clazz.equals(Class.class) || clazz.equals(Class[].class);
273
	}

	
 Check if the given class represents an array of primitives,
 i.e. boolean, byte, char, short, int, long, float, or double.
 
278
279
	public static boolean isPrimitiveArray(Class clazz) {
280
		return (clazz.isArray() && clazz.getComponentType().isPrimitive());
281
	}

	
 Check if the given class represents a primitive wrapper,
 i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.
 
286
287
	public static boolean isPrimitiveWrapper(Class clazz) {
288
		return primitiveWrapperTypeMap.containsKey(clazz);
289
	}

	
 Check if the given class represents an array of primitive wrappers,
 i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.
 
294
295
	public static boolean isPrimitiveWrapperArray(Class clazz) {
296
		return (clazz.isArray() && isPrimitiveWrapper(clazz.getComponentType()));
297
	}

	
 Copy the property values of the given source bean into the target bean.
 
 Parameters:source source beantarget target bean Throws:java.lang.IllegalArgumentException if the classes of source and target do not match
304
305
	public static void copyProperties(Object source, Object target)
306
			throws IllegalArgumentException, BeansException {
307
		copyProperties(source, target, null);
308
	}

	
 Copy the property values of the given source bean into the given target bean,
 ignoring the given ignoreProperties.
 
 Parameters:source the source beantarget the target beanignoreProperties array of property names to ignore Throws:java.lang.IllegalArgumentException if the classes of source and target do not match
317
318
	public static void copyProperties(Object source, Object target, String[] ignoreProperties)
319
			throws IllegalArgumentException, BeansException {
320
		Assert.notNull(source, "source must not be null");
321
		Assert.notNull(target, "source must not be null");
322
		List ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;
323
		BeanWrapper sourceBw = new BeanWrapperImpl(source);
324
		BeanWrapper targetBw = new BeanWrapperImpl(target);
325
		MutablePropertyValues values = new MutablePropertyValues();
326
		for (int i = 0; i < sourceBw.getPropertyDescriptors().length; i++) {
327
			PropertyDescriptor sourceDesc = sourceBw.getPropertyDescriptors()[i];
328
			String name = sourceDesc.getName();
329
			if (ignoreProperties == null || (!ignoreList.contains(name))) {
330
				PropertyDescriptor targetDesc = targetBw.getPropertyDescriptor(name);
331
				if (targetDesc.getWriteMethod() != null && targetDesc.getReadMethod() != null) {
332
					values.addPropertyValue(new PropertyValue(name, sourceBw.getPropertyValue(name)));
333
				}
334
			}
335
		}
336
		targetBw.setPropertyValues(values);
337
	}

	
 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
344
345
	public static PropertyDescriptor[] getPropertyDescriptors(Class clazz) throws BeansException {
346
		CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);
347
		return cr.getBeanInfo().getPropertyDescriptors();
348
	}

	
 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 look fails
357
358
	public static PropertyDescriptor findPropertyForMethod(Method method) throws BeansException {
359
		Assert.notNull(method, "method must not be null");
360
		PropertyDescriptor[] pds = getPropertyDescriptors(method.getDeclaringClass());
361
		for (int i = 0; i < pds.length; i++) {
362
			if (method.equals(pds[i].getReadMethod()) || method.equals(pds[i].getWriteMethod())) {
363
				return pds[i];
364
			}
365
		}
366
		return null;
367
	}
368
369
}