You are on page 1of 54

 A Java Bean is a software component that has been

designed to be reusable in a variety of different


environments
 Beans are important, because they allow you to build
complex systems from software components. These
components may be provided by you or supplied by one or
more different vendors. Java Beans defines an architecture
that specifies how these building blocks can operate
together.
 To better understand the value of Beans, consider the
following. Hardware designers have a wide variety of
components that can be integrated together to construct a
system. Resistors, capacitors, and inductors are examples
of simple building blocks. Integrated circuits provide more
advanced functionality. All of these different parts can be
reused. It is not necessary or possible to rebuild these
capabilities each time a new system is needed.
 To achieve the benefits of component software, a
component architecture is needed that allows programs to
be assembled from software building blocks, perhaps
provided by different vendors.
 It must also be possible for a designer to select a
component, understand its capabilities, and incorporate it
into an application.
 When a new version of a component becomes available, it
should be easy to incorporate this functionality into
existing code.
 Fortunately, Java Beans provides just such an architecture.
 There is no restriction on the capability of a Bean. It may
 perform a simple function, such as checking the spelling
of a document, or a complex function, such as forecasting
the performance of a stock portfolio.
 A Bean may be visible to an end user. One example of this
is a button on a graphical user interface.
 A Bean may also be invisible to a user. Software to decode
a stream of multimedia information in real time is an
example of this type of building block.
 A Bean obtains all the benefits of Java's "write-once,
run-anywhere" paradigm.
 The properties, events, and methods of a Bean that
are exposed to an application builder tool can be
controlled.
 A Bean may be designed to operate correctly in
different locales, which makes it useful in global
markets.
 Auxiliary software can be provided to help a person
configure a Bean. This software is only needed when
the design-time parameters for that component are
being set. It does not need to be included in the run-
time environment.
 The configuration settings of a Bean can be saved in
persistent storage and restored at a later time.
 A Bean may register to receive events from other
objects and can generate events that are sent to
other objects.
The Bean Developer Kit (BDK)
The Bean Developer Kit (BDK), available from
the JavaSoft site, is a simple example of a tool
that enables you to create, configure, and
connect a set of Beans. There is also a set of
sample Beans with their source code
Installing the BDK
 The JDK must be installed on your machine for
the BDK to work. Confirm that the JDK tools
are accessible from your environment.
Starting the BDK
 To start the BDK, follow these steps:

1. Change to the directory c:\\bdk\\beanbox.


2. Execute the batch file called run.bat. This causes the BDK to
display the three windows shown below . ToolBox lists all of
the different Beans that have been included with the BDK.
BeanBox provides an area to lay out and connect the Beans
selected from the ToolBox. Properties provides the ability to
configure a selected Bean.
 This section describes how to create an application
by using some of the Beans provided with the BDK.
First, the Molecule Bean displays a three-dimensional
view of a molecule.
 It may be configured to present one of the following
molecules: hyaluronic acid, benzene, cyclohexane,
ethane, or water.
 This component also has methods that allow the
molecule to be rotated in space along its X or Y axis.
 Second, the OurButton Bean provides a push-button
functionality.
 We will have one button labeled "Rotate X" to rotate
the molecule along its X axis and another button
labeled "Rotate Y“ to rotate the molecule along its Y
axis.
Figure 25.2: The Molecule and OurButton Beans
 Follow these steps to create and configure an instance of the Molecule Bean:

1. Position the cursor on the ToolBox entry labeled Molecule and click the left mouse
button. You should see the cursor change to a cross.

2. Move the cursor to the BeanBox display area and click the left mouse button in
approximately the area where you wish the Bean to be displayed. You should see a
rectangular region appear that contains a 3-D display of a molecule. This area is
surrounded by a hatched border, indicating that it is currently selected.

3. You can reposition the Molecule Bean by positioning the cursor over one of the
hatched borders and dragging the Bean.

4. You can change the molecule that is displayed by changing the selection in the
Properties window. Notice that the Bean display changes immediately when you
change the selected molecule.
5. Go to the menu bar of the BeanBox and select Edit | Events | action |
actionPerformed. You should now see a line extending from the button to the cursor.
Notice that one end of the line moves as the cursor moves. However, the other end
of
the line remains fixed at the button

6. Move the cursor so that it is inside the Molecule Bean display area, and click the
left mouse button. You should see the Event Target Dialog dialog box.

7.The dialog box allows you to choose a method that should be invoked when this
button is clicked. Select the entry labeled "rotateOnX" and click the OK button. You
should see a message box appear very briefly, stating that the tool is "Generating nd
compiling adaptor class.“

Test the application. Each time you press the button, the molecule should move a
few degrees around one of its axes.

Now create another instance of the OurButton Bean. Label it "Rotate Y" and map its
action event to the "rotateY" method of the Molecule Bean. The steps to do this are
very similar to those just described for the button labeled "Rotate X".

Test the application by clicking these buttons and observing how the molecule
moves.
 Before developing your own Bean, it is necessary for
you to understand JAR (Java Archive) files, because
tools such as the BDK expect Beans to be packaged
within JAR files.
 A JAR file allows you to efficiently deploy a set of
classes and their associated resources.
 For example, a developer may build a multimedia
application that uses various sound and image files.
 A set of Beans can control how and when this
information is presented. All of these pieces can be
placed into one JAR file.
 Also, the elements in a JAR file are compressed,
which makes downloading a JAR file much faster than
separately downloading several uncompressed files.
 A developer must provide a manifest file to indicate which
of the components in a JAR file are Java Beans.
 An example of a manifest file is provided in the following
listing. It defines a JAR file that contains four .gif files and
one .class file. The last entry is a Bean.

Name: sunw/demo/slides/slide0.gif
Name: sunw/demo/slides/slide1.gif
Name: sunw/demo/slides/slide2.gif
Name: sunw/demo/slides/slide3.gif
Name: sunw/demo/slides/Slides.class
Java-Bean: True
 A manifest file may reference several .class files. If a .class
file is a Java Bean, its entry must be immediately followed
by the line "Java-Bean: True".
 A utility is used to generate a JAR file. Its
syntax is shown here:
jar options files

Creating a JAR File


 The following command creates a JAR file

named Xyz.jar that contains all of the .class


and .gif files in the current directory:
jar cf Xyz.jar *.class *.gif
Option Description
c A new archive is to be created.
C Change directories during command execution.
f The first element in the file list is the name of the
archive that is to be created or accessed.
m The second element in the file list is the name of the
external manifest file.
M Manifest file not created.
t The archive contents should be tabulated.
u Update existing JAR file.
v Verbose output should be provided by the utility as it
executes.
x Files are to be extracted from the archive. (If there is
only one file, that is the name of the archive, and all files
in it are extracted. Otherwise, the first element in the file
list is the name of the archive, and the remaining
elements in the list are the files that should be extracted
from the archive.)
 If a manifest file such as Yxz.mf is available, it can be
used with the following command:
jar cfm Xyz.jar Yxz.mf *.class *.gif

Tabulating the Contents of a JAR File


 The following command lists the contents of Xyz.jar:

jar tf Xyz.jar

Extracting Files from a JAR File


 The following command extracts the contents of
Xyz.jar and places those files in the current directory:
jar xf Xyz.jar

Updating an Existing JAR File


 The following command adds the file file1.class to
Xyz.jar:
jar -uf Xyz.jar file1.class
Recursing Directories
 The following command adds all files below directoryX to
Xyz.jar:
jar -uf Xyz.jar -C directoryX *

Introspection
 Introspection is the process of analyzing a Bean to
determine its capabilities. This is an essential feature of
the Java Beans API, because it allows an application builder
tool to present information about a component to a
software designer.
 There are two ways in which the developer of a Bean can
indicate which of its properties, events, and methods
should be exposed by an application builder tool.
 With the first method, simple naming conventions are
used. These allow the introspection mechanisms to infer
information about a Bean.
 In the second way, an additional class is provided that
explicitly supplies this information.
 The first approach is examined here
 A property is a subset of a Bean's state. The
values assigned to the properties determine the
behavior and appearance of that component. This
section discusses three types of properties:
simple, Boolean, and indexed.

Simple Properties
 A simple property has a single value. It can be
identified by the following design patterns, where
N is the name of the property and T is its type.
public T getN( );
public void setN(T arg);
 read/write property has both of these methods to access its values.
 A read-only property has only a get method. A write-only property has only a set
method.
 The following listing shows a class that has three read/write simple properties:

public class Box {


private double depth, height, width;
public double getDepth( ) {
return depth;
}
public void setDepth(double d) {
depth = d;
}
public double getHeight( ) {
return height;
}
public void setHeight(double h) {
height = h;
}
public double getWidth( ) {
return width;
}
public void setWidth(double w) {
width = w;
}
}
 A Boolean property has a value of true or false. It can be
identified by the following design patterns, where N is the
name of the property:
public boolean isN( );
public boolean getN( );
public void setN(boolean value);

 The following listing shows a class that has one Boolean


property:
public class Line {
private boolean dotted = false;
public boolean isDotted( ) {
return dotted;
}
public void setDotted(boolean dotted) {
this.dotted = dotted;
}
}
Indexed Properties
 An indexed property consists of multiple values. It can be identified by
the following design patterns, where N is the name of the property and T
is its type:
 public T getN(int index);
 public void setN(int index, T value);
 public T[ ] getN( );
 public void setN(T values[ ]);

public class PieChart {


private double data[ ];
public double getData(int index) {
return data[index];
}
public void setData(int index, double value) {
data[index] = value;
}
public double[ ] getData( ) {
return data;
}
public void setData(double[ ] values) {
data = new double[values.length];
System.arraycopy(values, 0, data, 0, values.length);
}
}
 Beans can generate events and send them to other
objects. These can be identified by the following design
patterns, where T is the type of the event:

public void addTListener(TListener eventListener);


public void addTListener(TListener eventListener) throws
TooManyListeners;
public void removeTListener(TListener eventListener);

 These methods are used by event listeners to register an


interest in events of a specific type.
 The first pattern indicates that a Bean can multicast an
event to multiple listeners.
 The second pattern indicates that a Bean can unicast an
event to only one listener.
 The third pattern is used by a listener when it no longer
wishes to receive a specific type of event notification
from a Bean.
 Our new component is called the Colors Bean. It
appears as either a rectangle or ellipse that is
filled with a color.
 A color is chosen at random when the Bean
begins execution.
 A public method can be invoked to change it.
Each time the mouse is clicked on the Bean,
another random color is chosen.
 There is one boolean read/write property that
determines the shape.
 The BDK is used to lay out an application with
one instance of the Colors Bean and one instance
of the OurButton Bean. The button is labeled
"Change." Each time it is pressed, the color
changes.
Here are the steps that you must follow to
create a new Bean:
1. Create a directory for the new Bean.
2. Create the Java source file(s).
3. Compile the source file(s).
4. Create a manifest file.
5. Generate a JAR file.
6. Start the BDK.
7. Test.
Create a Directory for the New Bean
 You need to make a directory for the Bean.

c:\\bdk\\demo\\sunw\\demo\\colors.
Then change to that directory.

Create the Source File for the New Bean


 It is located in the file Colors.java.
 This file must be located in a subdirectory

named sunw\\demo\\colors relative to the


CLASSPATH environment variable.
// A simple Bean.
package sunw.demo.colors;
import java.awt.*;
import java.awt.event.*;
public class Colors extends Canvas {
transient private Color color;
private boolean rectangular;
public Colors() {
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me) {
change();
}
});
rectangular = false;
setSize(200, 100);
change();
}
public boolean getRectangular() {
return rectangular;
}
public void setRectangular(boolean flag) {
this.rectangular = flag;
repaint();
}
public void change() {
color = randomColor();
repaint();
}
private Color randomColor() {
int r = (int)(255*Math.random());
int g = (int)(255*Math.random());
int b = (int)(255*Math.random());
return new Color(r, g, b);
}
public void paint(Graphics g) {
Dimension d = getSize();
int h = d.height;
int w = d.width;
g.setColor(color);
if(rectangular) {
g.fillRect(0, 0, w-1, h-1);
}
else {
g.fillOval(0, 0, w-1, h-1);
}
}
}
Compile the Source Code for the New Bean
javac Colors.java.

Create a Manifest File


 First, switch to the c:\\bdk\\demo directory. This is
the directory in which the manifest files for the BDK
demos are located.
 Put the source code for your manifest file in the file
colors.mft. It is shown here:

Name: sunw/demo/colors/Colors.class
Java-Bean: True

 This file indicates that there is one .class file in the


JAR file and that it is a Java Bean.
 Notice that the Colors.class file is in the package
sunw.demo.colors and in the subdirectory
sunw\\demo\\colors relative to the current directory.
Generate a JAR File
 Beans are included in the ToolBox window of the BDK only if they
are in JAR files in the directory c:\\bdk\\jars.
 These files are generated with the jar utility. Enter the following:

jar cfm ..\\jars\\colors.jar colors.mft


sunw\\demo\\colors\\*.class
 This command creates the file colors.jar and places it in the
directory c:\\bdk\\jars.

Start the BDK


 Change to the directory c:\\bdk\\beanbox and type run. This
causes the BDK to start

Create an Instance of the Colors Bean


 create an instance of the Colors Bean in the BeanBox window.
Test your new component by pressing the mouse anywhere
within its borders. Its color Immediately changes.
 Use the Properties window to change the rectangular property
from false to true. Its shape immediately changes.
Create an instance of the OurButton Bean in the BeanBox window.
Then follow these steps:
1. Go to the Properties window and change the label of the Bean to
"Change". You should see that the button appearance changes
immediately when this property is changed.
2. Go to the menu bar of the BeanBox and select Edit | Events |
action | actionPerformed.
3. Move the cursor so that it is inside the Colors Bean display area,
and click the left mouse button. You should see the Event Target
Dialog dialog box.
4. The dialog box allows you to choose a method that should be
invoked when this button is clicked. Select the entry labeled
"change" and click the OK button. You should see a message box
appear very briefly, stating that the tool is "Generating and
compiling adaptor class.“
5. Click on the button. You should see the color change.
 A property with listeners" is called a bound property.
 Sometimes when a Bean property changes, another object may want to
be notified of the change, and react to the change. Whenever a bound
property changes, notification of the change is sent to interested
listeners
 A Bean containing a bound property must maintain a list of property
change listeners, and alert those listeners when the bound property
changes. The convenience class PropertyChangeSupport implements
methods that add and remove PropertyChangeListener objects from a
list, and fires PropertyChangeEvent objects at those listeners when the
bound property changes. Your Beans can inherit from this class, or use it
as an inner class.

 An object that wants to listen for property changes must be able to add
and remove itself from the listener list on the Bean containing the bound
property, and respond to the event notification method that signals a
property change. By implementing the PropertyChangeListener interface
the listener can be added to the list maintained by the bound property
Bean, and because it implements the
PropertyChangeListener.propertyChange method, the listener can
respond to property change notifications.
 To implement a bound property, take the following steps:
 Import the java.beans package. This gives you access to the
PropertyChangeSupport class.

 Instantiate a PropertyChangeSupport object:


private PropertyChangeSupport changes = new
PropertyChangeSupport(this);

This object maintains the property change listener list and fires
property change events. You can also make your class a
PropertyChangeSupport subclass.

 Implement methods to maintain the property change listener list.


Since PropertyChangeSupport implements these methods, you
merely wrap calls to the property-change support object's
methods:

public void addPropertyChangeListener( PropertyChangeListener l)


{
changes.addPropertyChangeListener(l);
}
public void removePropertyChangeListener( PropertyChangeListener l)
{
changes.removePropertyChangeListener(l);
}

 Modify a property's setter method to fire a property change event


when the property is changed. OurButton's setLabel method
looks like this:
public void setLabel(String newLabel)
{
String oldLabel = label;
label = newLabel; sizeToFit();
changes.firePropertyChange("label", oldLabel, newLabel);
}
Note that setLabel stores the old label value, because both the old
and new labels must be passed to firePropertyChange.

public void firePropertyChange(String propertyName, Object


oldValue, Object newValue)

 The firePropertyChange method bundles its parameters into a


PropertyChangeEvent object, and calls
propertyChange(PropertyChangeEvent pce) on each registered
listener. The old and new values are treated as Object values.
 So to make your class able to listen and respond to
property change events, you must:
1. Implement the PropertyChangeListener interface. public class
MyClass implements java.beans.PropertyChangeListener,
java.io.Serializable
2. Implement the propertyChange method in the listener. This
method needs to contain the code that handles what you need
to do when the listener receives property change event. Very
often, for example, this is a call to a setter method in the
listener class: a property change in the source Bean propagates
a change to a property in a listener Bean.

 To register interest in receiving notification about a Bean


property change, the listener Bean calls the listener
registration method on the source Bean. For example:

button.addPropertyChangeListener(aButtonListener);
EG:- The TickTock Bean is supplied with the BDK. It generates a property
change event every N seconds. N is a property of the Bean that can be
changed via the Properties window of the BDK. The next example builds
an application that uses the TickTock Bean to automatically control the
Colors Bean.

STEPS
 start the BDK and create an instance of the Colors Bean in the BeanBox
window.
 Create an instance of the TickTock Bean. The Properties window should
show one property for this component. It is "Interval" and its initial value
is 5. This represents the number of seconds that elapse between property
change events generated by the TickTock Bean. Change the value to 1.
 Now you need to map events generated by the TickTock Bean into
method calls on the Colors Bean. Follow these steps:
1. Go to the menu bar of the BeanBox and select Edit | Events |
propertyChange | propertyChange. You should now see a line extending
from the button to the cursor.
2. Move the cursor so that it is inside the Colors Bean display area, and click
the left mouse button. You should see the Event Target Dialog dialog
box.
3. The dialog box allows you to choose a method that should be invoked
when this event occurs. Select the entry labeled "change" and click the OK
button. You should see a message box appear very briefly, stating that
the tool is "Generating and compiling adaptor class."
 A Bean property is constrained when any change
to that property can be vetoed. Usually an
outside object exercises the right to veto, but the
Bean itself can also veto a property change.
 There are three parts to constrained property
implementations:
 A source Bean containing one or more constrained
properties.
 Listener objects that implement the
VetoableChangeListener interface. This object accepts or
rejects proposed changes to a constrained property in
the source Bean.
 A PropertyChangeEvent object containing the property
name, and its old and new values. This is the same class
used for bound properties.
 A Bean containing constrained properties must
 Allow VetoableChangeListener objects to register and
unregister their interest in receiving notification that a
property change is proposed.
 Fire property change events at those interested listeners
when a property change is proposed. The event should
be fired before the actual property change takes place.
This gives each listener a chance to veto the proposed
change. The PropertyChangeEvent is fired by a call to
each listeners vetoableChange method.
 If a listener vetoes, then make sure that any other
listeners can revert to the old value. This means
reissuing the vetoableChange call to all the listeners,
with a PropertyChangeEvent containing the old value.
 The VetoableChangeSupport utility class is provided to implement these
capabilities. This class implements methods to add and remove
VetoableChangeListener objects to a listener list, and a method that fires
property change events at each listener in that list when a property
change is proposed. This method will also catch any vetoes, and resend
the property change event with the original property value. Your Bean
can either inherit from VetoableChangeSupport, or use an instance of it.
 Note that, in general, constrained properties should also be bound
properties. When a constrained property change does occur, a
PropertyChangeEvent can be sent via
PropertyChangeListener.propertyChange to signal all
VetoableChangeListener Beans that the change has taken effect. This
lets all the vetoable change listeners know that the change was not
vetoed by any listener.
 Here's the steps to implement constrained properties in your Beans:
1) Import the java.beans package. This gives you access to the
VetoableChangeSupport class.
2) Instantiate a VetoableChangeSupport object within your Bean:
private VetoableChangeSupport vetos = new
VetoableChangeSupport(this);

VetoableChangeSupport manages a list of VetoableChangeListener


objects, and fires property change events at each object in the list when
a change occurs to a constrained property.
3)Implement methods to maintain the property
change listener list.
public void
addVetoableChangeListener( VetoableChangeListen
er l)
{
vetos.addVetoableChangeListener(l);
}
public void
removeVetoableChangeListener( VetoableChangeLis
tener l)
{
vetos.removeVetoableChangeListener(l);
}
4) Write a property's setter method to fire a property
change event when the property is changed.
This includes adding a throws clause to the setter
method's signature. JellyBean's setPriceInCents method
looks like this:

public void setPriceInCents(int newPriceInCents) throws


PropertyVetoException {

int oldPriceInCents = ourPriceInCents;


vetos.fireVetoableChange("priceInCents", new
Integer(oldPriceInCents), new Integer(newPriceInCents));
// No-one vetoed, so go ahead and make the change.
ourPriceInCents = newPriceInCents;
changes.firePropertyChange("priceInCents", new
Integer(oldPriceInCents), new Integer(newPriceInCents));

}
 So to make your class able to listen and respond
to property change events, your listener class
must:

 Implement the VetoableChangeListener interface.


 Implement the vetoableChange method. This is
the method that will be called by the source Bean
on each object in the listener list (maintained by
the VetoableChangeSupport object). This is also
the method that exercises veto power. A property
change is vetoed by throwing the
PropertyVetoException.
 This section describes how a developer can use
the BeanInfo interface to explicitly control this
process.
 This interface defines several methods, including
these:
PropertyDescriptor[ ] getPropertyDescriptors( )
EventSetDescriptor[ ] getEventSetDescriptors( )
MethodDescriptor[ ] getMethodDescriptors( )
 They return arrays of objects that provide
information about the properties, events, and
methods of a Bean.
 By implementing these methods, a developer can
designate exactly what is presented to a user.
// A Bean information class.
package sunw.demo.colors;
import java.beans.*;
public class ColorsBeanInfo extends SimpleBeanInfo {
public PropertyDescriptor[] getPropertyDescriptors() {
try {
PropertyDescriptor rectangular = new
PropertyDescriptor("rectangular", Colors.class);
PropertyDescriptor pd[] = {rectangular};
return pd;
}
catch(Exception e) {
}
return null;
}
}
 You must compile this file from the BDK\\demo
directory or set CLASSPATH so that it includes
c:\\bdk\\demo. If you don't, the compiler won't
find the Colors.class file properly.
 After this file is successfully compiled, the

colors.mft file can be updated, as shown here:


Name: sunw/demo/colors/ColorsBeanInfo.class
Name: sunw/demo/colors/Colors.class
Java-Bean: True
 Use the JAR tool to create a new colors.jar file.

Restart the BDK and create an instance of the


Colors Bean in the BeanBox.
 Persistence is the ability to save a Bean to nonvolatile storage and
retrieve it at a later time.
 Let us first see how the BDK allows you to save a set of Beans that have
been configured and connected together to form an application. Recall
our previous example involving both the Colors and TickTock Beans.
 The rectangular property of the Colors Bean was changed to true, and
the interval property of the TickTock Bean was changed to one second.
 To save the application, go to the menu bar of the BeanBox and select
File | Save.
 A dialog box should appear, allowing you to specify the name of a file to
which the Beans and their configuration parameters should be saved.
Supply a filename and click the OK button on that dialog box. Exit from
the BDK.
 Start the BDK again. To restore the application, go to the menu bar of
the BeanBox and select File | Load. A dialog box should appear, allowing
you to specify the name of the file from which an application should be
restored.
 Supply the name of the file in which the application was saved, and click
the OK button. Your application should now be functioning.
 Confirm that the rectangular property of the Colors Bean is true and that
the interval property for the TickTock Bean is equal to one second.
 The object serialization capabilities provided by
the Java class libraries are used to provide
persistence for Beans.
 If a Bean inherits directly or indirectly from
java.awt.Component, it is automatically
serializable, because that class implements the
java.io.Serializable interface.
 If a Bean does not inherit an implementation of
the Serializable interface, you must provide this
yourself. Otherwise, containers cannot save the
configuration of your component.
 The transient keyword can be used to designate
data members of a Bean that should not be
serialized. The color variable of the Colors class
is an example of such an item.
 The Java Beans functionality is provided by a set of classes
and interfaces in the java.beans package
Interface Description
BeanInfo This interface allows a designer to specify
information about the properties, events,
and methods of a Bean.
Customizer This interface allows a designer to provide a
graphical user interface through which a
Bean may be configured.
DesignMode Methods in this interface determine if a Bean
is executing in design mode.
PropertyChangeListener A method in this interface is invoked when a
bound property is changed.
Interface Description
PropertyEditor Objects that implement this interface allow
designers to change and display property values.
VetoableChangeListe A method in this interface is invoked when a
ner constrained property is changed.
Visibility Methods in this interface allow a Bean to execute
in environments where a graphical user interface
is not available.

Class Description
BeanDescriptor This class provides information about a Bean. It
also allows you to associate a customizer with a
Bean.
Beans This class is used to obtain information about a
Bean.
EventSetDescriptor Instances of this class describe an event that can
be generated by a Bean.
Class Description
FeatureDescriptor This is the superclass of the
PropertyDescriptor, EventSetDescriptor, and
MethodDescriptor classes.
IndexedPropertyDescr Instances of this class describe an indexed
iptor property of a Bean.
IntrospectionExceptio An exception of this type is generated if a
n problem occurs w hen analyzing a Bean.
Introspector This class analyzes a Bean and constructs a
BeanInfo object that describes the component.
MethodDescriptor Instances of this class describe a method of a
Bean.
ParameterDescriptor Instances of this class describe a method
parameter
PropertyChangeEvent This event is generated when bound or
constrained properties are changed. It is sent to
objects that registered an interest in these
events and implement either the
PropertyChangeListener or
VetoableChangeListener
interfaces.
PropertyDescriptor Instances of this class describe a property of a
Bean.
SimpleBeanInfo This class provides functionality that can be
used when writing BeanInfo classes.
VetoableChangeSupp Beans that support constrained properties can
ort use this class to notify VetoableChangeListener
objects.

the following program illustrates the Introspector, BeanDescriptor,


PropertyDescriptor, and EventSetDescriptor classes and the BeanInfo
interface. It lists the properties and events of the Colors Bean
// Show properties and events.
package sunw.demo.colors;
import java.awt.*;
import java.beans.*;
public class IntrospectorDemo {
public static void main(String args[]) {
try {
Class c = Class.forName("sunw.demo.colors.Colors");
BeanInfo beanInfo = Introspector.getBeanInfo(c);
BeanDescriptor beanDescriptor =
beanInfo.getBeanDescriptor();
System.out.println("Bean name = " +
beanDescriptor.getName());
System.out.println("Properties:");
PropertyDescriptor propertyDescriptor[] =
beanInfo.getPropertyDescriptors();
for(int i = 0; i < propertyDescriptor.length; i++) {
System.out.println("\\t" +
propertyDescriptor[i].getName());
}
System.out.println("Events:");
EventSetDescriptor eventSetDescriptor[] =
beanInfo.getEventSetDescriptors();
for(int i = 0; i < eventSetDescriptor.length; i++) {
System.out.println("\\t" +
eventSetDescriptor[i].getName());
}
}
catch(Exception e) {
System.out.println("Exception caught. " + e);
}
}
}
The output from this program is the following:
Bean name = Colors
Properties:
Rectangular
Events:
propertyChange
mouseMotion
focus
mouse
inputMethod
key
component
 You can use the BeanBox's File|MakeApplet...
menu item to generate an applet from the
BeanBox contents. Making an applet from the
BeanBox creates:
A JAR file containing class files and serialized data
A test HTML file that uses the JAR file (and any
other JAR files needed)
A subdirectory with Java sources and makefile
A readme file with complete information about the
generated applet and all files involved
1. Use the Juggler example
2. Choose File|Make Applet to bring up the
MakeApplet dialog

 The generated files were placed in the


beanbox/tmp/myApplet directory. You can
test your applet by bringing up appletviewer
in the following way:
appletviewer
<BDKInstallation>/beanbox/tmp/myApplet.
html

You might also like