Chapter 24 – Java Management Extensions (JMX)

2001 Prentice Hall, Inc. All rights reserved.

Chapter 24 – Java Management Extensions (JMX)

Outline24.1 Introduction24.2 Installation24.3 Case Study

24.3.1 Instrument Resources24.3.2 Implement the JMX Management

Agent24.3.3 Broadcasting and Receiving

Notifications24.3.4 Management Application24.3.5 Compiling and Running the

example24.4 Internet and World Wide Web Resources


24.1 Introduction

• Network management problems• Current network management solutions

– agents

• Recent technological advances• JMX

– Three-level management architecture• Instrumentation level• Agent level• Management level


24.1 Introduction

• JMX provides– Platform-independence– Protocol-independence– Reusable– Intelligent agent– Scalability


24.1 Introduction

Management Application

Java Dynamic Management Agent

Managed ResourceManaged Resource Managed ResourceInstrumentation Level

Agent Level

Manager Level


24.2 Installation

• Implementation of JMX– Java Dynamic Management Kit (JDMK)

• Download JDMK– www.sun.com/software/java-dynamic/try.html

• Set CLASSPATH– jdmkrt.jar and jdmktk.jar


24.3 Case Study

• Management solution– Resource– Agent– Application

• MBean• MBean server


24.3 Case Study

Printer MBean

RmiConnectorClient: 5555

RmiConnectorServer: 5555

MBeanServer

PrinterEventBroadcaster MBean

PrinterSimulator

Management Application


24.3.1 Instrument Resources

• Instrument a resource– Standard MBean

• MBean interface• MBean class

• MBean interface design pattern– Naming– Expose attributes of a management interface– Methods– Operations– Serializable


24.3.1 Instrument Resources

• MBean class design pattern– Implement MBean interface– Public and concrete– Public constructor

2001 Prentice Hall, Inc.All rights reserved.

Outline

InterfacePrinterMBean

1. Declarations

1 // Fig. 22.3: PrinterMBean.java2 // This class specifies the interface that will be implemented3 // by Printer, which will function as an MBean.4 5 // deitel package6 package com.deitel.advjhtp1.jmx.PrinterSimulator;7 8 public interface PrinterMBean {9 10 // is it printing?11 public Boolean isPrinting();12 13 // is it online?14 public Boolean isOnline();15 16 // is paper jammed?17 public Boolean isPaperJam();18 19 // returns paper amount in tray20 public Integer getPaperTray();21 22 // returns ink level in toner cartridge23 public Integer getToner();24 25 // returns ID of print job that is currently printing26 public String getCurrentPrintJob();27 28 // returns array of all queued up print jobs29 public String [] getPendingPrintJobs(); 30 31 // sets availability status of printer32 public void setOnline ( Boolean online );33

Management interface

Interface name with MBean suffix

Return value is serializable

is, get, set methods


Outline

InterfacePrinterEventListener

34 // fills up paper tray again with paper35 public void replenishPaperTray();36 37 // cancel pending print jobs38 public void cancelPendingPrintJobs();39 40 // start printing process41 public void startPrinting();42 }

1 // Fig. 22.4: PrinterEventListener.java2 // The listener interface for printer events.3 4 // Deitel package5 package com.deitel.advjhtp1.jmx.Printer;6 7 public interface PrinterEventListener {8 9 public void outOfPaper();10 11 public void lowToner();12 13 public void paperJam();14 }

operations


Outline

ClassPrinter

1. Declarations

2. Constructor

2.1 connect to printer device

1 // Fig. 22.5: Printer.java2 // This class provides implementation for PrinterMBean3 // interface and registers a managing MBean for the Printer 4 // device, which is simulated by PrinterSimulator.java.5 6 // deitel package7 package com.deitel.advjhtp1.jmx.PrinterSimulator;8 9 // Java core package10 import java.lang.Thread;11 import java.util.ArrayList;12 13 // JMX core packages14 import javax.management.*;15 16 // Deitel packages17 import com.deitel.advjhtp1.jmx.Printer.*;18 19 public class Printer implements PrinterMBean,20 PrinterEventListener { 21 22 private PrinterSimulator printerSimulator;23 private static final int PAPER_STACK_SIZE = 50;24 private ObjectInstance eventBroadcasterInstance;25 private ObjectName eventBroadcasterName;26 private ObjectName printerName;27 private MBeanServer mBeanServer;28 29 public Printer()30 {31 // connect to the printer device32 printerSimulator = new PrinterSimulator( this ) ;33 Thread myThread = new Thread( printerSimulator ) ;34 myThread.start();35

Connect to printer device

MBean class implements responding MBean interface

Public constructor


Outline

2.2 find MBean servers

2.3 specify MBean server requirement

2.4 identify MBean server

36 // find all MBean servers in current JVM37 ArrayList arrayList = 38 MBeanServerFactory.findMBeanServer( null ); 39 40 // retrieve the MBeanServer reference41 if ( arrayList.size() == 0)42 System.out.println( "Cannot find a MBeanServer!" );43 44 else {45 46 // get the MBeanServer that has the 47 // PrinterEventBroadcaster MBean registered with it48 for ( int i = 0; i < arrayList.size(); i++ ) {49 MBeanServer foundMBeanServer = 50 ( MBeanServer )arrayList.get( i );51 52 // obtain the object name for the 53 // PrinterEventBroadcaster MBean54 try {55 String name = foundMBeanServer.getDefaultDomain()56 + ":type=" + "PrinterEventBroadcaster";57 eventBroadcasterName = new ObjectName( name );58 } 59 60 // handle exception when creating ObjectName61 catch ( MalformedObjectNameException exception ) {62 exception.printStackTrace();63 }64 65 // check whether the PrinterEventBroadcaster MBean is66 // registered with this MBeanServer67 if ( foundMBeanServer.isRegistered( 68 eventBroadcasterName ) ) {69 mBeanServer = foundMBeanServer;70 break;71 }

Find MBean servers

Specify MBean server requirement

Identify MBean server


Outline

3. Implement management solution

72 73 } // end for loop74 75 } // end if-else to get the MBeanServer reference76 77 } // end PrinterSimulator constructor78 79 // will stop the printer thread from executing 80 // once execution should stop. 81 public void stop()82 {83 printerSimulator.stop();84 }85 86 // Is it printing?87 public Boolean isPrinting()88 {89 return new Boolean( printerSimulator.isPrinting() );90 }91 92 // is online?93 public Boolean isOnline()94 {95 return printerSimulator.isOnline(); 96 }97 98 // is paper jammed?99 public Boolean isPaperJam()100 {101 return printerSimulator.isPaperJam();102 }103 104 // is paper tray empty?105 public Integer getPaperTray()106 {107 return printerSimulator.getPaperTray();108 }


Outline

3. Implement management solution

109 110 // is toner low?111 public Integer getToner()112 {113 return printerSimulator.getToner();114 }115 116 // returns ID of print job that is currently printing117 public String getCurrentPrintJob()118 {119 return printerSimulator.getCurrentPrintJob();120 }121 122 // returns array of all queued up print jobs123 public String[] getPendingPrintJobs()124 {125 return printerSimulator.getPendingPrintJobs();126 }127 128 // sets status availability of printer129 public void setOnline( Boolean online )130 {131 if ( online.booleanValue() == true ) 132 printerSimulator.setOnline();133 else 134 printerSimulator.setOffline();135 }136 137 // fills up the paper tray again with paper.138 public void replenishPaperTray()139 {140 printerSimulator.replenishPaperTray (141 Printer.PAPER_STACK_SIZE );142 }143


Outline

4. Send out-of-paper notification

4.1 specify notification

4.2 send notification

144 // cancel pending print jobs145 public void cancelPendingPrintJobs()146 {147 printerSimulator.cancelPendingPrintJobs();148 }149 150 // start the printing process151 public void startPrinting()152 {153 printerSimulator.startPrintingProcess();154 }155 156 // send out of paper event to JMX layer157 public void fireOutOfPaperEvent()158 {159 // construct parameters and signatures160 Object[] parameter = new Object[ 1 ];161 parameter[ 0 ] = new Notification( 162 "PrinterEvent.OUT_OF_PAPER", this, 0L );163 String[] signature = new String[ 1 ];164 signature[ 0 ] = "javax.management.Notification";165 166 // invoke notification167 try {168 mBeanServer.invoke( eventBroadcasterName,169 "sendNotification", parameter, signature ); 170 } 171 172 // handle exception when invoking method173 catch ( ReflectionException exception ) {174 exception.printStackTrace();175 }176

Specify notification

Send notification


Outline

5. Send low-toner notification



177 // handle exception when communicating with MBean178 catch ( MBeanException exception ) {179 exception.printStackTrace();180 } 181 182 // handle exception if MBean not found183 catch ( InstanceNotFoundException exception ) {184 exception.printStackTrace();185 } 186 187 } // end method outOfPaperEvent188 189 // send low toner event to JMX layer190 public void fireLowTonerEvent()191 {192 // construct parameters and signatures193 Object[] parameter = new Object[ 1 ];194 parameter[ 0 ] = new Notification( 195 "PrinterEvent.LOW_TONER", this, 0L );196 String[] signature = new String[ 1 ];197 signature[ 0 ] = "javax.management.Notification";198 199 // invoke notification200 try {201 mBeanServer.invoke( eventBroadcasterName,202 "sendNotification", parameter, signature ); 203 } 204 205 // handle exception when invoking method206 catch ( ReflectionException exception ) {207 exception.printStackTrace();208 }209


Send notification


Outline

6. Send paper-jam notification


210 // handle exception communicating with MBean211 catch ( MBeanException exception ) {212 exception.printStackTrace();213 }214 215 // handle exception if MBean not found216 catch ( InstanceNotFoundException exception ) {217 exception.printStackTrace();218 } 219 220 } // end method lowTonerEvent221 222 // send paper jam event to JMX layer223 public void firePaperJamEvent()224 {225 // construct parameters and signatures226 Object[] parameter = new Object[ 1 ];227 parameter[ 0 ] = new Notification( 228 "PrinterEvent.PAPER_JAM", this, 0L );229 String[] signature = new String[ 1 ];230 signature[ 0 ] = "javax.management.Notification";231 232 // invoke notification233 try {234 mBeanServer.invoke( eventBroadcasterName,235 "sendNotification", parameter, signature ); 236 } 237 238 // handle exception when invoking method239 catch( ReflectionException exception ) {240 exception.printStackTrace();241 }242


Send notification


Outline


243 // handle exception communicating with MBean244 catch( MBeanException exception ) {245 exception.printStackTrace();246 } 247 248 // handle exception if MBean not found249 catch( InstanceNotFoundException exception ) {250 exception.printStackTrace();251 } 252 253 } // end method paperJamEvent254 255 // interface implementation256 public void outOfPaper() 257 {258 // delegate call259 fireOutOfPaperEvent();260 }261 262 // interface implementation263 public void lowToner() 264 {265 // delegate call266 fireLowTonerEvent();267 }268 269 // interface implementation270 public void paperJam()271 {272 // delegate call273 firePaperJamEvent();274 }275 }

Interface implementation


Outline

ClassPrinterSimulator

1. Declarations

2. Constructor

1 // Fig. 22.6: PrinterSimulator.java2 // This class simulates a printer device on a network.3 4 // Deitel package5 package com.deitel.advjhtp1.jmx.Printer;6 7 // java core package8 import java.util.Stack;9 10 public class PrinterSimulator implements Runnable {11 12 private Stack printerStack = new Stack();13 private boolean isOnline = true;14 private boolean isPrinting = false;15 private boolean isPaperJam = false;16 17 // 50 sheets of paper in tray 18 private Integer paperInTray = new Integer( 50 ); 19 20 // 100% full of ink21 private Integer tonerCartridge = new Integer( 100 ); 22 23 private String currentPrintJob;24 private boolean isAlive = true;25 private PrinterEventListener eventListener; 26 27 // default public constructor28 public PrinterSimulator( 29 PrinterEventListener listener ) 30 {31 eventListener = listener;32 }33

Constructor takes PrinterEventListener as input


Outline

3. Simulate printer activities

34 // stops execution of thread35 public void stop() 36 {37 isAlive = false;38 }39 40 // main life-cycle of the printer. 41 // prints one job from print job stack42 // 1) if offline, it pauses and waits.43 // 2) if online, handles one print job44 public void run() 45 {46 // main loop within thread47 while ( isAlive ) {48 49 // pause if offline50 if ( !isOnline ) {51 synchronized ( this ) {52 53 // waits for printer become online54 try {55 wait();56 } 57 58 // if interrupt occurs59 catch ( InterruptedException exception ) {60 exception.printStackTrace();61 System.exit( -1 );62 }63 64 } // end synchronized65 66 } // end if67


Outline


68 // prints one job from print job stack69 startPrintingProcess();70 71 } // end while72 }73 74 public void startPrintingProcess() 75 {76 // warm up the printer, print top print job from print77 // stack and adjust paper values and toner values78 try {79 // warm up printer for incoming batch of print jobs80 Thread.sleep( 1000 * 5 );81 82 if ( ( paperInTray.intValue() > 0 ) &&83 ( tonerCartridge.intValue() > 10 ) &&84 ( !isPaperJam ) ) {85 86 // start the printing process87 currentPrintJob = getNextPrintJob();88 isPrinting = true;89 90 // 12 seconds to print a normal document91 Thread.sleep( 1000 * 12 ); 92 93 // each print job uses 10 pages94 updatePaperInTray( paperInTray.intValue() - 10 ); 95 updateToner();96 updatePaperJam();97 isPrinting = false;98 99 // make sure no references are left dangling100 currentPrintJob = null;101 }102 }

Simulate printing process


Outline


103 104 // if interrupt occurs105 catch ( InterruptedException exception ) {106 exception.printStackTrace();107 System.exit( -1 );108 }109 110 } // end method startPrintingProcess111 112 // returns current printed job113 public String getCurrentPrintJob() 114 {115 return currentPrintJob;116 }117 118 // is printer online?119 public Boolean isOnline() 120 {121 return new Boolean ( isOnline );122 }123 124 // update amount of paper in paper tray125 public synchronized void updatePaperInTray( int newValue ) 126 {127 paperInTray = new Integer ( newValue ); 128 129 // fire event if paper tray low130 if ( paperInTray.intValue() <= 0 ) {131 eventListener.outOfPaperEvent();132 }133 }134 135 // is paper jammed?136 public Boolean isPaperJam()137 {138 return new Boolean( isPaperJam );139 }

Add paper to paper tray


Outline


140 141 // cancel pending print jobs142 public void cancelPendingPrintJobs()143 {144 synchronized ( printerStack ) {145 printerStack.clear();146 }147 }148 149 // update amount of toner available in toner cartridge150 public synchronized void updateToner() 151 {152 // after every print job, toner levels drop 1%153 tonerCartridge = new Integer ( 154 tonerCartridge.intValue() - 1 ); 155 156 // fire event if toner is low157 if ( tonerCartridge.intValue() <= 10 ) { 158 eventListener.lowTonerEvent();159 }160 }161 162 public synchronized void updatePaperJam()163 {164 if ( Math.random() > 0.9 ) {165 isPaperJam = true;166 eventListener.paperJamEvent();167 }168 }169 170 // returns number of pages in paper tray171 public synchronized Integer getPaperTray() 172 {173 return paperInTray;174 }175

Update toner in toner cartridge

Issue paper jam event randomly


Outline


176 // returns amount of toner in toner cartridge177 public synchronized Integer getToner() 178 {179 return tonerCartridge;180 }181 182 // generates a random number of print jobs with varying IDs183 public void populatePrintStack() 184 {185 int numOfJobs = ( int ) ( Math.random ( ) * 10 ) + 1;186 187 // generate print jobs188 synchronized ( printerStack ) {189 for ( int i = 0 ; i < numOfJobs ; i++ ) {190 printerStack.add ( "PRINT_JOB_ID #" + i );191 }192 }193 }194 195 // returns next print job in stack, populating the stack 196 // if it is empty197 public String getNextPrintJob() 198 {199 if ( printerStack.isEmpty() ) {200 populatePrintStack ( );201 202 // simulates absence of print jobs 203 try {204 Thread.sleep (205 ( int ) ( Math.random() * 1000 * 10 ) );206 } 207

Generate print jobs


Outline


208 // if interrupt occurs209 catch ( InterruptedException exception ) {210 exception.printStackTrace() ;211 System.exit ( -1 ) ;212 } 213 }214 215 // Remove topmost queued resource.216 String printJob;217 218 synchronized ( printerStack ) {219 printJob = ( String ) printerStack.pop();220 } 221 222 return printJob;223 224 } // end method getNextPrintJob225 226 // returns all jobs yet to be printed227 public String[] getPendingPrintJobs() 228 {229 String[] pendingPrintJobs;230 231 // create array of pending print jobs232 synchronized ( printerStack ) {233 Object[] temp = printerStack.toArray() ;234 pendingPrintJobs = new String[ temp.length ] ;235 236 for ( int i = 0 ; i < pendingPrintJobs.length ; i++ ) {237 pendingPrintJobs [ i ] = ( String )temp[ i ];238 } 239 } 240 241 return pendingPrintJobs; 242 243 } // end method getPendingPrintJobs

Get all jobs to be printed


Outline


244 245 // sets printer status to online246 public void setOnline() 247 {248 isOnline = true;249 250 // notify all waiting states251 synchronized ( this ) {252 notifyAll() ;253 }254 }255 256 // sets printer status to offline257 public void setOffline() 258 {259 isOnline = false;260 }261 262 // replenishes amount of paper in paper tray to specified 263 // value264 public void replenishPaperTray ( int paperStack ) 265 {266 updatePaperInTray( paperStack ) ;267 }268 269 // is printer printing?270 public boolean isPrinting() 271 {272 return isPrinting;273 }274 }

When printer becomes online, notify all waiting states


24.3.2 Implementation of the JMX Management Agent

• JMX agent– MBean server– MBeans (managed resource)– Protocol adaptor or connector


Outline

ClassPrinterManagementAgent

1. main

1.1 create MBeanServer

1.2 create RMI connector server

1.3 create broadcaster MBean

1 // Fig. 22.8: PrinterManagementAgent.java2 // This application creates an MBeanServer and starts an RMI3 // connector MBean service.4 5 // deitel package6 package com.deitel.advjhtp1.jmx.PrinterManagement;7 8 // JMX core packages9 import javax.management.*;10 11 public class PrinterManagementAgent {12 13 public static void main( String[] args ) 14 {15 ObjectInstance rmiConnectorServer = null;16 ObjectInstance printer = null;17 ObjectInstance broadcaster = null;18 ObjectName objectName = null;19 20 // create an MBeanServer21 MBeanServer server = 22 MBeanServerFactory.createMBeanServer();23 24 // create an RMI connector service, a printer simulator25 // MBean and a broadcaster MBean26 try {27 28 // create an RMI connector server29 rmiConnectorServer = server.createMBean (30 "com.sun.jdmk.comm.RmiConnectorServer", null );31 32 // create a broadcaster MBean33 String name = server.getDefaultDomain() 34 + ":type=" + "PrinterEventBroadcaster";35 String className = "com.deitel.advjhtp1.jmx."36 + "PrinterSimulator.PrinterEventBroadcaster"

Create MBean server

Create RMI connector server

Create broaddcaster MBean


Outline

1.4 create printer simulator MBean

1.5 handle exceptions

37 38 objectName = new ObjectName( name );39 printer = server.createMBean( 40 className, objectName ); 41 42 // create a printer simulator MBean43 name = server.getDefaultDomain()44 + ":type=" + "Printer";45 className = "com.deitel.advjhtp1.jmx." 46 + "PrinterSimulator.Printer";47 48 objectName = new ObjectName( name );49 broadcaster = server.createMBean(50 className, objectName );51 52 } // end try53 54 // handle class not JMX-compliant MBean exception55 catch ( NotCompliantMBeanException exception ) {56 exception.printStackTrace();57 }58 59 // handle MBean constructor exception60 catch ( MBeanException exception ) {61 exception.printStackTrace();62 }63 64 // handle MBean already exists exception65 catch ( InstanceAlreadyExistsException exception ) {66 exception.printStackTrace();67 }68 69 // handle MBean constructor exception70 catch ( ReflectionException exception ) {71 exception.printStackTrace();72 }

Create printer simulator MBean


Outline

1.6 specify RMI connector server port

1.7 set RMI connector server port

1.8 start RMI connector server

73 74 // handle invalid object name exception75 catch ( MalformedObjectNameException exception) {76 exception.printStackTrace();77 }78 79 // set port number80 Object[] parameter = new Object[ 1 ];81 parameter[ 0 ] = new Integer( 5555 );82 String[] signature = new String[ 1 ];83 signature[ 0 ] = "int";84 85 // invoke method setPort on RmiConnectorServer MBean86 // start the RMI connector service87 try {88 server.invoke( 89 rmiConnectorServer.getObjectName(), "setPort",90 parameter, signature );91 server.invoke( 92 rmiConnectorServer.getObjectName(), "start" ,93 new Object[ 0 ], new String[ 0 ] );94 } 95 96 // handle exception when executing method97 catch ( ReflectionException exception ) {98 exception.printStackTrace();99 }100 101 // handle exception communicating with MBean102 catch ( MBeanException exception ) {103 exception.printStackTrace();104 }105

Specify RMI connector server port

Set RMI connector server port

Start RMI connector server


Outline

InterfacePrinterEventBroadcasterMBean

1. Declarations

106 // handle exception if MBean not found107 catch ( InstanceNotFoundException exception ) {108 exception.printStackTrace();109 } 110 111 } // end method main112 }

____________________________________________________________________

1 // Fig. 22.9: PrinterEventBroadcasterMBean.java2 // This class defines the MBean interface.3 4 // deitel package5 package com.deitel.advjhtp1.jmx.PrinterSimulator;6 7 // JMX core packages8 import javax.management.Notification;9 10 public interface PrinterEventBroadcasterMBean {11 12 public void sendNotification( Notification notification );13 }


24.3.3 Broadcasting and Receiving Notifications

• Broadcast notifications– Notification broadcaster MBean

• Receive notifications


Outline

ClassPrinterEventBroadcaster

1. Declarations1 // Fig. 22.10: PrinterEventBroadcaster.java2 // This class defines an MBean that 3 // provides events information.4 5 // deitel package6 package com.deitel.advjhtp1.jmx.PrinterSimulator;7 8 // JMX core packages9 import javax.management.MBeanNotificationInfo;10 import javax.management.NotificationBroadcasterSupport;11 12 // extends NotificationBroadcasterSupport to adopt its 13 // functionality.14 public class PrinterEventBroadcaster 15 extends NotificationBroadcasterSupport16 implements PrinterEventBroadcasterMBean {17 18 private static final String OUT_OF_PAPER = 19 "PrinterEvent.OUT_OF_PAPER";20 private static final String LOW_TONER = 21 "PrinterEvent.LOW_TONER";22 private static final String PAPER_JAM = 23 "PrinterEvent.PAPER_JAM";24


Outline

2. Implement getNotificationInfo to describe events

25 // provide information about deliverable events26 public MBeanNotificationInfo[] getNotificationInfo() 27 {28 // array containing descriptor objects29 MBeanNotificationInfo[] descriptorArray = 30 new MBeanNotificationInfo[ 1 ];31 32 // different event types33 String[] notificationTypes = new String[ 3 ];34 notificationTypes[ 0 ] = 35 PrinterEventBroadcaster.OUT_OF_PAPER;36 notificationTypes[ 1 ] = 37 PrinterEventBroadcaster.LOW_TONER;38 notificationTypes[ 2 ] =39 PrinterEventBroadcaster.PAPER_JAM;40 41 // notification class type42 String classType = "javax.management.Notification";43 44 // description of MBeanNotificationInfo45 String description =46 "Notification types for PrinterEventBroadcaster";47 48 // populate descriptor array49 descriptorArray[ 0 ] = new MBeanNotificationInfo( 50 notificationTypes, classType, description );51 52 return descriptorArray; 53 54 } // end method getNotificationInfo55 }

Implement getNotificationInfo to describe events

Event description

Specify event types


Outline

ClassPrinterEventhandler

1. Inner class NotificationListener

1 // Fig. 22.11: PrinterEventHandler.java2 // The class adds a listener to the broadcaster MBean and3 // defines the event handlers when event occurs.4 5 // deitel package6 package com.deitel.advjhtp1.jmx.Client;7 8 // JMX core packages9 import javax.management.*;10 11 // JDMK core packages12 import com.sun.jdmk.comm.RmiConnectorClient;13 import com.sun.jdmk.comm.ClientNotificationHandler;14 15 // Deitel packages16 import com.deitel.advjhtp1.jmx.Printer.*;17 18 public class PrinterEventHandler {19 20 private RmiConnectorClient rmiClient;21 private PrinterEventListener eventTarget;22 23 // notification listener annonymous inner class24 private NotificationListener notificationListener = 25 new NotificationListener() {26 public void handleNotification(27 Notification notification, Object handback ) 28 {29 // retrieve notification type30 String notificationType = notification.getType();31 32 // handle different notifications 33 if ( notificationType.equals( 34 "PrinterEvent.OUT_OF_PAPER" ) ) { 35 handleOutOfPaperEvent(); 36 return;37 }

Inner class NotificationListener


Outline

2. Constructor

2.1 set notification mode

2.2 register listener to RMI connector client

39 if ( notificationType.equals( 40 "PrinterEvent.LOW_TONER" ) ) { 41 handleLowTonerEvent(); 42 return; 43 }44 45 if ( notificationType.equals( 46 "PrinterEvent.PAPER_JAM" ) ) {47 handlePaperJamEvent();48 return; 49 }50 51 } // end method handleNotification52 53 }; // end annonymous inner class54 55 // default constructor56 public PrinterEventHandler(57 RmiConnectorClient inputRmiClient,58 ManagerSidePrinterEventListener inputEventTarget ) 59 {60 rmiClient = inputRmiClient;61 eventTarget = inputEventTarget;62 63 // set notification push mode64 rmiClient.setMode( ClientNotificationHandler.PUSH_MODE ); 65 66 // register listener67 try {68 ObjectName objectName = new ObjectName( 69 rmiClient.getDefaultDomain() 70 + ":type=" + "PrinterEventBroadcaster" );71 72 rmiClient.addNotificationListener( objectName,73 notificationListener, null, null );74 }

Set notification mode

Register listener to RMI connector client


Outline

3. Delegate printer events

75 76 // if MBean does not exist in the MBean server77 catch ( InstanceNotFoundException exception) {78 exception.printStackTrace();79 }80 81 // if the format of the object name is wrong82 catch ( MalformedObjectNameException exception ) {83 exception.printStackTrace();84 }85 86 } // end PrinterEventHandler constructor87 88 // delegate out of paper event89 private void handleOutOfPaperEvent()90 {91 eventTarget.outOfPaper();92 }93 94 // delegate low toner event95 private void handleLowTonerEvent()96 {97 eventTarget.lowToner();98 }99 100 // delegate paper jam event101 private void handlePaperJamEvent()102 {103 eventTarget.paperJam();104 }105 }

Delegate printer events


24.3.4 Management Application

• Management application for the case study– GUI for managing the printer

• ClientPrinterManagement• ManagerSidePrinterEventListener• PrinterManagementGUI


Outline

ClassClientPrinterManagement

1. Constructor

1.1 get RMI connector client

1 // Fig. 22.12: ClientPrinterManagement.java2 // This application establishes a connection to the MBeanServer3 // and creates an MBean for PrinterSimulator.4 5 // deitel package6 package com.deitel.advjhtp1.jmx.Client;7 8 // Java core packages9 import java.awt.*;10 import java.awt.event.*;11 12 // JMX core packages13 import javax.management.*;14 15 // JDMX core packages16 import com.sun.jdmk.comm.RmiConnectorClient;17 import com.sun.jdmk.comm.RmiConnectorAddress;18 19 public class ClientPrinterManagement {20 21 private RmiConnectorClient rmiClient;22 23 // instantiate client connection24 public ClientPrinterManagement() 25 {26 // create connector client instance27 rmiClient = new RmiConnectorClient();28 29 // create address instance30 RmiConnectorAddress rmiAddress = 31 new RmiConnectorAddress();32

Get RMI connector client


Outline

1.2 set RMI client port

1.3 establish connection

2. Get RmiConnectorClient reference

3. main

3.1 invoke constructor

3.2 invoke GUI

33 // specify port34 rmiAddress.setPort( 5555 );35 36 // establish connection37 rmiClient.connect( rmiAddress );38 39 } // end ClinetPrinterManagement constructor40 41 // return RmiConnectorClient reference42 public RmiConnectorClient getClient() 43 {44 return rmiClient;45 }46 47 public static void main( String[] args ) 48 {49 // instantiate client connection50 ClientPrinterManagement clientManager = 51 new ClientPrinterManagement();52 53 // get RMIConnectorClient handle54 RmiConnectorClient client = clientManager.getClient();55 56 // start GUI57 PrinterManagementGUI printerManagementGUI = 58 new PrinterManagementGUI( client ); 59 60 // display the output61 printerManagementGUI.setSize(62 new Dimension( 500, 500 ) );63 printerManagementGUI.setVisible( true );64 65 } // end method main66 }

Set RMI client port

Establish connection

Invoke GUI


Outline

ClassPrinterManagementGUI

1. Import packages

2. Inner class TextAppender

1 // Fig. 22.14: PrinterManagementGUI.java2 // This class defines the GUI for the 3 // printer management application.4 5 // deitel package6 package com.deitel.advjhtp1.jmx.Client;7 8 // Java AWT core package9 import java.awt.*;10 import java.awt.event.*;11 12 // Java standard extensions13 import javax.swing.*;14 15 // JMX core packages16 import javax.management.*;17 18 // JDMX core packages19 import com.sun.jdmk.comm.RmiConnectorClient;20 import com.sun.jdmk.comm.RmiConnectorAddress;21 22 // Deitel packages23 import com.deitel.advjhtp1.jmx.Printer.*;24 25 public class PrinterManagementGUI extends JFrame 26 implements PrinterEventListener {27 28 // TextAppender appends text to a JTextArea. This Runnable29 // object should be executed only using SwingUtilities30 // methods invokeLater or invokeAndWait as it modifies31 // a live Swing component.32 private class TextAppender implements Runnable {33 34 private String text;35 private JTextArea textArea;36

Inner class TextAppender


Outline

3. Constructor

3.1 define status panel

37 // TextAppender constructor38 public TextAppender( JTextArea area, String newText )39 {40 text = newText;41 textArea = area;42 }43 44 // display new text in JTextArea45 public void run()46 {47 // append new message48 textArea.append( text );49 50 // move caret to end of messageArea to ensure new51 // message is visible on screen52 textArea.setCaretPosition(53 textArea.getText().length() );54 }55 56 } // end TextAppender inner class57 58 private ObjectName objectName;59 private RmiConnectorClient client;60 private JTextArea printerStatusTextArea = new JTextArea();61 private JTextArea printerEventTextArea = new JTextArea();62 63 public PrinterManagementGUI( RmiConnectorClient rmiClient ) 64 {65 super( "JMX Printer Management Example" );66 67 Container container = getContentPane();68 69 // status panel70 JPanel printerStatusPanel = new JPanel();71 printerStatusPanel.setPreferredSize(72 new Dimension( 512, 200 ) );

Define status panel


Outline

3.2 define buttons panel

3.2.1 define actions for the buttons

73 JScrollPane statusScrollPane = new JScrollPane();74 statusScrollPane.setAutoscrolls( true );75 statusScrollPane.setPreferredSize(76 new Dimension( 400, 150 ) );77 statusScrollPane.getViewport().add( 78 printerStatusTextArea, null );79 printerStatusPanel.add( statusScrollPane, null );80 81 // buttons panel82 JPanel buttonPanel = new JPanel();83 buttonPanel.setPreferredSize(84 new Dimension( 512, 200 ) );85 86 // define action for Check Status button87 JButton checkStatusButton = 88 new JButton( "Check Status" );89 checkStatusButton.addActionListener(90 91 new ActionListener() {92 93 public void actionPerformed( ActionEvent event ) {94 checkStatusButtonAction( event );95 }96 }97 );98 99 // define action for Add Paper button100 JButton addPaperButton = new JButton( "Add Paper" );101 addPaperButton.addActionListener(102 new ActionListener() {103 104 public void actionPerformed(ActionEvent event) {105 addPaperButtonAction( event );106 }107 }108 );109

Define buttons panel

Define actions for the buttons


Outline

3.3 define events panel

110 // define action for Cancel Pending Print Jobs button111 JButton cancelPendingPrintJobsButton = new JButton( 112 "Cancel Pending Print Jobs" );113 cancelPendingPrintJobsButton.addActionListener(114 new ActionListener() {115 116 public void actionPerformed( ActionEvent event ) {117 cancelPendingPrintJobsButtonAction( event );118 }119 }120 );121 122 // add three buttons to the panel123 buttonPanel.add( checkStatusButton, null );124 buttonPanel.add( addPaperButton, null );125 buttonPanel.add( cancelPendingPrintJobsButton, null );126 127 // events panel128 JPanel printerEventPanel = new JPanel();129 printerEventPanel.setPreferredSize(130 new Dimension( 512, 200) );131 JScrollPane eventsScrollPane = new JScrollPane();132 eventsScrollPane.setAutoscrolls( true );133 eventsScrollPane.setPreferredSize(134 new Dimension( 400, 150 ) );135 eventsScrollPane.getViewport().add(136 printerEventTextArea, null );137 printerEventPanel.add( eventsScrollPane, null );138 139 // initialize the text 140 printerStatusTextArea.setText( "Printer Status: ---\n" );141 printerEventTextArea.setText( "Events: --- \n" );142 143 // put all the panels together144 container.add( printerStatusPanel, BorderLayout.NORTH );145 container.add( printerEventPanel, BorderLayout.SOUTH );146 container.add( buttonPanel, BorderLayout.CENTER );

Define actions for the buttons

Define events panel


Outline

3.4 start printer simulator

3.5 get PrinterEventHandler

147 148 // set RmiConnectorClient reference149 client = rmiClient;150 151 // invoke method startPrinting of the152 // PrinterSimulator MBean153 try {154 String name = client.getDefaultDomain() 155 + ":type=" + "Printer";156 objectName = new ObjectName( name );157 client.invoke( objectName, "startPrinting", 158 new Object[ 0 ], new String[ 0 ] );159 }160 161 // invalid object name162 catch ( MalformedObjectNameException exception ) {163 exception.printStackTrace();164 } 165 166 // if cannot invoke the method167 catch ( ReflectionException exception) {168 exception.printStackTrace();169 }170 171 // if invoked method throws exception172 catch ( MBeanException exception ) {173 exception.printStackTrace();174 }175 176 // if MBean is not registered with MBean server177 catch ( InstanceNotFoundException exception ) {178 exception.printStackTrace();179 }180 181 // instantiate PrinterEventNotifier182 PrinterEventHandler printerEventHandler = 183 new PrinterEventHandler( client, this );

Start printing via MBean

Get PrinterEventHandler


Outline

3.6 define actions when close window

184 185 // unregister MBean when close the window186 addWindowListener(187 new WindowAdapter() {188 public void windowClosing( WindowEvent event )189 {190 // unregister MBean 191 try {192 193 // unregister the PrinterSimulator MBean194 client.unregisterMBean( objectName );195 196 // unregister the PrinterEventBroadcaster197 // MBean198 String name = client.getDefaultDomain()199 + ":type=" + "PrinterEventBroadcaster";200 objectName = new ObjectName( name );201 client.unregisterMBean( objectName );202 }203 204 // if invalid object name205 catch ( MalformedObjectNameException exception) {206 exception.printStackTrace();207 }208 209 // if exception is caught from method preDeregister210 catch ( MBeanRegistrationException exception ) {211 exception.printStackTrace();212 }213 214 // if MBean is not registered with MBean server215 catch ( InstanceNotFoundException exception ) {216 exception.printStackTrace();217 }218

Unregister Mbeans when close window


Outline

4 display events in events panel

219 // terminate the program220 System.exit( 0 );221 222 } // end method windowClosing223 224 } // end WindowAdapter constructor225 226 ); // end addWindowListener227 228 } // end PrinterManagementGUI constructor229 230 // out of paper events231 public void outOfPaper()232 {233 SwingUtilities.invokeLater( 234 new TextAppender( printerEventTextArea,235 "\nEVENT: Out of Paper!\n" ) );236 }237 238 // toner low events239 public void lowToner() 240 {241 SwingUtilities.invokeLater( 242 new TextAppender( printerEventTextArea,243 "\nEVENT: Toner Low!\n" ) );244 }245 246 // paper jam events247 public void paperJam()248 {249 SwingUtilities.invokeLater( 250 new TextAppender( printerEventTextArea,251 "\nEVENT: Paper Jam!\n" ) );252 }

Display events


Outline

5. Add paper to printer

6. Cancel pending print jobs

253 254 // add paper to the paper tray255 public void addPaperButtonAction( ActionEvent event )256 {257 try {258 client.invoke( objectName, "replenishPaperTray", 259 new Object[ 0 ], new String[ 0 ] );260 }261 262 // if cannot invoke the method263 catch ( ReflectionException exception)264 {265 exception.printStackTrace();266 }267 268 // if invoked method throws exception269 catch ( MBeanException exception ) {270 exception.printStackTrace();271 }272 273 // if MBean is not registered with MBean server274 catch ( InstanceNotFoundException exception ) {275 exception.printStackTrace();276 }277 278 } // end method addPaperButtonAction279 280 // cancel pending print jobs281 public void cancelPendingPrintJobsButtonAction( 282 ActionEvent event )283 {284 try {285 client.invoke( objectName, "cancelPendingPrintJobs", 286 new Object[ 0 ], new String[ 0 ] );287 }

Add paper to paper try when click Add Paper button

Cancel pending print jobs when click Cancel Pending Print Jobs button


Outline

7. Check printer’s status

7.1 get printer’s status

288 289 // if cannot invoke the method290 catch ( ReflectionException exception)291 {292 exception.printStackTrace();293 }294 295 // if invoked method throws exception296 catch ( MBeanException exception ) {297 exception.printStackTrace();298 }299 300 // if MBean is not registered with MBean server301 catch ( InstanceNotFoundException exception ) {302 exception.printStackTrace();303 } 304 305 } // end method cancelPendingPrintJobsButtonAction306 307 public void checkStatusButtonAction( ActionEvent event ) 308 {309 Object onlineResponse = null;310 Object paperJamResponse = null;311 Object printingResponse = null;312 Object paperTrayResponse = null;313 Object pendingPrintJobsResponse = null;314 315 // manage printer remotely316 try {317 318 // check if the printer is on line319 onlineResponse = client.invoke( objectName,320 "isOnline", new Object[ 0 ], new String[ 0 ] );321

Check printer’s status when click Check Status button


Outline

7.2 prepare output

322 // check if the printer is paper jammed323 paperJamResponse = client.invoke( objectName,324 "isPaperJam", new Object[ 0 ], new String[ 0 ] );325 326 // check if the printing is pringint327 printingResponse = client.invoke( objectName,328 "isPrinting", new Object[ 0 ], new String[ 0 ] );329 330 // get the paper tray331 paperTrayResponse = client.invoke( objectName,332 "getPaperTray", new Object[ 0 ], new String[ 0 ] );333 334 // get pending print jobs335 pendingPrintJobsResponse = client.invoke( objectName,336 "getPendingPrintJobs" , new Object[ 0 ],337 new String[ 0 ] );338 } 339 340 // if cannot invoke the method341 catch ( ReflectionException exception ) {342 exception.printStackTrace();343 }344 345 // if invoked method throws exception346 catch ( MBeanException exception ) {347 exception.printStackTrace();348 }349 350 // if MBean is not registered with MBean server351 catch ( InstanceNotFoundException exception ) {352 exception.printStackTrace();353 }354 355 // status for the online condition356 boolean isOnline = 357 ( ( Boolean ) onlineResponse ).booleanValue();

Check printer’s status by calling methods on Printer MBean


Outline

7.2 prepare output

358 359 // display status360 if ( isOnline ) {361 SwingUtilities.invokeLater( new TextAppender(362 printerStatusTextArea, 363 "\nPrinter is ONLINE.\n" ) ); 364 }365 else {366 SwingUtilities.invokeLater( new TextAppender(367 printerStatusTextArea, 368 "\nPrinter is OFFLINE.\n" ) );369 }370 371 // status for the paper jam condition372 boolean isPaperJam =373 ( ( Boolean ) paperJamResponse ).booleanValue();374 375 // display status376 if ( isPaperJam ) {377 SwingUtilities.invokeLater( new TextAppender(378 printerStatusTextArea,379 "Paper jammed.\n" ) );380 }381 else {382 SwingUtilities.invokeLater( new TextAppender(383 printerStatusTextArea,384 "No Paper Jam.\n" ) );385 }386 387 // status for the printing condition388 boolean isPrinting = 389 ( ( Boolean )printingResponse ).booleanValue();390

Append printer status to output area


Outline

7.2 prepare output

391 // display status392 if ( isPrinting ) {393 SwingUtilities.invokeLater( new TextAppender(394 printerStatusTextArea,395 "Printer is currently printing.\n" ) );396 }397 else {398 SwingUtilities.invokeLater( new TextAppender(399 printerStatusTextArea, 400 "Printer is not printing.\n" ) );401 }402 403 // status for paper tray condition 404 int paperRemaining = 405 ( ( Integer )paperTrayResponse ).intValue();406 407 // display status408 SwingUtilities.invokeLater( new TextAppender( 409 printerStatusTextArea,410 "Printer paper tray has " + paperRemaining + 411 " pages remaining.\n" ) );412 413 // status for pending print jobs414 Object[] pendingPrintJobs = 415 ( Object[] ) pendingPrintJobsResponse;416 int pendingPrintJobsNumber = pendingPrintJobs.length;417 418 // display status419 SwingUtilities.invokeLater( new TextAppender( 420 printerStatusTextArea, 421 "Number of pending print jobs: " + 422 pendingPrintJobsNumber + "\n" ) );423 424 425 } // end method checkStatusButtonAction 426 }

Append printer status to output area


22.3.5 Compiling and Running the example

• CLASSPATH– jdmkrt.jar and jdmktk.jar

• Compile– Files in package

com.deitel.advjhtp1.jmx.PrinterManagement– Files in package com.deitel.advjhtp1.jmx.PrinterSimulator

• Run– PrinterManagementAgent– ClientPrinterManagement


Outline

Program output

Initial window


Outline

Program output

Out-of-paper event happened

Status after out-of-paper event happened


Outline

Program output

Status after clicked Add Paper button


Outline

Program output

Status after out-of-paper event happened

Out-of-paper event happened


Outline

Program output

Status after clicked Cancel Pending Print Jobs button

Documents

Chapter 24 – Java Management Extensions (JMX)