TweetFollow Us on Twitter

Growing Java Beans

Volume Number: 14 (1998)
Issue Number: 9
Column Tag: JavaTech

Growing Java Beans

by Andrew Downs
Edited by the MacTech Editorial Staff

A code-based intro to Java's component architecture

Introduction

JavaBeans is the Java component architecture. This article discusses and demonstrates how to write several simple components (hereafter referred to as Beans). The reader should have a general familiarity with Java. The code in this article was developed using the Apple Mac OS Runtime for Java (MRJ) version 2.0 and the MRJ SDK 2.0.1 ea2.

For additional background information, several related articles previously published in MacTech are listed in the reference section at the end of this article. Several books are also listed.

Overview

A Java Bean bears a strong resemblance to a well-written Java application. But since it is a component, a Bean's scope is usually smaller than that of an entire application, making it easier to develop.

Here is a partial list of Bean characteristics. Beans should:

  • expose accessor methods (e.g. getValue() and setValue()) to allow retrieval and changing of attribute values by external sources;
  • allow for easy mixing and matching via GUI development tools;
  • generate or respond to appropriate events;
  • save their state using the Java Serialization mechanism.

In this article, we will explore the code behind two relatively simple Beans. They contain enough of the above-listed features to make them interesting, while remaining easy to read and understand. One of the Beans displays a sequence of lights similar to a U.S.-style traffic light. The other Bean changes the sequence of the light display. We will look at the code for these classes later.

Figure 1 shows the two Beans running within a Java Frame object. (A Frame is a platform-specific window.) Figure 2 shows the Beans running inside the BeanBox, a GUI tool from JavaSoftthat allows you to instantiate, connect, and test Bean behavior. The BeanBox is provided free of charge from JavaSoft, as part of the Beans Development Kit (BDK). Since it is written in Java, the BeanBox can be installed on the Macintosh using the MRJ Software Development Kit tools. It can then be run the same as other Java applications. The URL for obtaining the BeanBox is provided at the end of this article. (Note: you will need a file-extraction program that can open .zip files in order to unpack the BeanBox.)

Figure 1. The finished product running in its own container (a Frame).

Figure 2. Running inside the BeanBox.

Notice that there is little difference in the visible display of the Beans, whether running standalone or in the BeanBox. One Bean appears as a Java Choice menu (a Mac OS popup menu), and the other is a rectangle containing three circles, one of which is filled at any given time.

There are four classes that comprise this project:

  • Global: values shared by the other classes.
  • ModeSelector: a Choice (popup) menu, which specifies the mode of operation: in "normal" mode the lights flash in sequence (green - yellow - red), and in "maintenance" mode only the yellow light flashes.
  • Display: the component which draws the lights. Display also runs a Thread which adds timing capability to its operation.
  • DisplayFrame: a container for the Display and ModeSelector Beans.

We will cover each of these classes in sequence.

Global Values

This class defines some global values that are shared between the Display and ModeSelector classes. These values are collected in one place to simplify housekeeping and maintenance. We will refer to them from the other classes as Global.NORMAL, Global.sleep, etc. This is the Java syntax for referencing static (class) attributes. Note that final means the values cannot be changed after they are initially assigned, so these are constants.

Listing 1: Global.java

Global.java
// Shared values.

public class Global {
       // Mode values; all-caps to set them off from Strings of same name.
   public static final int NORMAL = 0, MAINT = 1;

       // Number of milliseconds for Thread to sleep.
   public static final int sleep = 250;

       // Choice menu item values.
   public static final String normal = "Normal";
   public static final String maint = "Maintenance";
}

Choice Bean

The ModeSelector Bean is a Choice menu component (a popup menu on the Mac). When the user changes the currently selected item, the Bean notifies any registered listeners. (We will see that the DisplayFrame class instantiates a Display object and registers it as a listener on a ModeSelector object.)

Listing 2: ModeSelector.java

ModeSelector.java
// A Choice menu class for changing the display mode (and resulting light sequence).

// Make available the following packages and classes:
import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.io.Serializable;
import java.util.Vector;

ModeSelector specifies that it implements the ItemListener interface so that it can receive item changed events (generated when the user makes a selection). The method that must be defined for the ItemListener interface is itemStateChanged(). In this implementation, ModeSelector ignores the event object contents, and checks its own state instead.

public class ModeSelector extends Choice implements 
   ItemListener, Serializable {

       // Mode value.
   private int mode = Global.NORMAL;

       // Keep track of other objects that want to be informed of changes.
   private PropertyChangeSupport changeListeners = 
      new PropertyChangeSupport( this );

   public ModeSelector() {
              // Call the superclass constructor.
      super();

              // Only two items in this menu.
      this.add( Global.normal );
      this.add( Global.maint );

              // Starting mode.
      this.setMode( Global.NORMAL );

              // Listen for selections on ourself.
      this.addItemListener( ( ItemListener )this );
   }

ModeSelector uses its own accessor methods to get and set the mode value. This may seem like overkill, since a class can access its own variables (even private ones, such as mode) directly. However, it is arguably a good habit, since variable references from outside the class should go through accessor methods, and never directly access variable values.

   public int getMode() {
              // Simple accessor function.
      return this.mode;
   }

   public void setMode( int i ) {
              // More complex accessor function.
              // Store the current mode.
      int old = this.getMode();

              // Set the current mode.
      if ( i == Global.NORMAL )
         this.mode = Global.NORMAL;
      else
         this.mode = Global.MAINT;

              // Notify our customers of the change.
      this.changeListeners.firePropertyChange( "mode", 
         new Integer( old ), new Integer( this.getMode() ) );
   }

   public void itemStateChanged( ItemEvent evt ) {
              // If the selected item has actually changed, then change
              // the mode accordingly.
      if ( ( this.getSelectedIndex() == Global.NORMAL ) 
         && ( this.getMode() == Global.MAINT ) )
         this.setMode( Global.NORMAL );
      else if ( ( this.getSelectedIndex() == Global.MAINT )
         && ( this.getMode() == Global.NORMAL ) )
         this.setMode( Global.MAINT );
   }

   public void addPropertyChangeListener( 
      PropertyChangeListener l ) {
              // Add someone else as a customer.
      changeListeners.addPropertyChangeListener( l );
   }

   public void removePropertyChangeListener( 
      PropertyChangeListener l ) {
              // Remove a customer.
      changeListeners.removePropertyChangeListener( l );
   }
}

Note that ModeSelector does not define any unique serialization that needs to occur. Instead, it uses the superclass' implementation.

Center of Attention

This Bean defines the lights that will be drawn as part of the traffic light. It also contains a Thread which is used to time the repaints.

Note that Display inherits directly from java.awt.Component. This makes it a "lightweight" component (as well as a Bean), which simply means that it has no native window object associated with it at runtime, and also none of the overhead associated with such an object.

Listing 3: Display.java

Display.java
// The traffic light class, which sequences and draws the colored lights.

import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.io.*;
import java.util.*;

public class Display extends Component implements 
   PropertyChangeListener, ItemListener, Serializable, 
   Runnable {

       // Size matters.
   private int width = 50, height = 165;

       // count = number of seconds.
       // mode determines display pattern.
       // interval = number of milliseconds for Thread to sleep. 
   private int count = 0, mode = Global.MAINT, interval = 
      Global.sleep;

       // color becomes important in NORMAL mode.
   private Color color;

       // Thread is not Serializable.
   transient private Thread runner;

   public Display() {
              // Call the superclass constructor.
      super();

              // We know how big we want to be.
      this.setSize( this.getPreferredSize() );

              // Set some instance variables.
      this.setMode( Global.NORMAL );
      this.setColor( Color.red );

              // Create and start a Thread.
      runner = new Thread( this );
      runner.start();
   }

The runner object used in this class, in conjunction with the Runnable interface, allows Display to take on the behavior of a Thread without actually subclassing directly from Thread. In the run() method, the runner is put to sleep temporarily. On wakeup, it compares the current time to the reference time, and if the reference time has been exceeded, this object's state gets updated (i.e. the light color may change).

   public void run() {
              // Reference point will be current time plus 1 second.
      Calendar triggerTime = Calendar.getInstance();
      triggerTime.add( Calendar.SECOND, 1 );

      while ( true ) {

         try {
                            // Sleep for <interval> milliseconds.
            Thread.sleep( this.interval );
         }
         catch ( InterruptedException ex ) {
            System.out.println( "InterruptedException..." );
         }

                      // Compare the current time to the reference point.
         if ( Calendar.getInstance().after( triggerTime ) ) {
                            // Take action.
            this.timerExpired();

                            // Reset the reference point.
            triggerTime = Calendar.getInstance();
            triggerTime.add( Calendar.SECOND, 1 );
         }
      }
   }

Overriding the getPreferredSize() method (whose original definition is in java.awt.Component) enables us to specify the desired size (in pixels) of this object. Notice that the preferred size will also be the minimum size. If we do not override these methods, some containers (such as the BeanBox) will not automatically size the object so that the lights are visible.

   public Dimension getPreferredSize() {
              // When queried, we know how big we *want* to be.
      return new Dimension( this.width, this.height );
   }

   public Dimension getMinimumSize() {
              // Our preferred size is already the minimum size.
      return this.getPreferredSize();
   }

The itemStateChanged() method allows this component to be dynamically connected to a source of ItemEvents, such as the ModeSelector class. Without it, you must directly bind the "mode" property of both classes in order to see a state change while running in the BeanBox.

   public void itemStateChanged( ItemEvent evt ) {
              // If the selected item has actually changed, 
              // then change the mode accordingly.
              // This is the same method as in ModeSelector.java.
              // Here, it allows this Component to receive changes directly,
              // and get hooked up in the BeanBox.
      if ( evt.getItem().toString().equals( Global.normal ) 
         && this.getMode() == Global.MAINT ) {
         this.setMode( Global.NORMAL );
         this.reset();
      }
      else if 
         ( evt.getItem().toString().equals( Global.maint ) 
         && this.getMode() == Global.NORMAL ) {
         this.setMode( Global.MAINT );
         this.reset();
      }
   }

The following method gets called from run() approximately every second. The timing used here is simple: in normal mode, each light will be "on" for five seconds; in maintenance mode, that interval is reduced to one second. In terms of color, normal mode sequences the lights (green, then yellow, then red), while maintenance mode only flashes the yellow light.

   public void timerExpired() {
              // count is the number of elapsed seconds.
      this.count++;

      if ( this.getMode() == Global.NORMAL ) {
                     // In normal mode, each light stays on for 5 seconds.
         if ( this.count > 4 ) {
            this.count = 0;

                            // Cycle through the light sequence.
            if ( this.getColor() == Color.red )
               this.setColor( Color.green );
            else if ( this.getColor() == Color.yellow )
               this.setColor( Color.red );
            else
               this.setColor( Color.yellow );

            repaint();
         }
      }
      else if ( mode == Global.MAINT ) {
                     // In maintenance mode, the light stays on for 1 second.
         if ( this.count > 0 ) {
            this.count = 0;

                            // Alternate yellow and black.
            if ( this.getColor() == Color.yellow )
               this.setColor( Color.black );
            else
               this.setColor( Color.yellow );

            repaint();
         }
      }
   }

   public void paint( Graphics g ) {
              // Draw the background.
      g.setColor( Color.lightGray );
      g.fillRect( 0, 0, 50, 165 );

      if ( this.getMode() == Global.NORMAL ) {
                     // For any light, black signifies "off".
         g.setColor( Color.black );

                     // Handle the red light.
         if ( this.getColor() == Color.red )
            g.setColor( this.getColor() );
         g.fillOval( 5, 10, 40, 40 );

                     // Handle the yellow light.
         if ( this.getColor() == Color.yellow )
            g.setColor( this.getColor() );
         else
            g.setColor( Color.black );
         g.fillOval( 5, 60, 40, 40 );

                     // Handle the green light.
         if ( this.getColor() == Color.green )
            g.setColor( this.getColor() );
         else
            g.setColor( Color.black );
         g.fillOval( 5, 110, 40, 40 );
      }
      else if ( this.getMode() == Global.MAINT ) {
                     // Red light is always "off".
         g.setColor( Color.black );
         g.fillOval( 5, 10, 40, 40 );

                     // Yellow light may be "on".
         if ( this.getColor() == Color.yellow )
            g.setColor( this.getColor() );
         g.fillOval( 5, 60, 40, 40 );

                     // Green light is always "off".
         g.setColor( Color.black );
         g.fillOval( 5, 110, 40, 40 );
      }
   }

       // Four simple accessor methods.
   public Color getColor() {
      return this.color;
   }

   public void setColor( Color c ) {
      this.color = c;
   }

   public int getMode() {
      return mode;
   }

   public void setMode( int i ) {
      mode = i;
   }

   public void propertyChange( PropertyChangeEvent evt ) {
              // This is how we get notified of a property change.
              // Make ints out of the old and new values...
      Integer theOldInt = ( Integer )( evt.getOldValue() );
      Integer theNewInt = ( Integer )( evt.getNewValue() );

              // ...then compare them. Any change is acceptable.
      if ( theNewInt.intValue() != theOldInt.intValue() ) {
         mode = theNewInt.intValue();
         this.reset();
      }
   }

   private void reset() {
              // In several cases, we need a way to force the lights 
              // to a known starting point.
      this.setColor( Color.yellow );
      this.count = 5;
      this.repaint();
   }

When retrieving the object's state, the runner object must be created from scratch, since the Thread class is not serializable.

   private void readObject( ObjectInputStream s ) throws 
      ClassNotFoundException, IOException {
              // Always call the default read method.
      s.defaultReadObject();

              // Since the Thread cannot be saved, create a new one after
              // startup and state retrieval.
      runner = new Thread( this );
      runner.start();
   }
}

Container App

The DisplayFrame class is provided as a container app for the other Beans we've built. It is a Frame containing the Display (traffic light) and ModeSelector. Figure 1 shows the Beans running inside a DisplayFrame object. Since DisplayFrame is an application, it can run independently of the BeanBox.

Listing 4: DisplayFrame.java

DisplayFrame.java
// A container app for runtime.

import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.io.*;
import java.util.*;

public class DisplayFrame extends Frame implements 
   Serializable {
       // Frame size.
   int width = 125, height = 185;

   public static void main( String args[] ) {
              // This class can be run outside of the BeanBox.
      DisplayFrame df = new DisplayFrame();
   }

   public DisplayFrame() {
              // Call the superclass constructor.
      super();

              // We know how big we want to be.
      this.setSize( this.width, this.height );

              // Create the traffic light...
      Display display = new Display();

              // ...and the choice menu.
      ModeSelector ms = new ModeSelector();

Add the Display object as a listener on the ModeSelector, so that it will be notified when the "mode" value changes.

      ms.addPropertyChangeListener( 
         ( PropertyChangeListener )display );

              // Setup the display area.
      Panel p = new Panel();
      p.setLayout( new BorderLayout() );
      p.add( "Center", display );
      p.add( "South", ms );

      this.add( p );
      this.setVisible( true );
   }

   public Dimension getPreferredSize() {
              // When queried, we know how big we *want* to be.
      return new Dimension( this.width, this.height );
   }

   public Dimension getMinimumSize() {
              // Our preferred size is already the minimum size.
      return this.getPreferredSize();
   }

   private void readObject( ObjectInputStream s ) throws 
      ClassNotFoundException, IOException {
              // Always call the default read method.
      s.defaultReadObject();
   }
}

Compiling and Running

You can compile the .java (source) files using the javac (Java compiler) tool included in the MRJ SDK Tools folder, or using the Java compiler in CodeWarrior or Visual Cafe. You can then optionally create a .jar (Java ARchive) file containing the resulting .class (output) files.

The archive for this article includes the .java and .class files (in separate directories), and individual .jar files containing each Bean and Global.class. In addition, the manifest directory contains manifest files for each of the classes, for use in building JAR files. You can also combine the manifests and classes into one big JAR file.

To run the program, drag the file DisplayFrame.class onto the JBindery application icon, which is located in the MRJ SDK JBindery folder. Once JBindery launches, it will display "DisplayFrame" in the class name field. (This field specifies the name of the class to run at application startup; that class must contain a main() method.) Click OK to run the program. To run inside the BeanBox, add the .jar files to the jars directory on your hard drive. Then, launch the BeanBox application. It should open and read the .jar files, and display the Beans in the palette on the left side. It will write an error message to the console stating that Global.jar does not contain any Beans. This is not a problem, since we know that Global is not a Bean, but rather a supporting class.

Conclusion

Java Beans should be reusable, customizable, and packaged in JAR files. As Bean development tools become more widespread, developers will find it even easier to create custom apps by combining Beans in new ways. Bean development allows an incremental, flexible approach which should make it easy for all developers to participate.

References

  • Developing Java Beans, Robert Englander, O'Reilly & Associates, Inc., 1997.
  • Java in a Nutshell, David Flanagan, O'Reilly & Associates, Inc., 1997.
  • Exploring Java, Patrick Niemeyer and Joshua Peck, O'Reilly & Associates, Inc., 1997.
  • Java Serialization, Andrew Downs, MacTech Magazine, April 1998.
  • Building Beans, Will Iverson, MacTech Magazine, June 1997.

URLs


Andrew Downs is a Senior Software Engineer for Template Software in New Orleans, LA, designing and building enterprise apps. He's trying to teach his twin sons that mice are for pointing, not eating. Andrew wrote the Macintosh freeware program Recent Additions, and the Java application UDPing. You can reach him at andrew@nola.template.com.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

The beginner's guide to Warbits
Warbits is a turn-based strategy that's clearly inspired by Nintendo's Advance Wars series. Since turn-based strategy games can be kind of tricky to dive into, see below for a few tips to help you in the beginning. Positioning is crucial [Read... | Read more »
How to upgrade your character in Spellsp...
So you’ve mastered the basics of Spellspire. By which I mean you’ve realised it’s all about spelling things in a spire. What next? Well you’re going to need to figure out how to toughen up your character. It’s all well and good being able to spell... | Read more »
5 slither.io mash-ups we'd love to...
If there's one thing that slither.io has proved, it's that the addictive gameplay of Agar.io can be transplanted onto basically anything and it will still be good fun. It wouldn't be surprising if we saw other developers jumping on the bandwagon,... | Read more »
How to navigate the terrain in Sky Charm...
Sky Charms is a whimsical match-'em up adventure that uses creative level design to really ramp up the difficulty. [Read more] | Read more »
Victorious Knight (Games)
Victorious Knight 1.3 Device: iOS Universal Category: Games Price: $1.99, Version: 1.3 (iTunes) Description: New challenges awaits you! Experience fresh RPG experience with a unique combat mechanic, packed with high quality 3D... | Read more »
Agent Gumball - Roguelike Spy Game (Gam...
Agent Gumball - Roguelike Spy Game 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: Someone’s been spying on Gumball. What the what?! Two can play at that game! GO UNDERCOVERSneak past enemy... | Read more »
Runaway Toad (Games)
Runaway Toad 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: It ain’t easy bein’ green! Tap, hold, and swipe to help Toad hop to safety in this gorgeous new action game from the creators of... | Read more »
PsyCard (Games)
PsyCard 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: From the makers och Card City Nights, Progress To 100 and Ittle Dew PSYCARD is a minesweeper-like game set in a cozy cyberpunk... | Read more »
Sago Mini Robot Party (Education)
Sago Mini Robot Party 1.0 Device: iOS Universal Category: Education Price: $2.99, Version: 1.0 (iTunes) Description: -- Children's Technology Review Editor's Choice -- | Read more »
How to get a high score in every level o...
Sky Charms is an adorable match three puzzler that provides a decent challenge thanks to its creative level design. It regularly presents something new, forcing you to think on your feet. [Read more] | Read more »

Price Scanner via MacPrices.net

Apple restocks Certified Refurbished Mac mini...
Apple has restocked Certified Refurbished 2014 Mac minis, with models available starting at $419. Apple’s one-year warranty is included with each mini, and shipping is free: - 1.4GHz Mac mini: $419 $... Read more
15-inch 2.2GHz Retina MacBook Pro on sale for...
Amazon.com has the 15″ 2.2GHz Retina MacBook Pro on sale for $1699.99 including free shipping. Their price is $300 off MSRP, and it’s the lowest price available for this model from any reseller (and... Read more
Apple Beats Microsoft at Own Game; Amazon Pri...
First quarter seasonality combined with an overall disinterested customer base led to an annual decline of 14.7% in worldwide tablet shipments during the first quarter of 2016 (1Q16). Worldwide... Read more
Tablets Had Worst Quarter Since 2012, says St...
The global tablet market began 2016 just as 2015 left off, down. Tablet shipments fell 10% to 46.5 million units during the Q1 2016, according to the new “Preliminary Global Tablet Shipments and... Read more
Clearance 13-inch MacBook Airs, Apple refurbi...
Apple recently dropped prices on certified refurbished 2015 13″ MacBook Airs with 4GB of RAM with models now available starting at $759. An Apple one-year warranty is included with each MacBook, and... Read more
Clearance 12-inch Retina MacBooks, Apple refu...
Apple has dropped prices on Certified Refurbished 2015 12″ Retina MacBooks with models now available starting at $929. Apple will include a standard one-year warranty with each MacBook, and shipping... Read more
Aleratec Releases Mac Software Upgrade for 1...
California based Aleratec Inc., designer, developer and manufacturer of Portable Device Management (PDM) charge/sync products for mobile devices and professional-grade duplicators for hard disk... Read more
Sale! Amazon offers 27-inch iMac, 13-inch 2.9...
Amazon has the 27″ 3.2GHz 5K iMac and the 13″ 3.9GHz Retina MacBook Pro on sale for $300 off MSRP, each including free shipping, for a limited time: - 27″ 3.2GHz/1TB HD 5K iMac (model MK462LL/A): $... Read more
Apple refurbished 13-inch Retina MacBook Pros...
Apple has Certified Refurbished 13″ Retina MacBook Pros available for up to $270 off the cost of new models. An Apple one-year warranty is included with each model, and shipping is free: - 13″ 2.7GHz... Read more
13-inch 2.7GHz/128GB Retina MacBook Pro on sa...
Take $200 off MSRP on the price of a new 13″ 2.7GHz/128GB Retina MacBook Pro (model MF839LL/A) at Amazon. Shipping is free: - 13″ 2.7GHz/128GB Retina MacBook Pro: $1099.99 $200 off MSRP Act now if... Read more

Jobs Board

Automotive Sales Consultant - Apple Ford Linc...
…you. The best candidates are smart, technologically savvy and are customer focused. Apple Ford Lincoln Apple Valley is different, because: $30,000 annual salary Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
*Apple* Solutions Consultant - Apple (United...
# Apple Solutions Consultant Job Number: 48260200 Phoenix, Arizona, United States Posted: Apr. 22, 2016 Weekly Hours: 40.00 **Job Summary** As an Apple Solutions Read more
Restaurant Manager (Neighborhood Captain) - A...
…in every aspect of daily operation. WHY YOU'LL LIKE IT: You'll be the Big Apple . You'll solve problems. You'll get to show your ability to handle the stress and Read more
Simply Mac *Apple* Specialist- Service Repa...
Simply Mac is the largest premier retailer of Apple products in the nation. In order to support our growing customer base, we are currently looking for a driven Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.