The JavaBeans™ architecture is based on a component model which enables
developers to create software units called components.
Components are self-contained, reusable software units that can be visually
assembled into composite components, applets, applications, and servlets
using visual application builder tools. JavaBean components are known as beans.
A set of APIs describes a component model for a particular language. The
the core detailed elaboration for the JavaBeans component architecture.
Beans are dynamic in that they can be changed or customized. Through the
design mode of a builder tool you can use the Properties window of the bean
to customize the bean and then save (persist) your beans using visual
manupulation. You can select a bean from the toolbox, drop it into a form,
modify its appearance and behavior, define its interaction with other beans,
and combine it and other beans into an applet, application, or a new bean.
The following list briefly describes key bean concepts.
- Builder tools discover a bean's features (that is, its properties,
methods, and events) by a process known as introspection.
Beans support introspection in two ways:
- By adhering to specific rules, known as design patterns,
when naming bean features. The
class examines beans for these design patterns to discover bean
Introspector class relies on the core
- By explicitly providing property, method, and event information
with a related bean information class. A bean information
class implements the
BeanInfo interface. A
class explicitly lists those bean features that are to be exposed to
application builder tools.
- Properties are the appearance and behavior characteristics of
a bean that can be changed at design time. Builder tools introspect on a
bean to discover its properties and expose those properties for
- Beans expose properties so they can be customized at design time. Customization
is supported in two ways: by using property editors, or by using more
sophisticated bean customizers.
- Beans use events to communicate with other beans. A bean that
is to receive events (a listener bean) registers with the bean that
fires the event (a source bean). Builder tools can examine a bean and
determine which events that bean can fire (send) and which it can handle
- Persistence enables beans to save and restore their state.
After changing a bean's properties, you can save the state of the bean
and restore that bean at a later time with the property changes intact.
The JavaBeans architecture uses Java Object Serialization to support
- A bean's methods are no different from Java methods, and can
be called from other beans or a scripting environment. By default all
public methods are exported.
Beans vary in functionality and purpose. You have probably met some of
the following beans in your programming practice:
- GUI (graphical user interface)
- Non-visual beans, such as a spelling checker
- Animation applet
- Spreadsheet application