Implementing this method is a simple matter of adding the same number of else if blocks as the number of attributes we’re exposing from the parent class:

public class Queue extends Basic implements DynamicMBean {
// . . .
  public Object getAttribute(String attributeName) 
    throws AttributeNotFoundException,
           MBeanException,
           ReflectionException {
    Object ret = null;
  
    if (attributeName.equals("QueueSize")) {
      ret = new Integer(getQueueSize(  ));
    }
    // . . .
    else if (attributeName.equals("RemoveWaitTime")) {
      ret = new Long(getRemoveWaitTime(  ));
    }
    else if (attributeName.equals("NumberOfResets")) {
                        ret = new Integer(getNumberOfResets(  ));
                      }
                      else if (attributeName.equals("TraceOn")) {
                        ret = new Boolean(isTraceOn(  ));
                      }
    else throw new AttributeNotFoundException(
      "Queue.getAttribute(  ): ERROR: " +
      "Cannot find " + attributeName + " attribute.");
    }
    return ret;
  }
// . . .
}

We exposed two attributes from the parent class, so we write two else if blocks for those attributes and delegate to the appropriate method. We know we can call this method because of Java inheritance.

There are no writable attributes on Basic, but if there were, the logic would be similar to that of getAttribute( ). Suppose, for the purposes of example, that TraceOn is a writable attribute. In that case, the implementation of setAttribute( ) would look like this:

public class Queue extends Basic implements DynamicMBean {
// . . .
  public void setAttribute(Attribute attribute) 
    throws AttributeNotFoundException,
           InvalidAttributeValueException,
           MBeanException,
           ReflectionException {
  String name = attribute.getName(  );
  Object value = attribute.getValue(  );
  // See if attribute is on parent class
  if (name.equals("QueueSize")) {
    setQueueSize(((Integer)value).intValue(  ));
  }
  else if (name.equals("TraceOn")) {
                      setTraceOn(((Boolean)value).booleanValue(  ));
                    }
  else throw new AttributeNotFoundException(
    "Queue.getAttribute(  ): ERROR: " +
    "Cannot find " + attributeName + " attribute.");
  }
// . . .
}

If the name of the attribute to set is “TraceOn,” we simply invoke the setter for the attribute.

You are probably starting to see a pattern here. When you use explicit superclass exposure as the management interface inheritance mechanism for your MBeans, you simply include extra else if blocks for the attributes and, in this case, the operations that are to be exposed.

The following example shows how to use this approach to modify invoke( ) to expose Basic’s management interface methods:

public class Queue extends Basic implements DynamicMBean {
// . . .
  public Object invoke(String operationName,
                       Object params[],
                       String signature[])
      throws MBeanException,
             ReflectionException {
    Object ret = Void.TYPE;
    ret = Void.TYPE;
    if (operationName.equals("suspend")) {
      suspend(  );
    }
    else if (operationName.equals("resume")) {
      resume(  );
    }
    else if (operationName.equals("enableTracing")) {
                        enableTracing(  );
                      }
                      else if (operationName.equals("disableTracing")) {
                        disableTracing(  );
                      }
    else {
      throw new ReflectionException(
            new NoSuchMethodException(operationName),
                "Queue.invoke(  ): ERROR: " +
                "Cannot find the operation " + operationName + "!");
    }
    return ret;
  }
// . . .
}

One drawback of using explicit superclass exposure is that the child class must have explicit knowledge of the parent class’s management interface. Also, this approach is more susceptible to errors when code changes to the parent class are necessary. However, you must weigh these risks against the benefits of being able to selectively expose attributes and operations from the parent class’s management interface on the child class and base your decision of whether or not to use this approach on that information.

This method must have the same signature as its parent method, so we first check to see if the requested attribute is available on the child class and then, if it is not, delegate to the parent class’s getAttribute( ) method:

public class Queue extends Basic implements DynamicMBean {
// . . .
  public Object getAttribute(String attributeName) 
    throws AttributeNotFoundException,
           MBeanException,
           ReflectionException {
    Object ret = null;
    if (attributeName.equals("QueueSize")) {
      ret = new Integer(getQueueSize(  ));
    }
    // . . .
    else {
                        ret = super.getAttribute(attributeName);
                      }
    return ret;
  }
// . . .
}

I omitted some of the lines of code in this example, for the sake of brevity. (If you compare this example to the corresponding example from the explicit superclass exposure pattern, you can see how I simplified the code.) If the requested attribute is not available on the parent class, we can simply let the AttributeNotFoundException propagate out. The message generated will be from the parent class, but we can always surround the superclass delegation with a try/catch block and augment or modify any exception thrown by the superclass.

There are no writable attributes on either Queue or Basic, but superclass delegation is a generic approach, so the child class makes no assumptions about access to the attributes on the parent class. The following example shows how to implement setAttribute( ) using this approach:

public class Queue extends Basic implements DynamicMBean {
// . . .
  public void setAttribute(Attribute attribute)
    throws AttributeNotFoundException,
           InvalidAttributeValueException,
           MBeanException,
           ReflectionException {
    String name = attribute.getName(  );
    Object value = attribute.getValue(  );
    if (name.equals("QueueSize")) {
      setQueueSize(((Integer)value).intValue(  ));
    }
    super.setAttribute(attribute);
  }
// . . .
}

This example doesn’t contain the contrived writable TraceOn attribute of Basic, but notice how much simpler the code is compared to the corresponding explicit superclass exposure example from earlier in this chapter. If the attribute is not found on the child class, we simply delegate to the parent class. If an AttributeNotFoundException is thrown, we simply let it propagate out of this method.

Superclass delegation works the same way for this method as well. First we check to see if the method is exposed on the child class interface. If it is not, we delegate to the superclass:

public class Queue extends Basic implements DynamicMBean {
// . . .
  public Object invoke(String operationName,
                       Object params[],
                       String signature[])
    throws MBeanException,
           ReflectionException {
    Object ret = Void.TYPE;
    ret = Void.TYPE;
    if (operationName.equals("suspend")) {
      suspend(  );
    }
    else if (operationName.equals("resume")) {
      resume(  );
    }
    else {
                        super.invoke(operationName, params, signature);
                      }
    return ret;
  }
// . . .
}

Again, the code is greatly simplified because we delegate to the superclass if the method to invoke is not recognized.

One drawback of this approach is that you cannot selectively perform management interface inheritance; superclass delegation is generic and exposes the entire management interface of the parent class. However, this also means that changes to the parent class’s management interface will not ripple through the child class, as is the case with explicit superclass exposure.