java.beans
public class Introspector extends Object
Don't worry about it too much, though: you can provide JavaBeans with as much customized information as you want, or as little as you want, using the BeanInfo interface (see BeanInfo for details).
Order of Operations
When you call getBeanInfo(class c), the Introspector first searches for BeanInfo class to see if you provided any explicit information. It searches for a class named <bean class name>BeanInfo in different packages, first searching the bean class's package and then moving on to search the beanInfoSearchPath.
If it does not find a BeanInfo class, it acts as though it had found a BeanInfo class returning null from all methods (meaning it should discover everything through Introspection). If it does, then it takes the information it finds in the BeanInfo class to be canonical (that is, the information speaks for its class as well as all superclasses).
When it has introspected the class, calls getBeanInfo(c.getSuperclass) and adds that information to the information it has, not adding to any information it already has that is canonical.
Introspection Design Patterns
When the Introspector goes in to read the class, it follows a well-defined order in order to not leave any methods unaccounted for. Its job is to step over all of the public methods in a class and determine whether they are part of a property, an event, or a method (in that order). Properties:
public boolean isXXX()
method, then XXX is a read-only boolean property.
boolean getXXX() may be supplied in
addition to this method, although isXXX() is the
one that will be used in this case and getXXX()
will be ignored. If there is a
public void setXXX(boolean) method,
it is part of this group and makes it a read-write
property.public <type> getXXX(int)
method, then XXX is a read-only indexed property of
type <type>. If there is a
public void setXXX(int,<type>)
method, then it is a read-write indexed property of
type <type>. There may also be a
public <type>[] getXXX() and a
public void setXXX(<type>)
method as well.public void setXXX(int,<type>)
method, then it is a write-only indexed property of
type <type>. There may also be a
public <type>[] getXXX() and a
public void setXXX(<type>)
method as well.public <type> getXXX() method,
then XXX is a read-only property of type
<type>. If there is a
public void setXXX(<type>)
method, then it will be used for the property and
the property will be considered read-write.public void setXXX(<type>)
method, then as long as XXX is not already used as
the name of a property, XXX is assumed to be a
write-only property of type <type>.PropertyVetoException, then the
property in question is assumed to be constrained.
No properties are ever assumed to be bound
(Spec Note: this is not in the
spec, it just makes sense). See PropertyDescriptor
for a description of bound and constrained
properties.
If there is a pair of methods,
public void addXXX(<type>) and
public void removeXXX(<type>), where
<type> is a descendant of
java.util.EventListener, then the pair of
methods imply that this Bean will fire events to
listeners of type <type>.
If the addXXX() method throws
java.util.TooManyListenersException, then
the event set is assumed to be unicast. See
EventSetDescriptor for a discussion of unicast event
sets.
Spec Note: the spec seems to say that the listener type's classname must be equal to the XXX part of addXXX() and removeXXX(), but that is not the case in Sun's implementation, so I am assuming it is not the case in general.
Methods:
Any public methods (including those which were used for Properties or Events) are used as Methods.
Since: JDK1.1
See Also: BeanInfo
| Field Summary | |
|---|---|
| static int | IGNORE_ALL_BEANINFO |
| static int | IGNORE_IMMEDIATE_BEANINFO |
| static int | USE_ALL_BEANINFO |
| Method Summary | |
|---|---|
| static String | decapitalize(String name)
A helper method to convert a name to standard Java
naming conventions: anything with two capitals as the
first two letters remains the same, otherwise the
first letter is decapitalized. |
| static void | flushCaches()
Flush all of the Introspector's internal caches.
|
| static void | flushFromCaches(Class<?> clz)
Flush the Introspector's internal cached information for a given
class.
|
| static BeanInfo | getBeanInfo(Class<?> beanClass)
Get the BeanInfo for class beanClass,
first by looking for explicit information, next by
using standard design patterns to determine
information about the class.
|
| static BeanInfo | getBeanInfo(Class<?> beanClass, int flag)
Returns a {@BeanInfo} instance for the given Bean class where a flag
controls the usage of explicit BeanInfo class to retrieve that
information.
|
| static BeanInfo | getBeanInfo(Class<?> beanClass, Class<?> stopClass)
Get the BeanInfo for class beanClass,
first by looking for explicit information, next by
using standard design patterns to determine
information about the class. |
| static String[] | getBeanInfoSearchPath()
Get the search path for BeanInfo classes.
|
| static void | setBeanInfoSearchPath(String[] beanInfoSearchPath)
Set the search path for BeanInfo classes. |
Parameters: name the name to decapitalize.
Returns: the decapitalized name.
Since: 1.2
Parameters: clz the class to be flushed.
Throws: NullPointerException if clz is null.
Since: 1.2
beanClass,
first by looking for explicit information, next by
using standard design patterns to determine
information about the class.
Parameters: beanClass the class to get BeanInfo about.
Returns: the BeanInfo object representing the class.
You have three options:
With {@link #USE_ALL_BEANINFO} the result is the same as {@link #getBeanInfo(Class)}.
Calling the method with flag set to
{@link #IGNORE_IMMEDIATE_BEANINFO} will let it use all
explicit BeanInfo classes for the beans superclasses
but not for the bean class itself. Furthermore eventset,
property and method information is retrieved by introspection
if the explicit BeanInfos did not provide such data
(ie. return null on {@link BeanInfo.getMethodDescriptors},
{@link BeanInfo.getEventSetDescriptors} and
{@link BeanInfo.getPropertyDescriptors}.)
When the method is called with Note: Any unknown value for Parameters: beanClass The class whose BeanInfo should be returned. flag Controls the usage of explicit Returns: A BeanInfo object describing the class. Throws: IntrospectionException If something goes wrong while retrieving
the bean data. flag
flag is interpreted
as {@link #IGNORE_ALL_BEANINFO}BeanInfo classes.
beanClass,
first by looking for explicit information, next by
using standard design patterns to determine
information about the class. It crawls up the
inheritance tree until it hits topClass.
Parameters: beanClass the Bean class. stopClass the class to stop at.
Returns: the BeanInfo object representing the class.
Returns: the BeanInfo search path.
Parameters: beanInfoSearchPath the new BeanInfo search path.