1. JavaBean concepts

2. BeanBox Tutorial

3. Starting and Using the BeanBox

4. Writing a SimpleBean

5. DOWNLOADING the BDK 1.0
 

*** What is a Java Bean ***

A notable difference between Java Beans and other component architectures (such as COM or OpenDoc) is that Java Beans are Java-centric, exclusively targeted at software development in Java. To ease integration with the Windows platform, bridges between Beans and COM have been developed.

JavaBeans brings component technology to the Java platform. You can use JavaBeans to write Java classes, called Beans, that you can visually manipulate within application builder tools. This document is a hands-on guide to learning JavaBeans and the Beans Development Kit (BDK). The JavaBeans API Specification provides a complete JavaBeans description.

The software you'll need to understand and explore Beans is available free on the web. In addition to the Beans Development Kit (BDK), you will need the Java Development Kit (JDK).
 
 

*** JavaBeans Concepts ***

The JavaBeans API makes it possible to write component software in the Java programming language. Components are self-contained, reusable software units that can be visually composed into composite components, applets, applications, and servlets using visual application builder tools. JavaBean components are known as Beans.

Components expose their features (for example, public methods and events) to builder tools for visual manipulation. A Bean's features are exposed because feature names adhere to specific design patterns. A "JavaBeans-enabled" builder tool can then examine the Bean's patterns, discern its features, and expose those features for visual manipulation. A builder tool maintains Beans in a palette or toolbox. You can select a Bean from the toolbox, drop it into a form, modify it's appearance and behavior, define its interaction with other Beans, and compose it and other Beans into an applet, application, or new Bean. All this can be done without writing a line of code.
 
 

 *** BDK ***

The JavaBeans Development Kit (BDK) is intended to support the early development of JavaBeans components and to act as a standard reference base for both component developers and tool vendors. The BDK provides a reference Bean container, the "BeanBox" and a variety of reusable example source code (in the demo and beanbox subdirectories) for use by both JavaBeans component and tool developers.

The BDK is not intended for use by application developers, nor is it intended to be a full-fledged application development environment. Instead, application developers should consider the various Java application development environments supporting JavaBeans.

This BDK 1.0 release requires you to have installed the Java Development Kit (JDK) 1.1 or later. We recommend using JDK 1.1.4 or later.

The BDK is qualified for Solaris 2.4, Solaris 2.5, Windows 95, and Windows NT 4.0. However the BDK is "pure Java" and should run on any JDK 1.1 enabled system.
 

*** Starting and Using the BeanBox ***

You can use these commands to start the BeanBox, The beans/beanbox. directory contains Windows (run.bat) and Unix (run.sh) or use make:
 
 

        gnumake run

Or:

        nmake run

When started, the BeanBox displays three windows: The BeanBox, ToolBox, and the Properties sheet. Here's how they look:

The picture shown above  is from Starting and Using the BeanBox  ( reference 3).

This illustration shows the BeanBox with the Juggler demo Bean placed within it. The hatching around the Juggler is how the BeanBox indicates the selected Bean. Clicking on a Bean selects it.

Adding a Bean to the ToolBox

Dropping a Bean on the BeanBox

• Click on the word JellyBean in the ToolBox. The cursor will change to a crosshair.

• Click within the BeanBox. The JellyBean will appear and will be selected.

The Properties sheet displays the selected Bean's properties. After dropping a JellyBean instance on the BeanBox, the Properties sheet displays the JellyBean properties: color, foreground, priceInCents, background, and font.
 
 

Editing Bean Properties

Saving and Restoring Beans

• Drop a JellyBean on the BeanBox.

• Change the color property to anything you want.

• Select the File|Save BeanBox menu item. A file browser will pop up; use it to save the Bean to a file.

• Select the File|Clear BeanBox menu item.

• Select the File|Load BeanBox menu item. The file browser will again pop up; use it to retrieve the serialized Bean.

*** Writing a SimpleBean ***

In this section you will learn more about Beans and the BeanBox by

• Creating a simple Bean

• Compiling and saving the Bean into a Java Archive (JAR) file

• Loading the Bean into the ToolBox

• Dropping a Bean instance into the BeanBox

• Inspecting the Bean's properties, methods, and events

• Generating an introspection report

1. Write the SimpleBean code. Put it in a file named SimpleBean.java, in the directory of your choice. Here's the code:

import java.awt.*;
import java.io.Serializable;
         
public class SimpleBean extends Canvas
                     implements Serializable{
 
  //Constructor sets inherited properties
  public SimpleBean(){
   setSize(60,40);
   setBackground(Color.red);
  }

}

SimpleBean extends the java.awt.Canvas component. SimpleBean also implements the java.io.Serializable interface, a requirement for all Beans. SimpleBean sets the background color and component size.

2. Make sure the CLASSPATH environment variable is set to point to all needed .class (or .jar) files. Here are some URLs that will help you to set CLASSPATH correctly:

• The Managing Source and Class Files lesson gives good advice on how and when to set your CLASSPATH.

• The JDK Tool Reference Page provides complete CLASSPATH information for both Windows and Solaris platforms.

1. Compile the Bean:

 

 
 
 

javac SimpleBean.java

This produces the class file SimpleBean.class

2. Create a manifest file. Use your favorite text editor to create a file, we'll call it manifest.tmp, that contains the following text:

 

 
 
 

Name: SimpleBean.class

Java-Bean: True

3. Create the JAR file. The JAR file will contain the manifest and the SimpleBean class file:

 

 
 
 

jar cfm SimpleBean.jar manifest.tmp SimpleBean.class

See the JAR File Format trail, and the JDK JAR file documentation for complete information on JAR files.

4. Load the JAR file into the ToolBox. Select the File|LoadJar... menu item. This will ring up a file browser. Navigate to the SimpleBean.jar location and select it. SimpleBean will appear at the bottom of the ToolBox. (Note that when the BeanBox is started, all Beans in JAR files in the beans/jars directory are automatically loaded into the ToolBox).
5. Drop a SimpleBean instance into the BeanBox. Click on the word SimpleBean in the ToolBox. The cursor will change to a crosshair. Move the cursor to a spot within the BeanBox and click. SimpleBean will appear as a painted rectangle with a hatched border. This border means that SimpleBean is selected. The SimpleBean properties will appear in the Properties sheet.

SimpleBean Makefiles

# gnumake file

CLASSFILES= SimpleBean.class

JARFILE= SimpleBean.jar

all: $(JARFILE)

# Create a JAR file with a suitable manifest.
$(JARFILE): $(CLASSFILES) $(DATAFILES)
        echo "Name: SimpleBean.class"  manifest.tmp
        echo "Java-Bean: True"  manifest.tmp
        jar cfm $(JARFILE) manifest.tmp *.class
        @/bin/rm manifest.tmp

# Compile the sources
%.class: %.java
        export CLASSPATH; CLASSPATH=. ; \
        javac $<

# make clean
clean:
        /bin/rm -f *.class
        /bin/rm -f $(JARFILE)

Here is the Windows nmake version:

CLASSFILES= simplebean.class

JARFILE= simplebean.jar

all: $(JARFILE)

# Create a JAR file with a suitable manifest.

$(JARFILE): $(CLASSFILES) $(DATAFILES)
        jar cfm $(JARFILE) <<manifest.tmp *.class
Name: SimpleBean.class
Java-Bean: True
<<

.SUFFIXES: .java .class

{sunw\demo\simple}.java{sunw\demo\simple}.class :
        set CLASSPATH=.
        javac $<

clean:
        -del sunw\demo\simple\*.class
        -del $(JARFILE)

You can use these makefiles as templates for creating your own Bean makefiles. The example Bean makefiles, in the beans/demo directory, also show you how to use makefiles to build and maintain your Beans.

Inspecting SimpleBean Properties and Events

Beans communicate with other Beans by sending and receiving event notifications. To see which events SimpleBean can send, choose the Edit|Events BeanBox menu item. A list of events, grouped by the Java interface in which the event method is declared, will be displayed. Under each interface group is a list of event methods. These are all inherited from Canvas.

Generating Bean Introspection Reports

• Low-level reflection, which uses design patterns to discover your Bean's features

• By examining an associated bean information class that explicitly describes your Bean's features.

By default Bean reports are sent to the java interpreter's standard output, which is the window where you started the BeanBox. You can redirect the report to a file by changing the java interpreter command in beanbox/run.sh or run.bat to: java sun.beanbox.BeanBoxFrame > beanreport.txt
 
 
 

REFERENCES:

1. JavaBean concepts

2. BeanBox Tutorial

3. Starting and Using the BeanBox

4. Writing a SimpleBean

5. DOWNLOADING the BDK 1.0