La tecnologia JMX è definita da due specifiche -Java Specification Reques -strettamente collegate fra loro, sviluppate attraverso JCP -Java Comunity Process-

• JSR 3: Java Management Extensions Instrumentation and Agent Specification;

• JSR 160: Java Management Extensions Remote API .

Tali specifiche suddividono l’architettura JMX in tre livelli separati (vedi tabella):

• Instrumentation : livello delle risorse applicative;

• Agent: livello dei controllers degli oggetti del livello Instrumentation;

• Distributed services: livello che fornisce le interfacce per la gestione delle risorse attraverso il livello Agent.

Tabella 1: Architettura JMX

I primi due livelli indicati nella tabella, Instrumentation e Agent, sono definiti dalla JSR 3. Il livello di remote management, Distributed services, è definito dal JSR 160.

Fig.4 Infrastruttura JMX.

(Fonte: JMX Reference Implementation 1.2.1 della SUN).

Tale livello definisce le specifiche per gestire le risorse attraverso gli MBeans.

Gli MBeans sono oggetti che espongono le informazioni da gestire in forma di attributi e operazioni.

Questo livello definisce anche un meccanismo di notifica che permette agli MBeans di generare eventi e di propagare le notifiche ai componenti degli altri livelli.

Gli MBeans possono essere classificati in quattro tipi:

1. Standard MBean;

2. Dynamuc MBean;

3. Model MBean

4. Open MBean.
   

Un MBean deve essere una classe pubblica non astratta, con almeno uno costruttore pubblico. Un MBean deve implementare le corrispondenti interfacce MBean o l'interfaccia javax.management.DynamicMBean. Opzionalmente, un MBean può implementare l'interfaccia javax.management.NotificationBroadcaster.

Ogni MBean viene registrato nel MBeanServer attraverso un identificativo univoco. Questo identificativo e chiamato MBean Name, ed è formato dal Dominio JMX e dalle coppie chiavi/valore. Ad esemio: DomainName:key1=val1,key2=val2. La classe javax.management.ObjectName rappresenta MBean Name. Grazie al Name, un client JMX o un adaptor , può istanziare, interrogare, registrare ed invocare i metodi di un MBean.

Questo è il primo tipo di MBean ed anche il più semplice fra tutti. Ogni classe che implementa la propria interfaccia MBean è detta Standard MBean. Viene usato quando la risorsa da gestire espone sempre gli stessi attributi ed operazioni.

Per scrivere una interfaccia Standard MBean, basta rispettare una serie di regole semantiche, prima fra tutte, il nome dell’interfaccia che deve aderire al seguente pattern lessico:

<implementing_class>MBean.

Come nell’esempio visto prima, se il nome del MBean è MiaServlet, la sua management interface è MiaServletMBean.

Ogni proprietà, ad esempio numeroUtenti, deve avere i corrispettivi metodi set, per la scrittura, e get per la lettura:

• getNumeroUtenti ();

• setNumeroUtenti (int numetoUtenti).

Quando i nomi dei metodi non sono preceduti da set e get, vengono intesi come azioni per la gestione delle proprietà del MBean.

Per gli attributi boolean, il metodo get può essere sostituito con “is<AttributeName>()”:

public boolean is<AttributeName()>;

Illustriamo un MBean di esempio. Il classico “Hello World”.

Fig. 5 Standard MBean

La corrispettiva interfaccia è :

Fig. 6 Standard MBean

A questo punto scriviamo una classe che registri il nostro MBean all’interno del MBeanServer:

Fig. 7 Standard MBean

Nel metodo main della classe Agent si è fatta una istanza del MBeanServer:

MBeanServer server =MBeanServerFactory.createMBeanServer();

Nel metodo run(), una volta ricavata dalla lista il server, si passa alla registrazione del MBean di esempio all’interno di esso:

server.registerMBean(new HelloWorld(), name);

Con questo associamo al nostro MBean un Name, l’identificativo per l’invocazione sia in  locale che in remoto del MBean.

A questo punto settiamo il valore del messaggio, impostandone l’attributo:

//impostazione dell'attributo Message

server.setAttribute(name, new Attribute("Message", "Hello World!! "));

ed effettuiamo la stampa del messaggio attraverso l’invocazione dell’operation “printMessage”:

// Invocazione dell'operation printMessage
Object result = server.invoke(
name, // MBean name
"printMessage", // operation name
null, // no parameters
null // void signature
);

In questo modo visualizziamo sulla console quanto segue:

Hello World!!

Infine registriamo l’adaptor HTTP implementato dalla SUN nel MBeanServer

//adaptor HTTP
HtmlAdaptorServer adaptor = new HtmlAdaptorServer();
//registrazione dell'adaptor HTTP
server.registerMBean(adaptor, new ObjectName("adaptor:protocol=HTML"));
adaptor.setPort(8084);//impostazione della porta
adaptor.start();

Grazie a questo adaptor è possibile gestire gli MBeans via HTTP, infatti basti aprire un browser web ed andare al seguente indirizzo : http://localhost:8084 per visualizzare questo contenuto:

Fig. 8 Standard MBean

Per eseguire correttamente l’esempio bisogna aggiungere al classpath due jars:

• jmxri.jar;

• jmxtools.jar;

appartenenti alla JMX Reference Implementation 1.2.1 della SUN, acquisibili al seguente url:

http://java.sun.com/products/JavaManagement/download.html

In questo articolo introduttivo ho voluto dare una panoramica generale dell’architettura JMX implementando uno Standard MBean d’esempio.

A coloro che desiderassero approfondire questo argomento consiglio la lettera del testo “Jmx: Managing J2ee Applications with Java Management Extensions” di Marc Fleury, Juha Lindfors e JBoss Group; Ed.SAMS.

• JMX Reference Implementation 1.2.1 SUN: http://java.sun.com/products/JavaManagement/download.html

• http://www.xmojo.org

• “Jmx: Managing J2ee Applications with Java Management Extensions” di Marc Fleury, Juha Lindfors e JBoss Group; Ed.SAMS.