java.beans

To minimize the resources used by a bean, the classes used by bean editors are loaded only when the bean is being edited. They are not needed while the bean is running in an application and therefore not loaded. This information is kept in what's called a bean-info (see {@link java.beans.BeanInfo}).

Unless explicitly stated, null values or empty Strings are not valid parameters for the methods in this package. You may expect to see exceptions if these parameters are used.

Long-Term Persistence

---

Note: The persistence scheme cannot automatically instantiate custom inner classes, such as you might use for event handlers. By using the {@link java.beans.EventHandler} class instead of inner classes for custom event handlers, you can avoid this problem.

---

You read and write beans in XML format using the {@link java.beans.XMLDecoder} and {@link java.beans.XMLEncoder} classes, respectively. One notable feature of the persistence scheme is that reading in a bean requires no special knowledge of the bean.

Writing out a bean, on the other hand, sometimes requires special knowledge of the bean's type. If the bean's state can be expressed using only the no-argument constructor and public getter and setter methods for properties, no special knowledge is required. Otherwise, the bean requires a custom persistence delegate -- an object that is in charge of writing out beans of a particular type. All classes provided in the JDK that descend from java.awt.Component, as well as all their properties, automatically have persistence delegates.

If you need (or choose) to provide a persistence delegate for a bean, you can do so either by using a {@link java.beans.DefaultPersistenceDelegate} instance or by creating your own subclass of PersistenceDelegate. If the only reason a bean needs a persistence delegate is because you want to invoke the bean's constructor with property values as arguments, you can create the bean's persistence delegate with the one-argument DefaultPersistenceDelegate constructor. Otherwise, you need to implement your own persistence delegate, for which you're likely to need the following classes:

{@link java.beans.PersistenceDelegate}

The abstract class from which all persistence delegates descend. Your subclass should use its knowledge of the bean's type to provide whatever Statements and Expressions are necessary to create the bean and restore its state.

{@link java.beans.Statement}

Represents the invocation of a single method on an object. Includes a set of arguments to the method.

{@link java.beans.Expression}

A subclass of Statement used for methods that return a value.

Once you create a persistence delegate, you register it using the setPersistenceDelegate method of XMLEncoder.

Related Documentation

• JavaBeans, a trail in The Java Tutorial.
• Long-Term Persistence, an article in The Swing Connection.

This interface is designed to work in collusion with java.beans.Beans.instantiate.

A bean implementor doesn't need to provide a complete set of explicit information.

An annotation on a constructor that shows how the parameters of that constructor correspond to the constructed object's getter methods.

This interface is intended to be implemented by, or delegated from, instances of java.beans.beancontext.BeanContext, in order to propagate to its nested hierarchy of java.beans.beancontext.BeanContextChild instances, the current "designTime" property.

The JavaBeans specification defines the notion of design time as is a mode in which JavaBeans instances should function during their composition and customization in a interactive design, composition or construction tool, as opposed to runtime when the JavaBean is part of an applet, application, or other live Java executable abstraction.
author:
   Laurence P.

An indexed property may also provide simple non-indexed read and write methods.

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.

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.

PropertyEditor supports a variety of different kinds of ways of displaying and updating property values.