1. Create a class that implements javax.management.NotificationListener.

   See NotificationListener in the Java SE 17 API Specification at https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/NotificationListener.html.

2. Within the class, add a NotificationListener.handleNotification(Notification notification, java.lang.Object handback) method.

   Note:

   Your implementation of this method should return as soon as possible to avoid blocking its notification broadcaster.

3. (Optional) In most listening situations, you want to know more than the simple fact that an MBean has emitted a notification object. For example, you might want to know the value of the notification object's Type attribute, which is used to classify the type of event that caused the notification to be emitted.

   To retrieve information from a notification object, within your handleNotification method invoke the object's methods. Because all notification types extend javax.management.Notification, the following Notification methods are available for all notifications:

   • getMessage()

   • getSequenceNumber()

   • getTimeStamp()

   • getType()

   • getUserData()

   See Notification in the Java SE 17 API Specification at https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/Notification.html.

   Most notification types provide additional methods for retrieving data that is specific to the notification. For example, javax.management.AttributeChangeNotification provides getNewValue() and getOldValue(), which you can use to determine how the attribute value has changed.

import javax.management.Notification;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.AttributeChangeNotification;

public class MyListener implements NotificationListener {

    public  void handleNotification(Notification notification, Object obj) {

        if(notification instanceof AttributeChangeNotification) {
            AttributeChangeNotification attributeChange =
                     (AttributeChangeNotification) notification;
            System.out.println("This notification is an
                      AttributeChangeNotification");
            System.out.println("Observed Attribute: " +
                                       attributeChange.getAttributeName() );
            System.out.println("Old Value: " + attributeChange.getOldValue() );
            System.out.println("New Value: " + attributeChange.getNewValue() );
        }
    }
}

• Listening from a Remote JVM
  
• Best Practices: Creating a Notification Listener
  

1. In the class that registers your listener with an MBean create an instance of javax.management.NotificationFilterSupport or AttributeChangeNotificationFilter.
2. Invoke a filter class method to specify filter criteria.

   See NotificationFilterSupport (https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/NotificationFilterSupport.html) or AttributeChangeNotificationFilter (https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/AttributeChangeNotificationFilter.html) in the Java SE 17 API Specification.

AttributeChangeNotificationFilter filter = 
   new AttributeChangeNotificationFilter();
filter.enableAttribute("State"); 

• Creating a Custom Filter
  

1. Initialize a connection to a Runtime MBean Server or the Domain Runtime MBean Server.

   See Make Remote Connections to an MBean Server.

2. To register with a WebLogic Server MBean, navigate the MBean hierarchy and retrieve an object name for the MBean that you want to listen to. See Make Remote Connections to an MBean Server.

   To register with a custom MBean, create an ObjectName that contains the MBean's JMX object name. See javax.management.ObjectName in the Java SE 17 API Specification at https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/ObjectName.html.

3. Instantiate the listener class that you created.
4. (Optional) Instantiate and configure one of the JDK's filter classes or instantiate a custom class.
5. Register the listener and filter by passing the MBean's object name, listener class, and filter class to the MBeanServerConnection.addNotificationListener (ObjectName name, ObjectName listener, NotificationFilter filter,Object handback) method.

import java.util.Hashtable;
import java.io.IOException;
import java.net.MalformedURLException;

import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
import javax.management.MalformedObjectNameException;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import javax.naming.Context;

import javax.management.AttributeChangeNotificationFilter;

public class RegisterListener {
   private static MBeanServerConnection connection;
   private static JMXConnector connector;
   private static final ObjectName service;
   // Initializing the object name for DomainRuntimeServiceMBean
   // so it can be used throughout the class.
   static {
      try {
         service = new ObjectName(
         "com.bea:Name=DomainRuntimeService,Type=weblogic.management.mbeanserv
          ers.domainruntime.DomainRuntimeServiceMBean");
      }catch (MalformedObjectNameException e) {
         throw new AssertionError(e.getMessage());
      }
   }

   /*
    * Initialize connection to the Domain Runtime MBean Server
    * each server in the domain hosts its own instance.
    */
   public static void initConnection(String hostname, String portString, 
      String username, String password) throws IOException,
      MalformedURLException {
      String protocol = "t3";
      Integer portInteger = Integer.valueOf(portString);
      int port = portInteger.intValue();
      String jndiroot = "/jndi/";
      String mserver = "weblogic.management.mbeanservers.domainruntime";
      JMXServiceURL serviceURL = new JMXServiceURL(protocol, hostname, port,
         jndiroot + mserver);
      Hashtable h = new Hashtable();
      h.put(Context.SECURITY_PRINCIPAL, username);
      h.put(Context.SECURITY_CREDENTIALS, password);
      h.put(JMXConnectorFactory.PROTOCOL_PROVIDER_PACKAGES,
         "weblogic.management.remote");
      connector = JMXConnectorFactory.connect(serviceURL, h);
      connection = connector.getMBeanServerConnection();
   }

   /*
    * Get an array of ServerLifeCycleRuntimeMBeans
    */
   public static ObjectName[] getServerLCRuntimes() throws Exception {
      ObjectName domainRT = (ObjectName) connection.getAttribute(service,
         "DomainRuntime"); 
      return (ObjectName[]) connection.getAttribute(domainRT,
         "ServerLifecycleRuntimes");
   }

   public static void main(String[] args) throws Exception {
      String hostname = args[0];
      String portString = args[1];
      String username = args[2];
      String password = args[3]; 
      try {
         //Instantiating your listener class.
         MyListener listener = new MyListener();
         AttributeChangeNotificationFilter filter = 
            new AttributeChangeNotificationFilter();
         filter.enableAttribute("State");           

         initConnection(hostname, portString, username, password);
         //Passing the name of the MBeans and your listener class to the
         //addNotificationListener method of MBeanServer.
         ObjectName[] serverLCRT = getServerLCRuntimes();
         int length= (int) serverLCRT.length;
         for (int i=0; i < length; i++) {
            connection.addNotificationListener(serverLCRT[i], listener, 
               filter, null);
            System.out.println("\n[myListener]: Listener registered with"
               +serverLCRT[i]);
         }

      //Keeping the remote client active.
         System.out.println("pausing...........");
         System.in.read();
      } catch(Exception e) {
         System.out.println("Exception: " + e);
      }
   }
}

JMX provides monitor MBeans that are specialized to observe specific types of changes:

• StringMonitorMBean observes attributes whose value is a String.

  Use this monitor to periodically observe attributes such as ServerLifeCycleRuntimeMBean State.

  See javax.management.monitor.StringMonitor in the Java SE 17 API Specification at https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/monitor/StringMonitor.html, which implements StringMonitorMBean.

• GaugeMonitorMBean observes attributes whose value is a Number.

  Use this monitor to observe an attribute whose value fluctuates as a result of normal operations. Configure the gauge monitor to emit a notification if the value of the attribute fluctuates outside a specific range. For example, you can use it to monitor the ThreadPoolRuntimeMBean StandbyThreadCount attribute to verify that the number of unused but available threads in a server falls within an acceptable range.

  See javax.management.monitor.GaugeMonitor in the Java SE 17 API Specification (see https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/monitor/GaugeMonitor.html), which implements GaugeMonitorMBean.

• CounterMonitorMBean observes attributes whose value is a Number.

  Use this monitor to observe an attribute whose value only increases as a result of normal operation. Configure the counter monitor to emit a notification if the value of the attribute crosses an upper threshold. You can also configure the counter monitor to increase the threshold and then reset the threshold at a specified point.

  For example, to track the overall number of hits on a server and to be notified each time 100 additional hits have accumulated, use a counter monitor that observes the ServerRuntimeMBean OpenSocketsCurrentCount attribute.

  See javax.management.monitor.CounterMonitor in the Java SE 17 API Specification (see https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/monitor/CounterMonitor.html), which implements CounterMonitorMBean.

All monitor MBeans emit notifications of type javax.management.monitor.MonitorNotification. When a monitor MBean generates a notification, it describes the event that generated the notification by writing a specific value into the notification's Type property. Table 7-4 describes the value of the Type property that the different types of monitor MBeans encode. A filter or listener can use the notification's getType() method to retrieve the String in the Type property.

• Errors and the MonitorNotification Type Property
  

1. Initialize a connection to the Domain Runtime MBean Server.

   See Make Remote Connections to an MBean Server.

2. Create an ObjectName for your monitor MBean instance.

   See javax.management.ObjectName in the Java SE 17 API Specification at https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/ObjectName.html.

   Oracle recommends that your object name starts with the name of your organization and includes key properties that clearly identifies the purpose of the monitor MBean instance.

   For example, mycompany:Name=SocketMonitor,Type=CounterMonitor

3. Create and register one of the monitor MBeans.

   Use javax.management.MBeanServerConnection.createMBean(String classname ObjectName name) method, where:

   • classname represents one of the following values:

     • javax.management.monitor.CounterMonitor

     • javax.management.monitor.GaugeMonitor

     • javax.management.monitor.StringMonitor

   • name represents the object name that you created for the monitor MBean instance.

4. Configure the monitor MBean by setting the value of its attributes.

   For guidelines on which attributes to set, see the javax.management.monitoring package in the Java SE 17 API Specification at https://docs.oracle.com/en/java/javase/17/docs/api/java.management/javax/management/monitor/package-summary.html.

5. To specify the MBean that your monitor MBean monitors (the observed MBean), invoke the monitor MBean's addObservedObject(ObjectName objectname) and addObservedAttribute(String attributename) operations where.

   • objectname is the ObjectName of the observed MBean

   • attributename is the name of the attribute in the observed MBean that you want to monitor

   A single instance of a monitor MBean can monitor multiple MBeans. Invoke the addObservedObject and addObservedAttribute operation for each MBean instance that you want to monitor.

6. Instantiate the listener object that you created in Creating a Notification Listener for a Monitor MBean.
7. Optionally instantiate and configure a filter.
8. Register the listener and optional filter with the monitor MBean. Do not register the listener with the observed MBean.

   Invoke the monitor MBean's addNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) method.

9. Start the monitor by invoking the monitor MBean's start() operation.

• Example: Registering a CounterMonitorMBean and Its Listener