Java Beans Tutorial, Pt. 4: Reflection and MethodDescriptors for NervousText

Print-friendly Version

[Tutorial Contents]

In this section the property editor and basic NervousText classes remain the same (except name changes for version 08) while some changes are made to the NervousText08BeanInfo class to reduce the number of methods exposed to builder tools.

  copy NervousText07.java to 
NervousText08.java
  copy NervousText07BeanInfo.java      
      to NervousText08BeanInfo.java
  copy NervousText07TextPropertyEditor.java 
      to NervousText08TextPropertyEditor.java

Make the appropriate changes to the class names and debug messages stubs in each file (changing NervousText07 to NervousText08 throughout each file).

Now for some reflection. You'll be making the following changes to NervousText08BeanInfo.

To use the Method class, you'll need to add an import statement at the top of the file.

import java.lang.reflect.Method;

bd.setDisplayName("Uneasy Text 07");

bd.setDisplayName("Uneasy Text 08");

The goal of the next set of changes is to reduce the number of event handler methods discovered by a builder tool. You might write a dozen or more public methods, but only want two of them to be exposed. The methods displayed are limited to one ActionEvent event handler to respond to button presses from other objects, and one PropertyChangeEvent event handler. Recall the PropertyChangeEvent event was used to support bound properties in an earlier version of NervousText so that changes to the text could notify other interested objects.

This reduction in visible methods is achieved by adding a new method called getMethodDescriptors whose structure resembles getPropertyDescriptors. Instead of returning an array of PropertyDescriptor, getMethodDescriptors returns an array of MethodDescriptor objects. The basic skeleton is as follows:

public MethodDescriptor[] getMethodDescriptors() {
  ...
  MethodDescriptor result[] = { ... };
  ...
  return result;
}

Of course there's a bit involved in setting up the array of MethodDescriptor objects to be returned. You're going to return four methods in all: a startMethod, a stopMethod and a changeDirectionMethod to respond to ActionEvents from buttons, as well as a propertyChangeMethod to respond to property change notifications from other Beans.

Each of these is declared as a local variable inside of getMethodDescriptors:

public MethodDescriptor[] getMethodDescriptors() {
  Method startMethod, stopMethod, 
    changeDirectionMethod;
  Method propertyChangeMethod;
  ...
}

You'll be calling getMethod for the Class object automatically associated with NervousText08. Recall from a previous section that this Class object can be retrieved by direct reference:

  NervousText08.class

  NervousText08.class.getMethod( ... );

The start and stop methods don't take any arguments, so the array of arguments passed to getMethod is empty.

  Class args[] = { };

  try {
    startMethod = NervousText08.class.getMethod(
        "start", args);
    stopMethod = NervousText08.class.getMethod(
        "stop", args);

  Class actionEventArgs[] = { 
     java.awt.event.ActionEvent.class };

With the array declared you can retrieve the method:

    changeDirectionMethod = 
        NervousText08.class.getMethod(
        "changeDirection", actionEventArgs);

The PropertyChangeEvent is set up in a similar manner:

  Class propertyChangeEventArgs[] = { 
      PropertyChangeEvent.class };
  ...
  propertyChangeMethod = NervousText08.class.getMethod(
     "makeChange", propertyChangeEventArgs);

Now that you have all the Methods, you can build an array of MethodDescriptor objects to be returned by getMethodDescriptors.

  // Now create the MethodDescriptor array
  // with visible event response methods:
  MethodDescriptor result[] = { 
    new MethodDescriptor(startMethod),
    new MethodDescriptor(stopMethod),
    new MethodDescriptor(changeDirectionMethod),
    new MethodDescriptor(propertyChangeMethod)
  };  

public MethodDescriptor[] getMethodDescriptors() {
  System.err.println("ENTER---> 
    NervousText08BeanInfo.getMethodDescriptors");

  // First find the "method" objects.
  Method startMethod, stopMethod, changeDirectionMethod;
  Method propertyChangeMethod;
  Class args[] = { };
  Class actionEventArgs[] = { 
    java.awt.event.ActionEvent.class };
  Class propertyChangeEventArgs[] = { 
    PropertyChangeEvent.class };

  try {
    startMethod = NervousText08.class.getMethod(
      "start", args);
    stopMethod = NervousText08.class.getMethod(
      "stop", args);
               
    // ActionEvent handler methods
    //FIND METHOD: 
    //  public void changeDirection(ActionEvent x)
    changeDirectionMethod = 
      NervousText08.class.getMethod(
      "changeDirection", actionEventArgs);

    // PropertyChangeEvent handler methods
    // FIND METHOD public void makeChange (
    //   PropertyChangeEvent evt) {
    propertyChangeMethod = NervousText08.class.getMethod(
       "makeChange", propertyChangeEventArgs);
  } catch (Exception ex) {
    // "should never happen"
    throw new Error("Missing method: " + ex);
  }

  // Now create the MethodDescriptor array
  // with visible event response methods:
  MethodDescriptor result[] = { 
    new MethodDescriptor(startMethod),
    new MethodDescriptor(stopMethod),
    new MethodDescriptor(changeDirectionMethod),
    new MethodDescriptor(propertyChangeMethod)
  };  
  System.err.println("EXIT----> 
       NervousText08BeanInfo.getMethodDescriptors");
  return result;
}

Important JDK classes used in this example:

Method

Class

MethodDescriptor

PropertyDescriptor

SimpleBeanInfo

NervousText08.java

NervousText08BeanInfo.java

NervousText08TextPropertyEditor.java