Saturday, August 20, 2016

Persistence

Persistence

Persistence is the ability to save a Bean to nonvolatile storage and retrieve it at a later time. The information that is particularly important are the configuration settings. 
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. These changes can be saved. 
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.

Labels:

Using the BeanInfo Interface

Using the BeanInfo Interface

Design patterns were used to determine the information that was provided to a Bean user. 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. SimpleBeanInfo is a class that provides default implementations of the BeanInfo interface, including the three methods just shown. You may extend this class and override one or more of them. The following listing shows how this is done for the Colors Bean that was developed earlier. ColorsBeanInfo is a subclass of SimpleBeanInfo.

It overrides getPropertyDescriptors( ) in order to designate which properties are presented to a Bean user. This method creates a PropertyDescriptor object for the rectangular property. The PropertyDescriptor constructor that is used is shown here:

          PropertyDescriptor(String property, Class beanCls) throws IntrospectionException

Here, the first argument is the name of the property, and the second argument is the class of the Bean.

// 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.
The introspection facilities are designed to look for a BeanInfo class. If it exists, its behavior explicitly determines the information that is presented to a Bean user. Otherwise, design patterns are used to infer this information.



Labels:

Friday, August 19, 2016

Using Bound Properties

Using Bound Properties

A Bean that has a bound property generates an event when the property is changed. The event is of type PropertyChangeEvent and is sent to objects that previously registered an interest in receiving such notifications.
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.”

You should now see the color of your component change every second.

Labels:

Developing a Simple Bean Using the BDK

Developing a Simple Bean Using the BDK

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.


Create a New Bean

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. To follow along with this example, create
c:\bdk\demo\sunw\demo\colors. Then change to that directory.

Create the Source File for the New Bean

// 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);
}
}
}

The import statement at the beginning of the file places it in the package named sunw.demo.colors. Recall from Chapter 9 that the directory hierarchy corresponds to the package hierarchy. Therefore, this file must be located in a subdirectory named sunw\demo\colors relative to the CLASSPATH environment variable.
The color of the component is determined by the private Color variable color, and its shape is determined by the private boolean variable rectangular.
The constructor defines an anonymous inner class that extends MouseAdapter and overrides its mousePressed( ) method. The change( ) method is invoked in response to mouse presses. The component is initialized to a rectangular shape of 200 by 100 pixels.
The change( ) method is invoked to select a random color and repaint the component.
The getRectangular( ) and setRectangular( ) methods provide access to the one property of this Bean. The change( ) method calls randomColor( ) to choose a color and then calls repaint( ) to make the change visible. Notice that the paint( ) method uses the rectangular and color variables to determine how to present the Bean.

Compile the Source Code for the New Bean

Compile the source code to create a class file. Type the following:
                                 
                          javac Colors.java

Create a Manifest File

You must now 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.

          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. You should see three windows, titled ToolBox, BeanBox, and Properties. The ToolBox window should include an entry labeled “Colors” for your new Bean.

Create an Instance of the Colors Bean

After you complete the preceding steps, 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 and Configure an Instance of the OurButton Bean

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.

Labels:

Introspection in Java Beans

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. Without introspection, the Java Beans technology could not operate.
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.

Design Patterns for Properties

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);

A 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;
}
}


Boolean Properties

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);

Either the first or second pattern can be used to retrieve the value of a Boolean property. However, if a class has both of these methods, the first pattern is used.

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[ ]);

The following listing shows a class that has one read/write indexed property:

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);
}

Labels:

JAR Files and Manifest Files for Java Beans

JAR Files

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.

JAR technology makes it much easier to deliver and install software. Also, the elements in a JAR file are compressed, which makes downloading a JAR file much faster than separately downloading several uncompressed files. Digital signatures may also be associated with the individual elements in a JAR file. This allows a consumer to be sure that these elements were produced by a specific organization or individual.
The package java.util.zip contains classes that read and write JAR files.

The JAR Utility

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

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 *


Manifest 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”.


Labels:

Thursday, August 18, 2016

Introduction to Java Beans

Java Bean

A Java Bean is a software component that has been designed to be reusable in a variety of different environments. 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. Finally, a Bean may be designed to work autonomously on a user’s workstation or to work in cooperation with a set of other distributed components. Software to generate a pie chart from a set of data points is an example of a Bean that can execute locally.
However, a Bean that provides real-time price information from a stock or commodities exchange would need to work in cooperation with other distributed software to obtain its data.

Advantages of Java Beans

A software component architecture provides standard mechanisms to deal with software building blocks. The following list enumerates some of the specific benefits that Java technology provides for a component developer:
■ 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.

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 Java 2 SDK must be installed on your machine for the BDK to work. Confirm that the SDK tools are accessible from your environment.
The BDK can then be downloaded from the JavaSoft site (http://java.sun.com). It is packaged as one file that is a self-extracting archive. Follow the instructions to install it on your machine. The discussion that follows assumes that the BDK is installed in a directory called bdk. If this is not the case with your system, substitute the proper directory.

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. 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. You may also see a window called Method Tracer, but we won’t be using it.

Using the BDK

This example is 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, buckminsterfullerine, cyclohexane, ethane, or water. This component also has methods that allow the molecule to be rotated in space along its X or Y axis.


Create and Configure an Instance of the Molecule Bean

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 leftmouse 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.



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.

Create and Configure an Instance of the OurButton Bean

Follow these steps to create and configure an instance of the OurButton Bean and connect it to the Molecule Bean:
1. Position the cursor on the ToolBox entry labeled OurButton 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 button. This area is surrounded by a hatched border indicating that it is currently selected.

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

4. Go to the Properties window and change the label of the Bean to “Rotate X”. The button appearance changes immediately when this property is changed.

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 and compiling adaptor class.”

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

Labels:

Saturday, July 16, 2016

Creating and Running User Defined Java Bean

Creating and Running User Defined Java Bean :


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.

1. Create a Directory for the New Bean
              You need to make a directory for the Bean. To follow along with this example, create

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

2. Create the Source File for the New 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);
}
}
}
The source code for the Colors component is shown in the following listing. It is
located in the file Colors.java.
The import statement at the beginning of the file places it in the package named
sunw.demo.colors. Recall from Chapter 9 that the directory hierarchy corresponds to
the package hierarchy. Therefore, this file must be located in a subdirectory named
sunw\demo\colors relative to the CLASSPATH environment variable.
The color of the component is determined by the private Color variable color, and
its shape is determined by the private boolean variable rectangular.
The constructor defines an anonymous inner class that extends MouseAdapter and
overrides its mousePressed( ) method. The change( ) method is invoked in response to
mouse presses. The component is initialized to a rectangular shape of 200 by 100 pixels.
The change( ) method is invoked to select a random color and repaint the component.
The getRectangular( ) and setRectangular( ) methods provide access to the one
property of this Bean. The change( ) method calls randomColor( ) to choose a color and
then calls repaint( ) to make the change visible. Notice that the paint( ) method uses the
rectangular and color variables to determine how to present the Bean.

3. Compile the Source Code for the New Bean

Compile the source code to create a class file. Type the following:

javac Colors.java.

4. Create a Manifest File:

You must now 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.

5. 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.
(You may wish to put this in a batch file for future use.)

6. Start the BDK

Change to the directory c:\bdk\beanbox and type run. This causes the BDK to start.
You should see three windows, titled ToolBox, BeanBox, and Properties. The ToolBox
window should include an entry labeled “Colors” for your new Bean.

7. Create an Instance of the Colors Bean

After you complete the preceding steps, 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 and Configure an Instance of the OurButton Bean

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.




Labels: ,