JavaBeans Development Kit (BDK)

JavaBeans Development Kit (BDK)  v1.1 Description:

JavaBeans Development Kit includes a reference Bean container and a variety of reusable example source code.

BDK is designed for use by both JavaBeans component and tool developers.

It comes with: the JavaBeans API sources which are provided as .java reference sources; the BeanBox test container which allows you to test out your new Beans against a reference container, and also acts an example of how to build a Bean container; fifteen example Beans which can run in the BeanBox and demonstrate various Bean behavior; various source code; makefile information; and a tutorial.

JavaBeans Concepts

JavaBeans brings component technology to the Java platform. With the JavaBeans API you can create reuseable, platform-independent components. Using JavaBeans-compliant application builder tools, you can combine these components into applets, applications, or composite components. JavaBean components are known as Beans.

JavaBeans is a core JDK1.1 capability. Any JDK1.1-compliant browser or tool implicitly supports JavaBeans.

The BDK is available free from our website, you will need the Java Development Kit (JDK).

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.

The following list briefly describes key Bean concepts, and gives the chapter in the JavaBeans specification where you can read a complete description.

- 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 Introspector (in the API reference documentation) class examines Beans for these design patterns to discover Bean features. The Introspector class relies on the core reflection (outside of the tutorial) API. The trail The Reflection API (in the JavaBeans(TM) trail) is an excellent place to learn about reflection.
By explicitly providing property, method, and event information with a related Bean Information class. A Bean information class implements the BeanInfo interface. A BeanInfo class explicitly lists those Bean features that are to be exposed to application builder tools. Chapter 8 of the JavaBeans API Specification (outside of the tutorial) discusses introspection, design patterns, and BeanInfo objects.
-Properties are a Bean's appearance and behavior characteristics that can be changed at design time. Builder tools introspect on a Bean to discover its properties, and expose those properties for manipulation. Chapter 7 of the JavaBeans API Specification discusses properties.
-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. Chapter 9 of the JavaBeans API Specification discusses Bean customization.
-Beans use events to communicate with other Beans. A Bean that wants to receive events (a listener Bean) registers its interest 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 (receive). Chapter 6 of the JavaBeans API Specification discusses events.
-Persistence enables Beans to save and restore their state. Once you've changed a Beans properties, you can save the state of the Bean and restore that Bean at a later time, property changes intact. JavaBeans uses Java Object Serialization to support persistence. Chapter 5 of the JavaBeans API Specification discusses persistence.
-A Bean's methods are no different than Java methods, and can be called from other Beans or a scripting environment. By default all public methods are exported. Although Beans are designed to be understood by builder tools, all key APIs, including support for events, properties, and persistence, have been designed to be easily read and understood by human programmers as well.

Where to download the Beans Development Kit

The BDK is delivered separately from the JDK. You can download the BDK for free from our web site. This site contains instructions for installing the BDK on your system. Here is a general description of the BDK files and directories:
  • README.html contains an entry point to the BDK documentation
  • LICENSE.html contains the BDK license agreement
  • GNUmakefile and Makefile are Unix and Windows makefiles (.gmk and .mk suffixes) for building the demos and the BeanBox, and for running the BeanBox
  • beans/apis contains
    • a java directory containing JavaBeans source files
    • a sun directory containing property editor source files
  • beans/beanbox contains
    • makefiles for building the BeanBox
    • scripts for running the BeanBox
    • a classes directory containing the BeanBox class files
    • a lib directory containing a BeanBox support jar file used by MakeApplet's produced code
    • sun and sunw directories containing BeanBox source (.java) files
    • a tmp directory containing automatically generated event adapter source and class files, .ser files, and applet files automatically generated by MakeApplet
  • beans/demos contains
    • makefiles for building the demo Beans
    • an HTML directory containing an applet wrapper demonstration that must be run in appletviewer, HotJava, or JDK1.1-compliant browsers
    • a sunw directory containing
      • a wrapper directory containing a Bean applet wrapper
      • a demos directory containing demo source file
  • beans/doc contains
    • demos documentation
    • a javadoc directory containing JavaBeans and JavaBeans-related class and interface documentation
    • miscellaneous documentation
  • beans/jars contains jar files for demo Beans

Starting and Using the BeanBox

This section gives you a brief, introductory look at the BeanBox and it's basic operation. The beans/beanbox directory contains Windows (run.bat) and Unix ( scripts that start the BeanBox. You can use these commands to start the BeanBox, or use a make utility:
Platform Command
Unix gmake run
Windows nmake run
See the BDK files beans/doc/makefiles.html and beans/doc/gnu.txt for information about getting copies of gnumake and nmake. When started, the BeanBox displays three windows: The ToolBox, the BeanBox window, and the Properties sheet. Here are brief descriptions of each window.
  • The ToolBox contains the Beans available for use by the BeanBox. To work on a Bean, you choose it from the ToolBox and drop it on the BeanBox window.
  • The BeanBox window is the area where you visually wire Beans together, defining how Beans appear, and interact with other Beans. The BeanBox window is itself an instance of a BeanBox Bean. The above screenshot shows the BeanBox window with a Juggler Bean instance dropped in it. Later you'll see how to wire the Juggler to two button Beans that start and stop him juggling. You select among Beans in the BeanBox window simply by clicking on the Bean. The selected Bean will have a hatced border, as the Juggler Bean does in the above screenshot. Which Bean is selected has significance for the Properties sheet.
  • The Properties sheet displays the properties for the Bean currently selected within the BeanBox window. The Properties sheet displays the Juggler Bean's properties. If you drop another Bean in the BeanBox window, the properties sheet will display that Bean's properties.

Adding a Bean to the ToolBox
When the BeanBox is started, it automatically loads the ToolBox with all the Beans it finds within the JAR files contained in the beans/jars directory. Move your JAR files into that directory to have them automatically loaded at BeanBox startup. You can load Beans from JAR files located elsewhere by using the File|LoadJar... BeanBox menu item.

Dropping a Bean on the BeanBox
Clicking on a Bean name within the ToolBox chooses that Bean for placement within the BeanBox. To drop a JellyBean instance onto the BeanBox
  1. Click on the word JellyBean in the ToolBox. The cursor will change to a crosshair when flying over the BeanBox windows.
  2. Click within the BeanBox. The JellyBean instance will appear, and will be selected.
Note the change in the Properties sheet when you put the JellyBean in the BeanBox. Before you placed the JellyBean in the BeanBox, the BeanBox's properties were displayed. After placing the JellyBean in the BeanBox, the JellyBean properties are displayed. If you missed the change, click within the BeanBox, away from the JellyBean. This will select the BeanBox rather than the JellyBean. The Properties sheet will then display the BeanBox'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
The Properties sheet displays each property's name and its current value. Values are displayed in an editable text field (strings and numbers), a choice menu (booleans), or as painted values (colors and fonts). Each property has an associated property editor. Clicking on a property within the Properties sheet activates the property's editor. Properties displayed in text fields or choice menus are edited within the Properties sheet. Because editing their values requires a more sophisticated user interface, Color and Font property types use a custom property editor. When you click on a color or font property a separate panel will pop up to do the editing. Try clicking on each of the JellyBean properties.

Saving and Restoring Beans
You can save the state of a Bean that your are customizing, and restore the Bean and its saved state at a later time. The BeanBox uses Java Object Serialization to save and restore Beans and their state. The following steps demonstrate how to save and restore a Bean:
  1. Drop a JellyBean on the BeanBox.
  2. Change the color property to anything you want.
  3. Select the File|Save menu item. A file browser will pop up; use it to save the Bean to a file.
  4. Select the File|Clear menu item.
  5. Select the File|Load menu item. The file browser will again pop up; use it to retrieve the serialized Bean. The JellyBean will be the color you chose.

Writing a Simple Bean

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
Your Bean will be named SimpleBean. Here are the steps to create it and view it in the BeanBox:
  1. Write the SimpleBean code. Put it in a file named, in the directory of your choice. Here's the code:
    import java.awt.*;
    public class SimpleBean extends Canvas
                            implements Serializable
        //Constructor sets inherited properties
        public SimpleBean(){
    SimpleBean extends the java.awt.Canvas component. SimpleBean also implements the 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.
  3. Compile the Bean:
    This produces the class file SimpleBean.class
  4. 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
  5. 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 Filestrail, and the JDK JAR file documentation for complete information on JAR files.
  6. Load the JAR file into the ToolBox. Select the File|LoadJar... menu item. This will bring 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).
  7. 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.
You can resize SimpleBean, because it inherits from Canvas, by dragging a corner. You will see the cursor change to a right angle when over a corner. You can also reposition SimpleBean within the BeanBox by dragging on any non-corner portion of the hatched border. You will see the cursor change to crossed arrows when in position to move the Bean.

SimpleBean Makefiles
Below are two makefiles (Unix and Windows) set up to create SimpleBean.
# gnumake file

CLASSFILES= SimpleBean.class

JARFILE= SimpleBean.jar

all: $(JARFILE)

# Create a JAR file with a suitable manifest.
        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
        export CLASSPATH; CLASSPATH=. ; \
        javac $<

# make clean
        /bin/rm -f *.class
        /bin/rm -f $(JARFILE)
Here is the Windows nmake version:
# nmake file
CLASSFILES= simplebean.class

JARFILE= simplebean.jar

all: $(JARFILE)

# Create a JAR file with a suitable manifest.

        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 $<

        -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

The Properties sheet displays the selected Bean's properties. With SimpleBean selected, the Properties sheet displays four propeties: foreground, background, font, and name. We declared no properties in SimpleBean so these are properties inherited from Canvas. Clicking on each property brings up a property editor. The BeanBox provides default property editors for the primitive types, plus Font and Color types. You can find the sources for these property editors in beans/apis/sun/beans/editors.

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

Introspection is the process of discovering a Bean's design-time features by one of two methods:
  • 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.
You can generate a Bean introspection report by choosing the the Edit|Report menu item. The report lists Bean events, properties, and methods, and their characteristics. 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/ or run.bat to:
java sun.beanbox.BeanBoxFrame > beanreport.txt

More BDK Downloads

BeanBuilder Rev 22 download
Jabacoified BeanBuilder download


To conclude JavaBeans Development Kit (BDK) works on Windows operating system and can be easily downloaded using the below download link according to Freeware license. JavaBeans Development Kit (BDK) download file is only 1.1 MB in size.
JavaBeans Development Kit (BDK) was filed under the Java and Javascript category and was reviewed in and receive 5/5 Score.
JavaBeans Development Kit (BDK) has been tested by our team against viruses, spyware, adware, trojan, backdoors and was found to be 100% clean. We will recheck JavaBeans Development Kit (BDK) when updated to assure that it remains clean.

JavaBeans Development Kit (BDK) user Review

Please review JavaBeans Development Kit (BDK) application and submit your comments below. We will collect all comments in an effort to determine whether the JavaBeans Development Kit (BDK) software is reliable, perform as expected and deliver the promised features and functionalities.

Popularity 10/10 - Downloads - 745 - Score - 5/5

Category: Java and Javascript 
Publisher: Sun Microsystems, Inc.
Last Updated: 02/07/2019
Requirements: Not specified
License: Freeware
Operating system: Windows
Hits: 1613
File size: 1.1 MB
Price: Not specified

Leave A comment
Name: *
E-Mail: *
Comment: *