📄 propertyutilsbean.java
字号:
/**
* <p>Retrieve the property descriptors for the specified class,
* introspecting and caching them the first time a particular bean class
* is encountered.</p>
*
* <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
*
* @param beanClass Bean class for which property descriptors are requested
* @return the property descriptors
*
* @exception IllegalArgumentException if <code>beanClass</code> is null
*/
public PropertyDescriptor[]
getPropertyDescriptors(Class beanClass) {
if (beanClass == null) {
throw new IllegalArgumentException("No bean class specified");
}
// Look up any cached descriptors for this bean class
PropertyDescriptor[] descriptors = null;
descriptors =
(PropertyDescriptor[]) descriptorsCache.get(beanClass);
if (descriptors != null) {
return (descriptors);
}
// Introspect the bean and cache the generated descriptors
BeanInfo beanInfo = null;
try {
beanInfo = Introspector.getBeanInfo(beanClass);
} catch (IntrospectionException e) {
return (new PropertyDescriptor[0]);
}
descriptors = beanInfo.getPropertyDescriptors();
if (descriptors == null) {
descriptors = new PropertyDescriptor[0];
}
// ----------------- Workaround for Bug 28358 --------- START ------------------
//
// The following code fixes an issue where IndexedPropertyDescriptor behaves
// Differently in different versions of the JDK for 'indexed' properties which
// use java.util.List (rather than an array).
//
// If you have a Bean with the following getters/setters for an indexed property:
//
// public List getFoo()
// public Object getFoo(int index)
// public void setFoo(List foo)
// public void setFoo(int index, Object foo)
//
// then the IndexedPropertyDescriptor's getReadMethod() and getWriteMethod()
// behave as follows:
//
// JDK 1.3.1_04: returns valid Method objects from these methods.
// JDK 1.4.2_05: returns null from these methods.
//
for (int i = 0; i < descriptors.length; i++) {
if (descriptors[i] instanceof IndexedPropertyDescriptor) {
IndexedPropertyDescriptor descriptor = (IndexedPropertyDescriptor)descriptors[i];
String propName = descriptor.getName().substring(0, 1).toUpperCase() +
descriptor.getName().substring(1);
if (descriptor.getReadMethod() == null) {
String methodName = descriptor.getIndexedReadMethod() != null
? descriptor.getIndexedReadMethod().getName()
: "get" + propName;
Method readMethod = MethodUtils.getMatchingAccessibleMethod(beanClass,
methodName,
EMPTY_CLASS_PARAMETERS);
if (readMethod != null) {
try {
descriptor.setReadMethod(readMethod);
} catch(Exception e) {
log.error("Error setting indexed property read method", e);
}
}
}
if (descriptor.getWriteMethod() == null) {
String methodName = descriptor.getIndexedWriteMethod() != null
? descriptor.getIndexedWriteMethod().getName()
: "set" + propName;
Method writeMethod = MethodUtils.getMatchingAccessibleMethod(beanClass,
methodName,
LIST_CLASS_PARAMETER);
if (writeMethod == null) {
Method[] methods = beanClass.getMethods();
for (int j = 0; j < methods.length; j++) {
if (methods[j].getName().equals(methodName)) {
Class[] parameterTypes = methods[j].getParameterTypes();
if (parameterTypes.length == 1 &&
List.class.isAssignableFrom(parameterTypes[0])) {
writeMethod = methods[j];
break;
}
}
}
}
if (writeMethod != null) {
try {
descriptor.setWriteMethod(writeMethod);
} catch(Exception e) {
log.error("Error setting indexed property write method", e);
}
}
}
}
}
// ----------------- Workaround for Bug 28358 ---------- END -------------------
descriptorsCache.put(beanClass, descriptors);
return (descriptors);
}
/**
* <p>Retrieve the property descriptors for the specified bean,
* introspecting and caching them the first time a particular bean class
* is encountered.</p>
*
* <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
*
* @param bean Bean for which property descriptors are requested
* @return the property descriptors
*
* @exception IllegalArgumentException if <code>bean</code> is null
*/
public PropertyDescriptor[] getPropertyDescriptors(Object bean) {
if (bean == null) {
throw new IllegalArgumentException("No bean specified");
}
return (getPropertyDescriptors(bean.getClass()));
}
/**
* <p>Return the Java Class repesenting the property editor class that has
* been registered for this property (if any). This method follows the
* same name resolution rules used by <code>getPropertyDescriptor()</code>,
* so if the last element of a name reference is indexed, the property
* editor for the underlying property's class is returned.</p>
*
* <p>Note that <code>null</code> will be returned if there is no property,
* or if there is no registered property editor class. Because this
* return value is ambiguous, you should determine the existence of the
* property itself by other means.</p>
*
* <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
*
* @param bean Bean for which a property descriptor is requested
* @param name Possibly indexed and/or nested name of the property for
* which a property descriptor is requested
* @return the property editor class
*
* @exception IllegalAccessException if the caller does not have
* access to the property accessor method
* @exception IllegalArgumentException if <code>bean</code> or
* <code>name</code> is null
* @exception IllegalArgumentException if a nested reference to a
* property returns null
* @exception InvocationTargetException if the property accessor method
* throws an exception
* @exception NoSuchMethodException if an accessor method for this
* propety cannot be found
*/
public Class getPropertyEditorClass(Object bean, String name)
throws IllegalAccessException, InvocationTargetException,
NoSuchMethodException {
if (bean == null) {
throw new IllegalArgumentException("No bean specified");
}
if (name == null) {
throw new IllegalArgumentException("No name specified for bean class '" +
bean.getClass() + "'");
}
PropertyDescriptor descriptor =
getPropertyDescriptor(bean, name);
if (descriptor != null) {
return (descriptor.getPropertyEditorClass());
} else {
return (null);
}
}
/**
* Return the Java Class representing the property type of the specified
* property, or <code>null</code> if there is no such property for the
* specified bean. This method follows the same name resolution rules
* used by <code>getPropertyDescriptor()</code>, so if the last element
* of a name reference is indexed, the type of the property itself will
* be returned. If the last (or only) element has no property with the
* specified name, <code>null</code> is returned.
*
* @param bean Bean for which a property descriptor is requested
* @param name Possibly indexed and/or nested name of the property for
* which a property descriptor is requested
* @return The property type
*
* @exception IllegalAccessException if the caller does not have
* access to the property accessor method
* @exception IllegalArgumentException if <code>bean</code> or
* <code>name</code> is null
* @exception IllegalArgumentException if a nested reference to a
* property returns null
* @exception InvocationTargetException if the property accessor method
* throws an exception
* @exception NoSuchMethodException if an accessor method for this
* propety cannot be found
*/
public Class getPropertyType(Object bean, String name)
throws IllegalAccessException, InvocationTargetException,
NoSuchMethodException {
if (bean == null) {
throw new IllegalArgumentException("No bean specified");
}
if (name == null) {
throw new IllegalArgumentException("No name specified for bean class '" +
bean.getClass() + "'");
}
// Special handling for DynaBeans
if (bean instanceof DynaBean) {
DynaProperty descriptor =
((DynaBean) bean).getDynaClass().getDynaProperty(name);
if (descriptor == null) {
return (null);
}
Class type = descriptor.getType();
if (type == null) {
return (null);
} else if (type.isArray()) {
return (type.getComponentType());
} else {
return (type);
}
}
PropertyDescriptor descriptor =
getPropertyDescriptor(bean, name);
if (descriptor == null) {
return (null);
} else if (descriptor instanceof IndexedPropertyDescriptor) {
return (((IndexedPropertyDescriptor) descriptor).
getIndexedPropertyType());
} else if (descriptor instanceof MappedPropertyDescriptor) {
return (((MappedPropertyDescriptor) descriptor).
getMappedPropertyType());
} else {
return (descriptor.getPropertyType());
}
}
/**
* <p>Return an accessible property getter method for this property,
* if there is one; otherwise return <code>null</code>.</p>
*
* <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
*
* @param descriptor Property descriptor to return a getter for
* @return The read method
*/
public Method getReadMethod(PropertyDescriptor descriptor) {
return (MethodUtils.getAccessibleMethod(descriptor.getReadMethod()));
}
/**
* Return the value of the specified simple property of the specified
* bean, with no type conversions.
*
* @param bean Bean whose property is to be extracted
* @param name Name of the property to be extracted
* @return The property value
*
* @exception IllegalAccessException if the caller does not have
* access to the property accessor method
* @exception IllegalArgumentException if <code>bean</code> or
* <code>name</code> is null
* @exception IllegalArgumentException if the property name
* is nested or indexed
* @exception InvocationTargetException if the property accessor method
* throws an exception
* @exception NoSuchMethodException if an accessor method for this
* propety cannot be found
*/
public Object getSimpleProperty(Object bean, String name)
throws IllegalAccessException, InvocationTargetException,
NoSuchMethodException {
if (bean == null) {
throw new IllegalArgumentException("No bean specified");
}
if (name == null) {
throw new IllegalArgumentException("No name specified for bean class '" +
bean.getClass() + "'");
}
// Validate the syntax of the property name
if (resolver.hasNested(name)) {
throw new IllegalArgumentException
("Nested property names are not allowed: Property '" +
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -