You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1634 lines
65 KiB
1634 lines
65 KiB
/*
|
|
* Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package java.beans;
|
|
|
|
import com.sun.beans.TypeResolver;
|
|
import com.sun.beans.WeakCache;
|
|
import com.sun.beans.finder.ClassFinder;
|
|
import com.sun.beans.finder.MethodFinder;
|
|
|
|
import java.awt.Component;
|
|
|
|
import java.lang.ref.Reference;
|
|
import java.lang.ref.SoftReference;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Modifier;
|
|
import java.lang.reflect.Type;
|
|
|
|
import java.util.Map;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.EventListener;
|
|
import java.util.EventObject;
|
|
import java.util.List;
|
|
import java.util.TreeMap;
|
|
|
|
import sun.reflect.misc.ReflectUtil;
|
|
|
|
/**
|
|
* The Introspector class provides a standard way for tools to learn about
|
|
* the properties, events, and methods supported by a target Java Bean.
|
|
* <p>
|
|
* For each of those three kinds of information, the Introspector will
|
|
* separately analyze the bean's class and superclasses looking for
|
|
* either explicit or implicit information and use that information to
|
|
* build a BeanInfo object that comprehensively describes the target bean.
|
|
* <p>
|
|
* For each class "Foo", explicit information may be available if there exists
|
|
* a corresponding "FooBeanInfo" class that provides a non-null value when
|
|
* queried for the information. We first look for the BeanInfo class by
|
|
* taking the full package-qualified name of the target bean class and
|
|
* appending "BeanInfo" to form a new class name. If this fails, then
|
|
* we take the final classname component of this name, and look for that
|
|
* class in each of the packages specified in the BeanInfo package search
|
|
* path.
|
|
* <p>
|
|
* Thus for a class such as "sun.xyz.OurButton" we would first look for a
|
|
* BeanInfo class called "sun.xyz.OurButtonBeanInfo" and if that failed we'd
|
|
* look in each package in the BeanInfo search path for an OurButtonBeanInfo
|
|
* class. With the default search path, this would mean looking for
|
|
* "sun.beans.infos.OurButtonBeanInfo".
|
|
* <p>
|
|
* If a class provides explicit BeanInfo about itself then we add that to
|
|
* the BeanInfo information we obtained from analyzing any derived classes,
|
|
* but we regard the explicit information as being definitive for the current
|
|
* class and its base classes, and do not proceed any further up the superclass
|
|
* chain.
|
|
* <p>
|
|
* If we don't find explicit BeanInfo on a class, we use low-level
|
|
* reflection to study the methods of the class and apply standard design
|
|
* patterns to identify property accessors, event sources, or public
|
|
* methods. We then proceed to analyze the class's superclass and add
|
|
* in the information from it (and possibly on up the superclass chain).
|
|
* <p>
|
|
* For more information about introspection and design patterns, please
|
|
* consult the
|
|
* <a href="http://www.oracle.com/technetwork/java/javase/documentation/spec-136004.html">JavaBeans™ specification</a>.
|
|
*/
|
|
|
|
public class Introspector {
|
|
|
|
// Flags that can be used to control getBeanInfo:
|
|
/**
|
|
* Flag to indicate to use of all beaninfo.
|
|
*/
|
|
public final static int USE_ALL_BEANINFO = 1;
|
|
/**
|
|
* Flag to indicate to ignore immediate beaninfo.
|
|
*/
|
|
public final static int IGNORE_IMMEDIATE_BEANINFO = 2;
|
|
/**
|
|
* Flag to indicate to ignore all beaninfo.
|
|
*/
|
|
public final static int IGNORE_ALL_BEANINFO = 3;
|
|
|
|
// Static Caches to speed up introspection.
|
|
private static final WeakCache<Class<?>, Method[]> declaredMethodCache = new WeakCache<>();
|
|
|
|
private Class<?> beanClass;
|
|
private BeanInfo explicitBeanInfo;
|
|
private BeanInfo superBeanInfo;
|
|
private BeanInfo additionalBeanInfo[];
|
|
|
|
private boolean propertyChangeSource = false;
|
|
private static Class<EventListener> eventListenerType = EventListener.class;
|
|
|
|
// These should be removed.
|
|
private String defaultEventName;
|
|
private String defaultPropertyName;
|
|
private int defaultEventIndex = -1;
|
|
private int defaultPropertyIndex = -1;
|
|
|
|
// Methods maps from Method names to MethodDescriptors
|
|
private Map<String, MethodDescriptor> methods;
|
|
|
|
// properties maps from String names to PropertyDescriptors
|
|
private Map<String, PropertyDescriptor> properties;
|
|
|
|
// events maps from String names to EventSetDescriptors
|
|
private Map<String, EventSetDescriptor> events;
|
|
|
|
private final static EventSetDescriptor[] EMPTY_EVENTSETDESCRIPTORS = new EventSetDescriptor[0];
|
|
|
|
static final String ADD_PREFIX = "add";
|
|
static final String REMOVE_PREFIX = "remove";
|
|
static final String GET_PREFIX = "get";
|
|
static final String SET_PREFIX = "set";
|
|
static final String IS_PREFIX = "is";
|
|
|
|
//======================================================================
|
|
// Public methods
|
|
//======================================================================
|
|
|
|
/**
|
|
* Introspect on a Java Bean and learn about all its properties, exposed
|
|
* methods, and events.
|
|
* <p>
|
|
* If the BeanInfo class for a Java Bean has been previously Introspected
|
|
* then the BeanInfo class is retrieved from the BeanInfo cache.
|
|
*
|
|
* @param beanClass The bean class to be analyzed.
|
|
* @return A BeanInfo object describing the target bean.
|
|
* @exception IntrospectionException if an exception occurs during
|
|
* introspection.
|
|
* @see #flushCaches
|
|
* @see #flushFromCaches
|
|
*/
|
|
public static BeanInfo getBeanInfo(Class<?> beanClass)
|
|
throws IntrospectionException
|
|
{
|
|
if (!ReflectUtil.isPackageAccessible(beanClass)) {
|
|
return (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo();
|
|
}
|
|
ThreadGroupContext context = ThreadGroupContext.getContext();
|
|
BeanInfo beanInfo;
|
|
synchronized (declaredMethodCache) {
|
|
beanInfo = context.getBeanInfo(beanClass);
|
|
}
|
|
if (beanInfo == null) {
|
|
beanInfo = new Introspector(beanClass, null, USE_ALL_BEANINFO).getBeanInfo();
|
|
synchronized (declaredMethodCache) {
|
|
context.putBeanInfo(beanClass, beanInfo);
|
|
}
|
|
}
|
|
return beanInfo;
|
|
}
|
|
|
|
/**
|
|
* Introspect on a Java bean and learn about all its properties, exposed
|
|
* methods, and events, subject to some control flags.
|
|
* <p>
|
|
* If the BeanInfo class for a Java Bean has been previously Introspected
|
|
* based on the same arguments then the BeanInfo class is retrieved
|
|
* from the BeanInfo cache.
|
|
*
|
|
* @param beanClass The bean class to be analyzed.
|
|
* @param flags Flags to control the introspection.
|
|
* If flags == USE_ALL_BEANINFO then we use all of the BeanInfo
|
|
* classes we can discover.
|
|
* If flags == IGNORE_IMMEDIATE_BEANINFO then we ignore any
|
|
* BeanInfo associated with the specified beanClass.
|
|
* If flags == IGNORE_ALL_BEANINFO then we ignore all BeanInfo
|
|
* associated with the specified beanClass or any of its
|
|
* parent classes.
|
|
* @return A BeanInfo object describing the target bean.
|
|
* @exception IntrospectionException if an exception occurs during
|
|
* introspection.
|
|
*/
|
|
public static BeanInfo getBeanInfo(Class<?> beanClass, int flags)
|
|
throws IntrospectionException {
|
|
return getBeanInfo(beanClass, null, flags);
|
|
}
|
|
|
|
/**
|
|
* Introspect on a Java bean and learn all about its properties, exposed
|
|
* methods, below a given "stop" point.
|
|
* <p>
|
|
* If the BeanInfo class for a Java Bean has been previously Introspected
|
|
* based on the same arguments, then the BeanInfo class is retrieved
|
|
* from the BeanInfo cache.
|
|
* @return the BeanInfo for the bean
|
|
* @param beanClass The bean class to be analyzed.
|
|
* @param stopClass The baseclass at which to stop the analysis. Any
|
|
* methods/properties/events in the stopClass or in its baseclasses
|
|
* will be ignored in the analysis.
|
|
* @exception IntrospectionException if an exception occurs during
|
|
* introspection.
|
|
*/
|
|
public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass)
|
|
throws IntrospectionException {
|
|
return getBeanInfo(beanClass, stopClass, USE_ALL_BEANINFO);
|
|
}
|
|
|
|
/**
|
|
* Introspect on a Java Bean and learn about all its properties,
|
|
* exposed methods and events, below a given {@code stopClass} point
|
|
* subject to some control {@code flags}.
|
|
* <dl>
|
|
* <dt>USE_ALL_BEANINFO</dt>
|
|
* <dd>Any BeanInfo that can be discovered will be used.</dd>
|
|
* <dt>IGNORE_IMMEDIATE_BEANINFO</dt>
|
|
* <dd>Any BeanInfo associated with the specified {@code beanClass} will be ignored.</dd>
|
|
* <dt>IGNORE_ALL_BEANINFO</dt>
|
|
* <dd>Any BeanInfo associated with the specified {@code beanClass}
|
|
* or any of its parent classes will be ignored.</dd>
|
|
* </dl>
|
|
* Any methods/properties/events in the {@code stopClass}
|
|
* or in its parent classes will be ignored in the analysis.
|
|
* <p>
|
|
* If the BeanInfo class for a Java Bean has been
|
|
* previously introspected based on the same arguments then
|
|
* the BeanInfo class is retrieved from the BeanInfo cache.
|
|
*
|
|
* @param beanClass the bean class to be analyzed
|
|
* @param stopClass the parent class at which to stop the analysis
|
|
* @param flags flags to control the introspection
|
|
* @return a BeanInfo object describing the target bean
|
|
* @exception IntrospectionException if an exception occurs during introspection
|
|
*
|
|
* @since 1.7
|
|
*/
|
|
public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass,
|
|
int flags) throws IntrospectionException {
|
|
BeanInfo bi;
|
|
if (stopClass == null && flags == USE_ALL_BEANINFO) {
|
|
// Same parameters to take advantage of caching.
|
|
bi = getBeanInfo(beanClass);
|
|
} else {
|
|
bi = (new Introspector(beanClass, stopClass, flags)).getBeanInfo();
|
|
}
|
|
return bi;
|
|
|
|
// Old behaviour: Make an independent copy of the BeanInfo.
|
|
//return new GenericBeanInfo(bi);
|
|
}
|
|
|
|
|
|
/**
|
|
* Utility method to take a string and convert it to normal Java variable
|
|
* name capitalization. This normally means converting the first
|
|
* character from upper case to lower case, but in the (unusual) special
|
|
* case when there is more than one character and both the first and
|
|
* second characters are upper case, we leave it alone.
|
|
* <p>
|
|
* Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays
|
|
* as "URL".
|
|
*
|
|
* @param name The string to be decapitalized.
|
|
* @return The decapitalized version of the string.
|
|
*/
|
|
public static String decapitalize(String name) {
|
|
if (name == null || name.length() == 0) {
|
|
return name;
|
|
}
|
|
if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
|
|
Character.isUpperCase(name.charAt(0))){
|
|
return name;
|
|
}
|
|
char chars[] = name.toCharArray();
|
|
chars[0] = Character.toLowerCase(chars[0]);
|
|
return new String(chars);
|
|
}
|
|
|
|
/**
|
|
* Gets the list of package names that will be used for
|
|
* finding BeanInfo classes.
|
|
*
|
|
* @return The array of package names that will be searched in
|
|
* order to find BeanInfo classes. The default value
|
|
* for this array is implementation-dependent; e.g.
|
|
* Sun implementation initially sets to {"sun.beans.infos"}.
|
|
*/
|
|
|
|
public static String[] getBeanInfoSearchPath() {
|
|
return ThreadGroupContext.getContext().getBeanInfoFinder().getPackages();
|
|
}
|
|
|
|
/**
|
|
* Change the list of package names that will be used for
|
|
* finding BeanInfo classes. The behaviour of
|
|
* this method is undefined if parameter path
|
|
* is null.
|
|
*
|
|
* <p>First, if there is a security manager, its <code>checkPropertiesAccess</code>
|
|
* method is called. This could result in a SecurityException.
|
|
*
|
|
* @param path Array of package names.
|
|
* @exception SecurityException if a security manager exists and its
|
|
* <code>checkPropertiesAccess</code> method doesn't allow setting
|
|
* of system properties.
|
|
* @see SecurityManager#checkPropertiesAccess
|
|
*/
|
|
|
|
public static void setBeanInfoSearchPath(String[] path) {
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null) {
|
|
sm.checkPropertiesAccess();
|
|
}
|
|
ThreadGroupContext.getContext().getBeanInfoFinder().setPackages(path);
|
|
}
|
|
|
|
|
|
/**
|
|
* Flush all of the Introspector's internal caches. This method is
|
|
* not normally required. It is normally only needed by advanced
|
|
* tools that update existing "Class" objects in-place and need
|
|
* to make the Introspector re-analyze existing Class objects.
|
|
*/
|
|
|
|
public static void flushCaches() {
|
|
synchronized (declaredMethodCache) {
|
|
ThreadGroupContext.getContext().clearBeanInfoCache();
|
|
declaredMethodCache.clear();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flush the Introspector's internal cached information for a given class.
|
|
* This method is not normally required. It is normally only needed
|
|
* by advanced tools that update existing "Class" objects in-place
|
|
* and need to make the Introspector re-analyze an existing Class object.
|
|
*
|
|
* Note that only the direct state associated with the target Class
|
|
* object is flushed. We do not flush state for other Class objects
|
|
* with the same name, nor do we flush state for any related Class
|
|
* objects (such as subclasses), even though their state may include
|
|
* information indirectly obtained from the target Class object.
|
|
*
|
|
* @param clz Class object to be flushed.
|
|
* @throws NullPointerException If the Class object is null.
|
|
*/
|
|
public static void flushFromCaches(Class<?> clz) {
|
|
if (clz == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
synchronized (declaredMethodCache) {
|
|
ThreadGroupContext.getContext().removeBeanInfo(clz);
|
|
declaredMethodCache.put(clz, null);
|
|
}
|
|
}
|
|
|
|
//======================================================================
|
|
// Private implementation methods
|
|
//======================================================================
|
|
|
|
private Introspector(Class<?> beanClass, Class<?> stopClass, int flags)
|
|
throws IntrospectionException {
|
|
this.beanClass = beanClass;
|
|
|
|
// Check stopClass is a superClass of startClass.
|
|
if (stopClass != null) {
|
|
boolean isSuper = false;
|
|
for (Class<?> c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
|
|
if (c == stopClass) {
|
|
isSuper = true;
|
|
}
|
|
}
|
|
if (!isSuper) {
|
|
throw new IntrospectionException(stopClass.getName() + " not superclass of " +
|
|
beanClass.getName());
|
|
}
|
|
}
|
|
|
|
if (flags == USE_ALL_BEANINFO) {
|
|
explicitBeanInfo = findExplicitBeanInfo(beanClass);
|
|
}
|
|
|
|
Class<?> superClass = beanClass.getSuperclass();
|
|
if (superClass != stopClass) {
|
|
int newFlags = flags;
|
|
if (newFlags == IGNORE_IMMEDIATE_BEANINFO) {
|
|
newFlags = USE_ALL_BEANINFO;
|
|
}
|
|
superBeanInfo = getBeanInfo(superClass, stopClass, newFlags);
|
|
}
|
|
if (explicitBeanInfo != null) {
|
|
additionalBeanInfo = explicitBeanInfo.getAdditionalBeanInfo();
|
|
}
|
|
if (additionalBeanInfo == null) {
|
|
additionalBeanInfo = new BeanInfo[0];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Constructs a GenericBeanInfo class from the state of the Introspector
|
|
*/
|
|
private BeanInfo getBeanInfo() throws IntrospectionException {
|
|
|
|
// the evaluation order here is import, as we evaluate the
|
|
// event sets and locate PropertyChangeListeners before we
|
|
// look for properties.
|
|
BeanDescriptor bd = getTargetBeanDescriptor();
|
|
MethodDescriptor mds[] = getTargetMethodInfo();
|
|
EventSetDescriptor esds[] = getTargetEventInfo();
|
|
PropertyDescriptor pds[] = getTargetPropertyInfo();
|
|
|
|
int defaultEvent = getTargetDefaultEventIndex();
|
|
int defaultProperty = getTargetDefaultPropertyIndex();
|
|
|
|
return new GenericBeanInfo(bd, esds, defaultEvent, pds,
|
|
defaultProperty, mds, explicitBeanInfo);
|
|
|
|
}
|
|
|
|
/**
|
|
* Looks for an explicit BeanInfo class that corresponds to the Class.
|
|
* First it looks in the existing package that the Class is defined in,
|
|
* then it checks to see if the class is its own BeanInfo. Finally,
|
|
* the BeanInfo search path is prepended to the class and searched.
|
|
*
|
|
* @param beanClass the class type of the bean
|
|
* @return Instance of an explicit BeanInfo class or null if one isn't found.
|
|
*/
|
|
private static BeanInfo findExplicitBeanInfo(Class<?> beanClass) {
|
|
return ThreadGroupContext.getContext().getBeanInfoFinder().find(beanClass);
|
|
}
|
|
|
|
/**
|
|
* @return An array of PropertyDescriptors describing the editable
|
|
* properties supported by the target bean.
|
|
*/
|
|
|
|
private PropertyDescriptor[] getTargetPropertyInfo() {
|
|
|
|
// Check if the bean has its own BeanInfo that will provide
|
|
// explicit information.
|
|
PropertyDescriptor[] explicitProperties = null;
|
|
if (explicitBeanInfo != null) {
|
|
explicitProperties = getPropertyDescriptors(this.explicitBeanInfo);
|
|
}
|
|
|
|
if (explicitProperties == null && superBeanInfo != null) {
|
|
// We have no explicit BeanInfo properties. Check with our parent.
|
|
addPropertyDescriptors(getPropertyDescriptors(this.superBeanInfo));
|
|
}
|
|
|
|
for (int i = 0; i < additionalBeanInfo.length; i++) {
|
|
addPropertyDescriptors(additionalBeanInfo[i].getPropertyDescriptors());
|
|
}
|
|
|
|
if (explicitProperties != null) {
|
|
// Add the explicit BeanInfo data to our results.
|
|
addPropertyDescriptors(explicitProperties);
|
|
|
|
} else {
|
|
|
|
// Apply some reflection to the current class.
|
|
|
|
// First get an array of all the public methods at this level
|
|
Method methodList[] = getPublicDeclaredMethods(beanClass);
|
|
|
|
// Now analyze each method.
|
|
for (int i = 0; i < methodList.length; i++) {
|
|
Method method = methodList[i];
|
|
if (method == null) {
|
|
continue;
|
|
}
|
|
// skip static methods.
|
|
int mods = method.getModifiers();
|
|
if (Modifier.isStatic(mods)) {
|
|
continue;
|
|
}
|
|
String name = method.getName();
|
|
Class<?>[] argTypes = method.getParameterTypes();
|
|
Class<?> resultType = method.getReturnType();
|
|
int argCount = argTypes.length;
|
|
PropertyDescriptor pd = null;
|
|
|
|
if (name.length() <= 3 && !name.startsWith(IS_PREFIX)) {
|
|
// Optimization. Don't bother with invalid propertyNames.
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
|
|
if (argCount == 0) {
|
|
if (name.startsWith(GET_PREFIX)) {
|
|
// Simple getter
|
|
pd = new PropertyDescriptor(this.beanClass, name.substring(3), method, null);
|
|
} else if (resultType == boolean.class && name.startsWith(IS_PREFIX)) {
|
|
// Boolean getter
|
|
pd = new PropertyDescriptor(this.beanClass, name.substring(2), method, null);
|
|
}
|
|
} else if (argCount == 1) {
|
|
if (int.class.equals(argTypes[0]) && name.startsWith(GET_PREFIX)) {
|
|
pd = new IndexedPropertyDescriptor(this.beanClass, name.substring(3), null, null, method, null);
|
|
} else if (void.class.equals(resultType) && name.startsWith(SET_PREFIX)) {
|
|
// Simple setter
|
|
pd = new PropertyDescriptor(this.beanClass, name.substring(3), null, method);
|
|
if (throwsException(method, PropertyVetoException.class)) {
|
|
pd.setConstrained(true);
|
|
}
|
|
}
|
|
} else if (argCount == 2) {
|
|
if (void.class.equals(resultType) && int.class.equals(argTypes[0]) && name.startsWith(SET_PREFIX)) {
|
|
pd = new IndexedPropertyDescriptor(this.beanClass, name.substring(3), null, null, null, method);
|
|
if (throwsException(method, PropertyVetoException.class)) {
|
|
pd.setConstrained(true);
|
|
}
|
|
}
|
|
}
|
|
} catch (IntrospectionException ex) {
|
|
// This happens if a PropertyDescriptor or IndexedPropertyDescriptor
|
|
// constructor fins that the method violates details of the deisgn
|
|
// pattern, e.g. by having an empty name, or a getter returning
|
|
// void , or whatever.
|
|
pd = null;
|
|
}
|
|
|
|
if (pd != null) {
|
|
// If this class or one of its base classes is a PropertyChange
|
|
// source, then we assume that any properties we discover are "bound".
|
|
if (propertyChangeSource) {
|
|
pd.setBound(true);
|
|
}
|
|
addPropertyDescriptor(pd);
|
|
}
|
|
}
|
|
}
|
|
processPropertyDescriptors();
|
|
|
|
// Allocate and populate the result array.
|
|
PropertyDescriptor result[] =
|
|
properties.values().toArray(new PropertyDescriptor[properties.size()]);
|
|
|
|
// Set the default index.
|
|
if (defaultPropertyName != null) {
|
|
for (int i = 0; i < result.length; i++) {
|
|
if (defaultPropertyName.equals(result[i].getName())) {
|
|
defaultPropertyIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private HashMap<String, List<PropertyDescriptor>> pdStore = new HashMap<>();
|
|
|
|
/**
|
|
* Adds the property descriptor to the list store.
|
|
*/
|
|
private void addPropertyDescriptor(PropertyDescriptor pd) {
|
|
String propName = pd.getName();
|
|
List<PropertyDescriptor> list = pdStore.get(propName);
|
|
if (list == null) {
|
|
list = new ArrayList<>();
|
|
pdStore.put(propName, list);
|
|
}
|
|
if (this.beanClass != pd.getClass0()) {
|
|
// replace existing property descriptor
|
|
// only if we have types to resolve
|
|
// in the context of this.beanClass
|
|
Method read = pd.getReadMethod();
|
|
Method write = pd.getWriteMethod();
|
|
boolean cls = true;
|
|
if (read != null) cls = cls && read.getGenericReturnType() instanceof Class;
|
|
if (write != null) cls = cls && write.getGenericParameterTypes()[0] instanceof Class;
|
|
if (pd instanceof IndexedPropertyDescriptor) {
|
|
IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
|
|
Method readI = ipd.getIndexedReadMethod();
|
|
Method writeI = ipd.getIndexedWriteMethod();
|
|
if (readI != null) cls = cls && readI.getGenericReturnType() instanceof Class;
|
|
if (writeI != null) cls = cls && writeI.getGenericParameterTypes()[1] instanceof Class;
|
|
if (!cls) {
|
|
pd = new IndexedPropertyDescriptor(ipd);
|
|
pd.updateGenericsFor(this.beanClass);
|
|
}
|
|
}
|
|
else if (!cls) {
|
|
pd = new PropertyDescriptor(pd);
|
|
pd.updateGenericsFor(this.beanClass);
|
|
}
|
|
}
|
|
list.add(pd);
|
|
}
|
|
|
|
private void addPropertyDescriptors(PropertyDescriptor[] descriptors) {
|
|
if (descriptors != null) {
|
|
for (PropertyDescriptor descriptor : descriptors) {
|
|
addPropertyDescriptor(descriptor);
|
|
}
|
|
}
|
|
}
|
|
|
|
private PropertyDescriptor[] getPropertyDescriptors(BeanInfo info) {
|
|
PropertyDescriptor[] descriptors = info.getPropertyDescriptors();
|
|
int index = info.getDefaultPropertyIndex();
|
|
if ((0 <= index) && (index < descriptors.length)) {
|
|
this.defaultPropertyName = descriptors[index].getName();
|
|
}
|
|
return descriptors;
|
|
}
|
|
|
|
/**
|
|
* Populates the property descriptor table by merging the
|
|
* lists of Property descriptors.
|
|
*/
|
|
private void processPropertyDescriptors() {
|
|
if (properties == null) {
|
|
properties = new TreeMap<>();
|
|
}
|
|
|
|
List<PropertyDescriptor> list;
|
|
|
|
PropertyDescriptor pd, gpd, spd;
|
|
IndexedPropertyDescriptor ipd, igpd, ispd;
|
|
|
|
Iterator<List<PropertyDescriptor>> it = pdStore.values().iterator();
|
|
while (it.hasNext()) {
|
|
pd = null; gpd = null; spd = null;
|
|
ipd = null; igpd = null; ispd = null;
|
|
|
|
list = it.next();
|
|
|
|
// First pass. Find the latest getter method. Merge properties
|
|
// of previous getter methods.
|
|
for (int i = 0; i < list.size(); i++) {
|
|
pd = list.get(i);
|
|
if (pd instanceof IndexedPropertyDescriptor) {
|
|
ipd = (IndexedPropertyDescriptor)pd;
|
|
if (ipd.getIndexedReadMethod() != null) {
|
|
if (igpd != null) {
|
|
igpd = new IndexedPropertyDescriptor(igpd, ipd);
|
|
} else {
|
|
igpd = ipd;
|
|
}
|
|
}
|
|
} else {
|
|
if (pd.getReadMethod() != null) {
|
|
String pdName = pd.getReadMethod().getName();
|
|
if (gpd != null) {
|
|
// Don't replace the existing read
|
|
// method if it starts with "is"
|
|
String gpdName = gpd.getReadMethod().getName();
|
|
if (gpdName.equals(pdName) || !gpdName.startsWith(IS_PREFIX)) {
|
|
gpd = new PropertyDescriptor(gpd, pd);
|
|
}
|
|
} else {
|
|
gpd = pd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Second pass. Find the latest setter method which
|
|
// has the same type as the getter method.
|
|
for (int i = 0; i < list.size(); i++) {
|
|
pd = list.get(i);
|
|
if (pd instanceof IndexedPropertyDescriptor) {
|
|
ipd = (IndexedPropertyDescriptor)pd;
|
|
if (ipd.getIndexedWriteMethod() != null) {
|
|
if (igpd != null) {
|
|
if (isAssignable(igpd.getIndexedPropertyType(), ipd.getIndexedPropertyType())) {
|
|
if (ispd != null) {
|
|
ispd = new IndexedPropertyDescriptor(ispd, ipd);
|
|
} else {
|
|
ispd = ipd;
|
|
}
|
|
}
|
|
} else {
|
|
if (ispd != null) {
|
|
ispd = new IndexedPropertyDescriptor(ispd, ipd);
|
|
} else {
|
|
ispd = ipd;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (pd.getWriteMethod() != null) {
|
|
if (gpd != null) {
|
|
if (isAssignable(gpd.getPropertyType(), pd.getPropertyType())) {
|
|
if (spd != null) {
|
|
spd = new PropertyDescriptor(spd, pd);
|
|
} else {
|
|
spd = pd;
|
|
}
|
|
}
|
|
} else {
|
|
if (spd != null) {
|
|
spd = new PropertyDescriptor(spd, pd);
|
|
} else {
|
|
spd = pd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// At this stage we should have either PDs or IPDs for the
|
|
// representative getters and setters. The order at which the
|
|
// property descriptors are determined represent the
|
|
// precedence of the property ordering.
|
|
pd = null; ipd = null;
|
|
|
|
if (igpd != null && ispd != null) {
|
|
// Complete indexed properties set
|
|
// Merge any classic property descriptors
|
|
if ((gpd == spd) || (gpd == null)) {
|
|
pd = spd;
|
|
} else if (spd == null) {
|
|
pd = gpd;
|
|
} else if (spd instanceof IndexedPropertyDescriptor) {
|
|
pd = mergePropertyWithIndexedProperty(gpd, (IndexedPropertyDescriptor) spd);
|
|
} else if (gpd instanceof IndexedPropertyDescriptor) {
|
|
pd = mergePropertyWithIndexedProperty(spd, (IndexedPropertyDescriptor) gpd);
|
|
} else {
|
|
pd = mergePropertyDescriptor(gpd, spd);
|
|
}
|
|
if (igpd == ispd) {
|
|
ipd = igpd;
|
|
} else {
|
|
ipd = mergePropertyDescriptor(igpd, ispd);
|
|
}
|
|
if (pd == null) {
|
|
pd = ipd;
|
|
} else {
|
|
Class<?> propType = pd.getPropertyType();
|
|
Class<?> ipropType = ipd.getIndexedPropertyType();
|
|
if (propType.isArray() && propType.getComponentType() == ipropType) {
|
|
pd = pd.getClass0().isAssignableFrom(ipd.getClass0())
|
|
? new IndexedPropertyDescriptor(pd, ipd)
|
|
: new IndexedPropertyDescriptor(ipd, pd);
|
|
} else if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
|
|
pd = pd.getClass0().isAssignableFrom(ipd.getClass0())
|
|
? new PropertyDescriptor(pd, ipd)
|
|
: new PropertyDescriptor(ipd, pd);
|
|
} else {
|
|
pd = ipd;
|
|
}
|
|
}
|
|
} else if (gpd != null && spd != null) {
|
|
if (igpd != null) {
|
|
gpd = mergePropertyWithIndexedProperty(gpd, igpd);
|
|
}
|
|
if (ispd != null) {
|
|
spd = mergePropertyWithIndexedProperty(spd, ispd);
|
|
}
|
|
// Complete simple properties set
|
|
if (gpd == spd) {
|
|
pd = gpd;
|
|
} else if (spd instanceof IndexedPropertyDescriptor) {
|
|
pd = mergePropertyWithIndexedProperty(gpd, (IndexedPropertyDescriptor) spd);
|
|
} else if (gpd instanceof IndexedPropertyDescriptor) {
|
|
pd = mergePropertyWithIndexedProperty(spd, (IndexedPropertyDescriptor) gpd);
|
|
} else {
|
|
pd = mergePropertyDescriptor(gpd, spd);
|
|
}
|
|
} else if (ispd != null) {
|
|
// indexed setter
|
|
pd = ispd;
|
|
// Merge any classic property descriptors
|
|
if (spd != null) {
|
|
pd = mergePropertyDescriptor(ispd, spd);
|
|
}
|
|
if (gpd != null) {
|
|
pd = mergePropertyDescriptor(ispd, gpd);
|
|
}
|
|
} else if (igpd != null) {
|
|
// indexed getter
|
|
pd = igpd;
|
|
// Merge any classic property descriptors
|
|
if (gpd != null) {
|
|
pd = mergePropertyDescriptor(igpd, gpd);
|
|
}
|
|
if (spd != null) {
|
|
pd = mergePropertyDescriptor(igpd, spd);
|
|
}
|
|
} else if (spd != null) {
|
|
// simple setter
|
|
pd = spd;
|
|
} else if (gpd != null) {
|
|
// simple getter
|
|
pd = gpd;
|
|
}
|
|
|
|
// Very special case to ensure that an IndexedPropertyDescriptor
|
|
// doesn't contain less information than the enclosed
|
|
// PropertyDescriptor. If it does, then recreate as a
|
|
// PropertyDescriptor. See 4168833
|
|
if (pd instanceof IndexedPropertyDescriptor) {
|
|
ipd = (IndexedPropertyDescriptor)pd;
|
|
if (ipd.getIndexedReadMethod() == null && ipd.getIndexedWriteMethod() == null) {
|
|
pd = new PropertyDescriptor(ipd);
|
|
}
|
|
}
|
|
|
|
// Find the first property descriptor
|
|
// which does not have getter and setter methods.
|
|
// See regression bug 4984912.
|
|
if ( (pd == null) && (list.size() > 0) ) {
|
|
pd = list.get(0);
|
|
}
|
|
|
|
if (pd != null) {
|
|
properties.put(pd.getName(), pd);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static boolean isAssignable(Class<?> current, Class<?> candidate) {
|
|
return ((current == null) || (candidate == null)) ? current == candidate : current.isAssignableFrom(candidate);
|
|
}
|
|
|
|
private PropertyDescriptor mergePropertyWithIndexedProperty(PropertyDescriptor pd, IndexedPropertyDescriptor ipd) {
|
|
Class<?> type = pd.getPropertyType();
|
|
if (type.isArray() && (type.getComponentType() == ipd.getIndexedPropertyType())) {
|
|
return pd.getClass0().isAssignableFrom(ipd.getClass0())
|
|
? new IndexedPropertyDescriptor(pd, ipd)
|
|
: new IndexedPropertyDescriptor(ipd, pd);
|
|
}
|
|
return pd;
|
|
}
|
|
|
|
/**
|
|
* Adds the property descriptor to the indexedproperty descriptor only if the
|
|
* types are the same.
|
|
*
|
|
* The most specific property descriptor will take precedence.
|
|
*/
|
|
private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,
|
|
PropertyDescriptor pd) {
|
|
PropertyDescriptor result = null;
|
|
|
|
Class<?> propType = pd.getPropertyType();
|
|
Class<?> ipropType = ipd.getIndexedPropertyType();
|
|
|
|
if (propType.isArray() && propType.getComponentType() == ipropType) {
|
|
if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
|
|
result = new IndexedPropertyDescriptor(pd, ipd);
|
|
} else {
|
|
result = new IndexedPropertyDescriptor(ipd, pd);
|
|
}
|
|
} else if ((ipd.getReadMethod() == null) && (ipd.getWriteMethod() == null)) {
|
|
if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
|
|
result = new PropertyDescriptor(pd, ipd);
|
|
} else {
|
|
result = new PropertyDescriptor(ipd, pd);
|
|
}
|
|
} else {
|
|
// Cannot merge the pd because of type mismatch
|
|
// Return the most specific pd
|
|
if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
|
|
result = ipd;
|
|
} else {
|
|
result = pd;
|
|
// Try to add methods which may have been lost in the type change
|
|
// See 4168833
|
|
Method write = result.getWriteMethod();
|
|
Method read = result.getReadMethod();
|
|
|
|
if (read == null && write != null) {
|
|
read = findMethod(result.getClass0(),
|
|
GET_PREFIX + NameGenerator.capitalize(result.getName()), 0);
|
|
if (read != null) {
|
|
try {
|
|
result.setReadMethod(read);
|
|
} catch (IntrospectionException ex) {
|
|
// no consequences for failure.
|
|
}
|
|
}
|
|
}
|
|
if (write == null && read != null) {
|
|
write = findMethod(result.getClass0(),
|
|
SET_PREFIX + NameGenerator.capitalize(result.getName()), 1,
|
|
new Class<?>[] { FeatureDescriptor.getReturnType(result.getClass0(), read) });
|
|
if (write != null) {
|
|
try {
|
|
result.setWriteMethod(write);
|
|
} catch (IntrospectionException ex) {
|
|
// no consequences for failure.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Handle regular pd merge
|
|
private PropertyDescriptor mergePropertyDescriptor(PropertyDescriptor pd1,
|
|
PropertyDescriptor pd2) {
|
|
if (pd1.getClass0().isAssignableFrom(pd2.getClass0())) {
|
|
return new PropertyDescriptor(pd1, pd2);
|
|
} else {
|
|
return new PropertyDescriptor(pd2, pd1);
|
|
}
|
|
}
|
|
|
|
// Handle regular ipd merge
|
|
private IndexedPropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd1,
|
|
IndexedPropertyDescriptor ipd2) {
|
|
if (ipd1.getClass0().isAssignableFrom(ipd2.getClass0())) {
|
|
return new IndexedPropertyDescriptor(ipd1, ipd2);
|
|
} else {
|
|
return new IndexedPropertyDescriptor(ipd2, ipd1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return An array of EventSetDescriptors describing the kinds of
|
|
* events fired by the target bean.
|
|
*/
|
|
private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
|
|
if (events == null) {
|
|
events = new HashMap<>();
|
|
}
|
|
|
|
// Check if the bean has its own BeanInfo that will provide
|
|
// explicit information.
|
|
EventSetDescriptor[] explicitEvents = null;
|
|
if (explicitBeanInfo != null) {
|
|
explicitEvents = explicitBeanInfo.getEventSetDescriptors();
|
|
int ix = explicitBeanInfo.getDefaultEventIndex();
|
|
if (ix >= 0 && ix < explicitEvents.length) {
|
|
defaultEventName = explicitEvents[ix].getName();
|
|
}
|
|
}
|
|
|
|
if (explicitEvents == null && superBeanInfo != null) {
|
|
// We have no explicit BeanInfo events. Check with our parent.
|
|
EventSetDescriptor supers[] = superBeanInfo.getEventSetDescriptors();
|
|
for (int i = 0 ; i < supers.length; i++) {
|
|
addEvent(supers[i]);
|
|
}
|
|
int ix = superBeanInfo.getDefaultEventIndex();
|
|
if (ix >= 0 && ix < supers.length) {
|
|
defaultEventName = supers[ix].getName();
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < additionalBeanInfo.length; i++) {
|
|
EventSetDescriptor additional[] = additionalBeanInfo[i].getEventSetDescriptors();
|
|
if (additional != null) {
|
|
for (int j = 0 ; j < additional.length; j++) {
|
|
addEvent(additional[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (explicitEvents != null) {
|
|
// Add the explicit explicitBeanInfo data to our results.
|
|
for (int i = 0 ; i < explicitEvents.length; i++) {
|
|
addEvent(explicitEvents[i]);
|
|
}
|
|
|
|
} else {
|
|
|
|
// Apply some reflection to the current class.
|
|
|
|
// Get an array of all the public beans methods at this level
|
|
Method methodList[] = getPublicDeclaredMethods(beanClass);
|
|
|
|
// Find all suitable "add", "remove" and "get" Listener methods
|
|
// The name of the listener type is the key for these hashtables
|
|
// i.e, ActionListener
|
|
Map<String, Method> adds = null;
|
|
Map<String, Method> removes = null;
|
|
Map<String, Method> gets = null;
|
|
|
|
for (int i = 0; i < methodList.length; i++) {
|
|
Method method = methodList[i];
|
|
if (method == null) {
|
|
continue;
|
|
}
|
|
// skip static methods.
|
|
int mods = method.getModifiers();
|
|
if (Modifier.isStatic(mods)) {
|
|
continue;
|
|
}
|
|
String name = method.getName();
|
|
// Optimization avoid getParameterTypes
|
|
if (!name.startsWith(ADD_PREFIX) && !name.startsWith(REMOVE_PREFIX)
|
|
&& !name.startsWith(GET_PREFIX)) {
|
|
continue;
|
|
}
|
|
|
|
if (name.startsWith(ADD_PREFIX)) {
|
|
Class<?> returnType = method.getReturnType();
|
|
if (returnType == void.class) {
|
|
Type[] parameterTypes = method.getGenericParameterTypes();
|
|
if (parameterTypes.length == 1) {
|
|
Class<?> type = TypeResolver.erase(TypeResolver.resolveInClass(beanClass, parameterTypes[0]));
|
|
if (Introspector.isSubclass(type, eventListenerType)) {
|
|
String listenerName = name.substring(3);
|
|
if (listenerName.length() > 0 &&
|
|
type.getName().endsWith(listenerName)) {
|
|
if (adds == null) {
|
|
adds = new HashMap<>();
|
|
}
|
|
adds.put(listenerName, method);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (name.startsWith(REMOVE_PREFIX)) {
|
|
Class<?> returnType = method.getReturnType();
|
|
if (returnType == void.class) {
|
|
Type[] parameterTypes = method.getGenericParameterTypes();
|
|
if (parameterTypes.length == 1) {
|
|
Class<?> type = TypeResolver.erase(TypeResolver.resolveInClass(beanClass, parameterTypes[0]));
|
|
if (Introspector.isSubclass(type, eventListenerType)) {
|
|
String listenerName = name.substring(6);
|
|
if (listenerName.length() > 0 &&
|
|
type.getName().endsWith(listenerName)) {
|
|
if (removes == null) {
|
|
removes = new HashMap<>();
|
|
}
|
|
removes.put(listenerName, method);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (name.startsWith(GET_PREFIX)) {
|
|
Class<?>[] parameterTypes = method.getParameterTypes();
|
|
if (parameterTypes.length == 0) {
|
|
Class<?> returnType = FeatureDescriptor.getReturnType(beanClass, method);
|
|
if (returnType.isArray()) {
|
|
Class<?> type = returnType.getComponentType();
|
|
if (Introspector.isSubclass(type, eventListenerType)) {
|
|
String listenerName = name.substring(3, name.length() - 1);
|
|
if (listenerName.length() > 0 &&
|
|
type.getName().endsWith(listenerName)) {
|
|
if (gets == null) {
|
|
gets = new HashMap<>();
|
|
}
|
|
gets.put(listenerName, method);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (adds != null && removes != null) {
|
|
// Now look for matching addFooListener+removeFooListener pairs.
|
|
// Bonus if there is a matching getFooListeners method as well.
|
|
Iterator<String> keys = adds.keySet().iterator();
|
|
while (keys.hasNext()) {
|
|
String listenerName = keys.next();
|
|
// Skip any "add" which doesn't have a matching "remove" or
|
|
// a listener name that doesn't end with Listener
|
|
if (removes.get(listenerName) == null || !listenerName.endsWith("Listener")) {
|
|
continue;
|
|
}
|
|
String eventName = decapitalize(listenerName.substring(0, listenerName.length()-8));
|
|
Method addMethod = adds.get(listenerName);
|
|
Method removeMethod = removes.get(listenerName);
|
|
Method getMethod = null;
|
|
if (gets != null) {
|
|
getMethod = gets.get(listenerName);
|
|
}
|
|
Class<?> argType = FeatureDescriptor.getParameterTypes(beanClass, addMethod)[0];
|
|
|
|
// generate a list of Method objects for each of the target methods:
|
|
Method allMethods[] = getPublicDeclaredMethods(argType);
|
|
List<Method> validMethods = new ArrayList<>(allMethods.length);
|
|
for (int i = 0; i < allMethods.length; i++) {
|
|
if (allMethods[i] == null) {
|
|
continue;
|
|
}
|
|
|
|
if (isEventHandler(allMethods[i])) {
|
|
validMethods.add(allMethods[i]);
|
|
}
|
|
}
|
|
Method[] methods = validMethods.toArray(new Method[validMethods.size()]);
|
|
|
|
EventSetDescriptor esd = new EventSetDescriptor(eventName, argType,
|
|
methods, addMethod,
|
|
removeMethod,
|
|
getMethod);
|
|
|
|
// If the adder method throws the TooManyListenersException then it
|
|
// is a Unicast event source.
|
|
if (throwsException(addMethod,
|
|
java.util.TooManyListenersException.class)) {
|
|
esd.setUnicast(true);
|
|
}
|
|
addEvent(esd);
|
|
}
|
|
} // if (adds != null ...
|
|
}
|
|
EventSetDescriptor[] result;
|
|
if (events.size() == 0) {
|
|
result = EMPTY_EVENTSETDESCRIPTORS;
|
|
} else {
|
|
// Allocate and populate the result array.
|
|
result = new EventSetDescriptor[events.size()];
|
|
result = events.values().toArray(result);
|
|
|
|
// Set the default index.
|
|
if (defaultEventName != null) {
|
|
for (int i = 0; i < result.length; i++) {
|
|
if (defaultEventName.equals(result[i].getName())) {
|
|
defaultEventIndex = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void addEvent(EventSetDescriptor esd) {
|
|
String key = esd.getName();
|
|
if (esd.getName().equals("propertyChange")) {
|
|
propertyChangeSource = true;
|
|
}
|
|
EventSetDescriptor old = events.get(key);
|
|
if (old == null) {
|
|
events.put(key, esd);
|
|
return;
|
|
}
|
|
EventSetDescriptor composite = new EventSetDescriptor(old, esd);
|
|
events.put(key, composite);
|
|
}
|
|
|
|
/**
|
|
* @return An array of MethodDescriptors describing the private
|
|
* methods supported by the target bean.
|
|
*/
|
|
private MethodDescriptor[] getTargetMethodInfo() {
|
|
if (methods == null) {
|
|
methods = new HashMap<>(100);
|
|
}
|
|
|
|
// Check if the bean has its own BeanInfo that will provide
|
|
// explicit information.
|
|
MethodDescriptor[] explicitMethods = null;
|
|
if (explicitBeanInfo != null) {
|
|
explicitMethods = explicitBeanInfo.getMethodDescriptors();
|
|
}
|
|
|
|
if (explicitMethods == null && superBeanInfo != null) {
|
|
// We have no explicit BeanInfo methods. Check with our parent.
|
|
MethodDescriptor supers[] = superBeanInfo.getMethodDescriptors();
|
|
for (int i = 0 ; i < supers.length; i++) {
|
|
addMethod(supers[i]);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < additionalBeanInfo.length; i++) {
|
|
MethodDescriptor additional[] = additionalBeanInfo[i].getMethodDescriptors();
|
|
if (additional != null) {
|
|
for (int j = 0 ; j < additional.length; j++) {
|
|
addMethod(additional[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (explicitMethods != null) {
|
|
// Add the explicit explicitBeanInfo data to our results.
|
|
for (int i = 0 ; i < explicitMethods.length; i++) {
|
|
addMethod(explicitMethods[i]);
|
|
}
|
|
|
|
} else {
|
|
|
|
// Apply some reflection to the current class.
|
|
|
|
// First get an array of all the beans methods at this level
|
|
Method methodList[] = getPublicDeclaredMethods(beanClass);
|
|
|
|
// Now analyze each method.
|
|
for (int i = 0; i < methodList.length; i++) {
|
|
Method method = methodList[i];
|
|
if (method == null) {
|
|
continue;
|
|
}
|
|
MethodDescriptor md = new MethodDescriptor(method);
|
|
addMethod(md);
|
|
}
|
|
}
|
|
|
|
// Allocate and populate the result array.
|
|
MethodDescriptor result[] = new MethodDescriptor[methods.size()];
|
|
result = methods.values().toArray(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
private void addMethod(MethodDescriptor md) {
|
|
// We have to be careful here to distinguish method by both name
|
|
// and argument lists.
|
|
// This method gets called a *lot, so we try to be efficient.
|
|
String name = md.getName();
|
|
|
|
MethodDescriptor old = methods.get(name);
|
|
if (old == null) {
|
|
// This is the common case.
|
|
methods.put(name, md);
|
|
return;
|
|
}
|
|
|
|
// We have a collision on method names. This is rare.
|
|
|
|
// Check if old and md have the same type.
|
|
String[] p1 = md.getParamNames();
|
|
String[] p2 = old.getParamNames();
|
|
|
|
boolean match = false;
|
|
if (p1.length == p2.length) {
|
|
match = true;
|
|
for (int i = 0; i < p1.length; i++) {
|
|
if (p1[i] != p2[i]) {
|
|
match = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (match) {
|
|
MethodDescriptor composite = new MethodDescriptor(old, md);
|
|
methods.put(name, composite);
|
|
return;
|
|
}
|
|
|
|
// We have a collision on method names with different type signatures.
|
|
// This is very rare.
|
|
|
|
String longKey = makeQualifiedMethodName(name, p1);
|
|
old = methods.get(longKey);
|
|
if (old == null) {
|
|
methods.put(longKey, md);
|
|
return;
|
|
}
|
|
MethodDescriptor composite = new MethodDescriptor(old, md);
|
|
methods.put(longKey, composite);
|
|
}
|
|
|
|
/**
|
|
* Creates a key for a method in a method cache.
|
|
*/
|
|
private static String makeQualifiedMethodName(String name, String[] params) {
|
|
StringBuffer sb = new StringBuffer(name);
|
|
sb.append('=');
|
|
for (int i = 0; i < params.length; i++) {
|
|
sb.append(':');
|
|
sb.append(params[i]);
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
private int getTargetDefaultEventIndex() {
|
|
return defaultEventIndex;
|
|
}
|
|
|
|
private int getTargetDefaultPropertyIndex() {
|
|
return defaultPropertyIndex;
|
|
}
|
|
|
|
private BeanDescriptor getTargetBeanDescriptor() {
|
|
// Use explicit info, if available,
|
|
if (explicitBeanInfo != null) {
|
|
BeanDescriptor bd = explicitBeanInfo.getBeanDescriptor();
|
|
if (bd != null) {
|
|
return (bd);
|
|
}
|
|
}
|
|
// OK, fabricate a default BeanDescriptor.
|
|
return new BeanDescriptor(this.beanClass, findCustomizerClass(this.beanClass));
|
|
}
|
|
|
|
private static Class<?> findCustomizerClass(Class<?> type) {
|
|
String name = type.getName() + "Customizer";
|
|
try {
|
|
type = ClassFinder.findClass(name, type.getClassLoader());
|
|
// Each customizer should inherit java.awt.Component and implement java.beans.Customizer
|
|
// according to the section 9.3 of JavaBeans™ specification
|
|
if (Component.class.isAssignableFrom(type) && Customizer.class.isAssignableFrom(type)) {
|
|
return type;
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
// ignore any exceptions
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private boolean isEventHandler(Method m) {
|
|
// We assume that a method is an event handler if it has a single
|
|
// argument, whose type inherit from java.util.Event.
|
|
Type argTypes[] = m.getGenericParameterTypes();
|
|
if (argTypes.length != 1) {
|
|
return false;
|
|
}
|
|
return isSubclass(TypeResolver.erase(TypeResolver.resolveInClass(beanClass, argTypes[0])), EventObject.class);
|
|
}
|
|
|
|
/*
|
|
* Internal method to return *public* methods within a class.
|
|
*/
|
|
private static Method[] getPublicDeclaredMethods(Class<?> clz) {
|
|
// Looking up Class.getDeclaredMethods is relatively expensive,
|
|
// so we cache the results.
|
|
if (!ReflectUtil.isPackageAccessible(clz)) {
|
|
return new Method[0];
|
|
}
|
|
synchronized (declaredMethodCache) {
|
|
Method[] result = declaredMethodCache.get(clz);
|
|
if (result == null) {
|
|
result = clz.getMethods();
|
|
for (int i = 0; i < result.length; i++) {
|
|
Method method = result[i];
|
|
if (!method.getDeclaringClass().equals(clz)) {
|
|
result[i] = null; // ignore methods declared elsewhere
|
|
}
|
|
else {
|
|
try {
|
|
method = MethodFinder.findAccessibleMethod(method);
|
|
Class<?> type = method.getDeclaringClass();
|
|
result[i] = type.equals(clz) || type.isInterface()
|
|
? method
|
|
: null; // ignore methods from superclasses
|
|
}
|
|
catch (NoSuchMethodException exception) {
|
|
// commented out because of 6976577
|
|
// result[i] = null; // ignore inaccessible methods
|
|
}
|
|
}
|
|
}
|
|
declaredMethodCache.put(clz, result);
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//======================================================================
|
|
// Package private support methods.
|
|
//======================================================================
|
|
|
|
/**
|
|
* Internal support for finding a target methodName with a given
|
|
* parameter list on a given class.
|
|
*/
|
|
private static Method internalFindMethod(Class<?> start, String methodName,
|
|
int argCount, Class args[]) {
|
|
// For overriden methods we need to find the most derived version.
|
|
// So we start with the given class and walk up the superclass chain.
|
|
|
|
Method method = null;
|
|
|
|
for (Class<?> cl = start; cl != null; cl = cl.getSuperclass()) {
|
|
Method methods[] = getPublicDeclaredMethods(cl);
|
|
for (int i = 0; i < methods.length; i++) {
|
|
method = methods[i];
|
|
if (method == null) {
|
|
continue;
|
|
}
|
|
|
|
// make sure method signature matches.
|
|
if (method.getName().equals(methodName)) {
|
|
Type[] params = method.getGenericParameterTypes();
|
|
if (params.length == argCount) {
|
|
if (args != null) {
|
|
boolean different = false;
|
|
if (argCount > 0) {
|
|
for (int j = 0; j < argCount; j++) {
|
|
if (TypeResolver.erase(TypeResolver.resolveInClass(start, params[j])) != args[j]) {
|
|
different = true;
|
|
continue;
|
|
}
|
|
}
|
|
if (different) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
return method;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
method = null;
|
|
|
|
// Now check any inherited interfaces. This is necessary both when
|
|
// the argument class is itself an interface, and when the argument
|
|
// class is an abstract class.
|
|
Class ifcs[] = start.getInterfaces();
|
|
for (int i = 0 ; i < ifcs.length; i++) {
|
|
// Note: The original implementation had both methods calling
|
|
// the 3 arg method. This is preserved but perhaps it should
|
|
// pass the args array instead of null.
|
|
method = internalFindMethod(ifcs[i], methodName, argCount, null);
|
|
if (method != null) {
|
|
break;
|
|
}
|
|
}
|
|
return method;
|
|
}
|
|
|
|
/**
|
|
* Find a target methodName on a given class.
|
|
*/
|
|
static Method findMethod(Class<?> cls, String methodName, int argCount) {
|
|
return findMethod(cls, methodName, argCount, null);
|
|
}
|
|
|
|
/**
|
|
* Find a target methodName with specific parameter list on a given class.
|
|
* <p>
|
|
* Used in the contructors of the EventSetDescriptor,
|
|
* PropertyDescriptor and the IndexedPropertyDescriptor.
|
|
* <p>
|
|
* @param cls The Class object on which to retrieve the method.
|
|
* @param methodName Name of the method.
|
|
* @param argCount Number of arguments for the desired method.
|
|
* @param args Array of argument types for the method.
|
|
* @return the method or null if not found
|
|
*/
|
|
static Method findMethod(Class<?> cls, String methodName, int argCount,
|
|
Class args[]) {
|
|
if (methodName == null) {
|
|
return null;
|
|
}
|
|
return internalFindMethod(cls, methodName, argCount, args);
|
|
}
|
|
|
|
/**
|
|
* Return true if class a is either equivalent to class b, or
|
|
* if class a is a subclass of class b, i.e. if a either "extends"
|
|
* or "implements" b.
|
|
* Note tht either or both "Class" objects may represent interfaces.
|
|
*/
|
|
static boolean isSubclass(Class<?> a, Class<?> b) {
|
|
// We rely on the fact that for any given java class or
|
|
// primtitive type there is a unqiue Class object, so
|
|
// we can use object equivalence in the comparisons.
|
|
if (a == b) {
|
|
return true;
|
|
}
|
|
if (a == null || b == null) {
|
|
return false;
|
|
}
|
|
for (Class<?> x = a; x != null; x = x.getSuperclass()) {
|
|
if (x == b) {
|
|
return true;
|
|
}
|
|
if (b.isInterface()) {
|
|
Class<?>[] interfaces = x.getInterfaces();
|
|
for (int i = 0; i < interfaces.length; i++) {
|
|
if (isSubclass(interfaces[i], b)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Return true iff the given method throws the given exception.
|
|
*/
|
|
private boolean throwsException(Method method, Class<?> exception) {
|
|
Class exs[] = method.getExceptionTypes();
|
|
for (int i = 0; i < exs.length; i++) {
|
|
if (exs[i] == exception) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Try to create an instance of a named class.
|
|
* First try the classloader of "sibling", then try the system
|
|
* classloader then the class loader of the current Thread.
|
|
*/
|
|
static Object instantiate(Class<?> sibling, String className)
|
|
throws InstantiationException, IllegalAccessException,
|
|
ClassNotFoundException {
|
|
// First check with sibling's classloader (if any).
|
|
ClassLoader cl = sibling.getClassLoader();
|
|
Class<?> cls = ClassFinder.findClass(className, cl);
|
|
return cls.newInstance();
|
|
}
|
|
|
|
} // end class Introspector
|
|
|
|
//===========================================================================
|
|
|
|
/**
|
|
* Package private implementation support class for Introspector's
|
|
* internal use.
|
|
* <p>
|
|
* Mostly this is used as a placeholder for the descriptors.
|
|
*/
|
|
|
|
class GenericBeanInfo extends SimpleBeanInfo {
|
|
|
|
private BeanDescriptor beanDescriptor;
|
|
private EventSetDescriptor[] events;
|
|
private int defaultEvent;
|
|
private PropertyDescriptor[] properties;
|
|
private int defaultProperty;
|
|
private MethodDescriptor[] methods;
|
|
private Reference<BeanInfo> targetBeanInfoRef;
|
|
|
|
public GenericBeanInfo(BeanDescriptor beanDescriptor,
|
|
EventSetDescriptor[] events, int defaultEvent,
|
|
PropertyDescriptor[] properties, int defaultProperty,
|
|
MethodDescriptor[] methods, BeanInfo targetBeanInfo) {
|
|
this.beanDescriptor = beanDescriptor;
|
|
this.events = events;
|
|
this.defaultEvent = defaultEvent;
|
|
this.properties = properties;
|
|
this.defaultProperty = defaultProperty;
|
|
this.methods = methods;
|
|
this.targetBeanInfoRef = (targetBeanInfo != null)
|
|
? new SoftReference<>(targetBeanInfo)
|
|
: null;
|
|
}
|
|
|
|
/**
|
|
* Package-private dup constructor
|
|
* This must isolate the new object from any changes to the old object.
|
|
*/
|
|
GenericBeanInfo(GenericBeanInfo old) {
|
|
|
|
beanDescriptor = new BeanDescriptor(old.beanDescriptor);
|
|
if (old.events != null) {
|
|
int len = old.events.length;
|
|
events = new EventSetDescriptor[len];
|
|
for (int i = 0; i < len; i++) {
|
|
events[i] = new EventSetDescriptor(old.events[i]);
|
|
}
|
|
}
|
|
defaultEvent = old.defaultEvent;
|
|
if (old.properties != null) {
|
|
int len = old.properties.length;
|
|
properties = new PropertyDescriptor[len];
|
|
for (int i = 0; i < len; i++) {
|
|
PropertyDescriptor oldp = old.properties[i];
|
|
if (oldp instanceof IndexedPropertyDescriptor) {
|
|
properties[i] = new IndexedPropertyDescriptor(
|
|
(IndexedPropertyDescriptor) oldp);
|
|
} else {
|
|
properties[i] = new PropertyDescriptor(oldp);
|
|
}
|
|
}
|
|
}
|
|
defaultProperty = old.defaultProperty;
|
|
if (old.methods != null) {
|
|
int len = old.methods.length;
|
|
methods = new MethodDescriptor[len];
|
|
for (int i = 0; i < len; i++) {
|
|
methods[i] = new MethodDescriptor(old.methods[i]);
|
|
}
|
|
}
|
|
this.targetBeanInfoRef = old.targetBeanInfoRef;
|
|
}
|
|
|
|
public PropertyDescriptor[] getPropertyDescriptors() {
|
|
return properties;
|
|
}
|
|
|
|
public int getDefaultPropertyIndex() {
|
|
return defaultProperty;
|
|
}
|
|
|
|
public EventSetDescriptor[] getEventSetDescriptors() {
|
|
return events;
|
|
}
|
|
|
|
public int getDefaultEventIndex() {
|
|
return defaultEvent;
|
|
}
|
|
|
|
public MethodDescriptor[] getMethodDescriptors() {
|
|
return methods;
|
|
}
|
|
|
|
public BeanDescriptor getBeanDescriptor() {
|
|
return beanDescriptor;
|
|
}
|
|
|
|
public java.awt.Image getIcon(int iconKind) {
|
|
BeanInfo targetBeanInfo = getTargetBeanInfo();
|
|
if (targetBeanInfo != null) {
|
|
return targetBeanInfo.getIcon(iconKind);
|
|
}
|
|
return super.getIcon(iconKind);
|
|
}
|
|
|
|
private BeanInfo getTargetBeanInfo() {
|
|
if (this.targetBeanInfoRef == null) {
|
|
return null;
|
|
}
|
|
BeanInfo targetBeanInfo = this.targetBeanInfoRef.get();
|
|
if (targetBeanInfo == null) {
|
|
targetBeanInfo = ThreadGroupContext.getContext().getBeanInfoFinder()
|
|
.find(this.beanDescriptor.getBeanClass());
|
|
if (targetBeanInfo != null) {
|
|
this.targetBeanInfoRef = new SoftReference<>(targetBeanInfo);
|
|
}
|
|
}
|
|
return targetBeanInfo;
|
|
}
|
|
}
|