JBoss - chapitre JMX

Supervision avec JMX

antislashn.org JBoss - Supervision avec JMX 2 / 125

JMX

● JMX : Java Management eXtension● Standard pour la gestion et la supervision des

ressources● inclus de Java SE depuis la version 5● supervision des ressources matérielles et logicielles

● Standard utilisé massivement dans le monde des serveurs Java EE● JBoss est composé d'un serveur JMX dans lequel

viennent s'agréger les différents services


JMX

● Le standard impose de respecter● une architecture● une configuration de classes

– avec un système de nommage– le contrôle est effectué par des modules applicatifs appelés

MBean (Managed Bean)

● Architecture en trois couches● niveau clients : permet le contrôle● niveau agent : serveur● niveau instrumentation : les MBeans


JMX

source : Oracle


JMX

niveau clients

Services :●Timers●Notification

Connecteurs et adaptateurs

Serveur de MBean

niveau agent JMX

niveau instrumentation MBeanMBean

MBean

Client JMX


Niveau instrumentation

● Une ressource administrable doit tourner dans une JVM● application, service, périphérique

● L'instrumentation de la ressource est effectuée par les MBeans● l'écriture d'un MBean doit suivre un modèle de

conception● une ressource instrumentée par un MBean est

administrable par l'agent JMX


Niveau instrumentation

● Plusieurs types de MBeans

● Standard MBean– les fonctionnalités sont exposées statiquement par interface

● MXBean– Standard MBean possédant des contraintes sur les types

● Dynamic MBean– les fonctionnalités sont exposée dynamiquement

● Model MBean– MBean générique et configurable

● Open MBean– Dynamic MBean possédant des contraintes sur les types


Niveau agent

Serveur deMBeans

MBeanRegistry

MBeanmeta data

Client

MBean

MBean


Niveau agent

● L'agent JMX (ou serveur JMX) est composé de● du serveur de MBean

– classe MBeanServer

● de services– service de notifications : classe Notification

– service de timer : classe Timer

● des connecteurs et adaptateurs de protocoles pour dialoguer avec la couche client– connecteur : permet à un client Java de se connecter au serveur –

utilise RMI– adaptateurs de protocoles : permet au client d'utiliser d'autres

protocoles que RMI


Niveau agent

● Le serveur de MBean joue le rôle de registre d'objets● un MBean doit s'enregistrer avec un nom unique

auprès du serveur– le nom est de type ObjectName

● composé d'un domaine et de propriétés (séparateurs : et ,)

– l'enregistrement peut être effectué par● l'agent lui-même● un autre MBean● une application distante via un service distribué

jboss.deployment:flavor=URL,type=DeploymentScanner


Niveau agent

● Une fois enregistré, un certain nombres d'opérations sont disponibles sur le MBean● découverte des opérations disponibles sur le MBean● lecture et écriture des attributs● invocation des opérations du MBean● récupération des notifications émises par le MBean


Niveau agent

● Les services d'agent● sont généralement eux-mêmes des MBeans● gèrent les opération de gestion des MBeans● par défaut :

– service m-let (Management Applet)● gestion du chargement dynamique des classes

– service moniteur● gestion des notification

– service de timers● déclenchements réguliers d'action sur les MBeans

– service de mise en relation des MBeans entre eux


Niveau client

● Client du niveau agent● Ce niveau fournit une interface de supervision et

administration● Deux outils sont fournis par le JDK

● jconsole● jvisualvm

– regroupe plusieurs outils– la visualisation des MBeans nécessite le chargement d'un

plugin

● Possibilité de créer son propre client


JMX

● Le MBean suit un modèle de conception● il comporte

– des attributs en lecture / écriture● spécification des getteur/setteur

– des opérations– et éventuellement une description


Standard MBean

● Modèle de conception● spécification de nommage entre l'interface qui expose

les attributs et opération et la classe d'implémentation● la classe d'implémentation doit posséder un

constructeur par défaut● les attributs sont spécifiés par les méthodes getXxx(), setXxx() et isXxx()


Standard MBean

● Codage simple● une interface

– même nom que la classe d'implémentation suffixé par MBean

– les getteur/setteur indique sil'attribut est en lecture et/ouécriture

● une classe d'implémentation


Standard MBean : couche agent

● Le MBean est identifié dans le serveur par son nom● ou ObjectName● composé de deux parties

– le domaine– les propriétés– les deux sont séparés par le caractère :

jboss.deployment:flavor=URL,type=DeploymentScanner



● Étapes principales● récupération d'un serveur de MBeans

● création d'un ObjectName pour l'enregistrement du MBean

● enregistrement du MBean auprès du serveur

MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

ObjectName mBeanName = new ObjectName("antislashn.jmx:bean=Hello,type=standard");

HelloMBean mBean = new Hello();mbs.registerMBean(mBean, mBeanName);



● Pour exécuter le serveur de MBean, il faut activer l'accès distant à JMX● -Dcom.sun.management.jmxremote● d'autres propriétés peuvent être précisées si en mode

remote

● un modèle de fichier de mot de passe est proposé dans le répertoire lib/management du JRE

java -Dcom.sun.management.jmxremote.port=3333-Dcom.sun.management.jmxremote.ssl=false-Dcom.sun.management.jmxremote.authenticate=falseMonAppliJava


Standard MBean : supervision

● Des utilitaires de supervisions sont livrés avec le JDK● jconsole● jvisualvm

– qui intègre les utilitaire jconsole, jstat , jinfo, jmap


Standard MBean : supervision

● Exemple de copie d'écran avec jvisualvm


StandardMBean : codage d'un client

● Pour que le client se connecte au serveur de MBean, il faut que celui ci soit lancé avec les arguments suivants

-Dcom.sun.management.jmxremote-Dcom.sun.management.jmxremote.port=3333-Dcom.sun.management.jmxremote.authenticate=false-Dcom.sun.management.jmxremote.ssl=false


StandardMBean : codage d'un client

● Les étapes de codage

● créer une URL

● récupérer un connecteur

● récupérer une connexion

● récupérer un proxy vers le MBean

JMXServiceURL serviceURL = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://:3333/jmxrmi");JMXConnector jmxConnector = JMXConnectorFactory.connect(serviceURL);MBeanServerConnection serverConnection = jmxConnector.getMBeanServerConnection();

ObjectName objectName = new ObjectName("antislashn.jmx:bean=Hello,type=standard");HelloMBean mBean = JMX.newMBeanProxy(serverConnection, objectName, HelloMBean.class);System.out.println(">>> "+mBean.getName());

le client connaît la classe du MBean

port passé en argument à la JVM du server


Dynamic MBean

● Implémente l'interface DynamicMBean● la lecture des attributs et opérations disponibles ne se

fait plus par introspection– utilisation des méthodes redéfinies

● bien que plus complexe à coder, ce type de bean est plus puissant– exposition des attributs et opérations à l'exécution

● pour le Standard MBean l'exposition est effectuée à la compilation

– pas d'import de classes spécifique côté client


Dynamic MBean

● Les méthodes de DynamicMean permettent● de découvrir les attributs et opérations du MBean

– getMBeanInfo()

● de retrouver la valeur d'un attribut, ou d'une liste d'attributs– Object getAtribute(String attribute)– AttributeList getAttributes(String[] attributes)

● mettre à jour la valeur d'un attribut, ou d'une liste d'attributs– void setAttribute(Attribute attribute)

– AttributeList setAttributes(AttributeList attributes)

● d'invoquer une opération– Object invoke(String action,Object[] params, Object[] types)


Dynamic MBean● Méta-classes de description

● MBeanInfo : une instance par Dynamic MBean– conteneur de méta données

● MBeanAttributeInfo : une instance par attribut

● MBeanParameterInfo : une instance par paramètre

● MBeanConstructorInfo : une instance par constructeur– contient un ou plusieurs MBeanParameterInfo

● MBeanOperationInfo : une instance par opération– contient un ou plusieurs MBeanParameterInfo

● MBeanNotificationInfo : une instance par groupe de notifications


Dynamic MBean

● MBeanAttributeInfo● description d'un attribut

– name : nom de l'attribut tel qu'il apparaît dans l'interface de gestion

– type : classe de l'attribut sous forme d'un String● Integer.TYPE.getName() ou Hello.class.getName() par exemple

– description : description de l'attribut

– isReadable : indicateur de lecture

– isWritable : indicateur d'écriture

– isis : indicateur d'attribut de type booléen● l'accesseur débute alors par is au lieu de get


Dynamic MBean

● MBeanParameterInfo● description d'un paramètre de constructeur ou

d'opération– name : nom du paramètre tel qu'il apparaît dans l'interface

de gestion– type : classe du paramètre sous forme d'un String

– description : description du paramètre


Dynamic MBean

● MBeanConstructorInfo● description d'un constructeur

– name : nom du constructeur tel qu'il apparaît dans l'interface de gestion


– signature : tableau de MBeanParameterInfo correspondant à la signature du constructeur


Dynamic MBean

● MBeanOperationInfo● description d'une opération

– name : nom de l'opération telle qu'elle apparaît dans l'interface de gestion


– signature : tableau de MBeanParameterInfo correspondant à la signature du constructeur

– type : type du retour

– impact : indicateur d'impact sur l'état du bean


Dynamic MBean

● MBeanOperationInfo● valeurs possibles pour la propriété impact

– INFO : état du MBean inchangé, l'opération retourne une information

– ACTION : l'état du MBean a changé

– ACTION_INFO : l'état du MBean a changé, et l'opération retourne une information

– UNKNOW : l'impact de l'opération sur l'état du MBean est inconnu


Dynamic MBean

● MBeanNotificationInfo● description d'une notification

– name : nom de la notification telle qu'elle apparaît dans l'interface de gestion


– notifsType : types des notifications qui sont émises par le MBean sous forme d'un tableau de String

● un type de notification est du type :vendor[.application][.component][.eventGroup].event


Dynamic MBean

● MBeanInfo● description d'un MBean

– className : nom de la classe du MBean (String)


– attributes : tableau des MBeanAttributeInfo

– constructors : tableau des MBeanConstructorInfo

– operations : tableau des MBeanOperationInfo

– notifications : tableau des MBeanNotificationInfo


Dynamic MBean

● Codage du MBean● l'exemple reprends

du Standard MBean Hello

public interface HelloMBean {// attributsString getName();String getColor();void setColor(String

color);

// opérationsvoid sayHello();double add(double a, double

b);}

public class Hello implements HelloMBean {private String name ="Toto MBean";private String color = "vert";

@Overridepublic String getName() {

return name;}

@Overridepublic String getColor() {return color;

}

@Overridepublic void setColor(String color) {

this.color = color;}

@Overridepublic void sayHello() {

System.out.println(">>> Standard MBean "+name+" - "+color);}

@Overridepublic double add(double a, double b) {

return a+b;}

}


Dynamic MBean - codage

● Déclaration des attributs● constructeur de la classe MBeanAttributeInfo :

● code (extrait)MBeanAttributeInfo[] attributeInfos = new MBeanAttributeInfo[2];

attributeInfos[0] = new MBeanAttributeInfo("Name",String.class.getName(),"Nom du MBean",false,true,false);

attributeInfos[1] = new MBeanAttributeInfo("Color", String.class.getName(), "Couleur du MBean", true, true, false);

MBeanAttributeInfo(String name, String type, String description, boolean isReadable, boolean isWritable, boolean isIs)



● Déclaration des opérations● constructeur de la classe MBeanOperationInfo :

● code (extrait)MBeanOperationInfo[] operationInfos = new MBeanOperationInfo[5];

MBeanParameterInfo[] parameterInfos = new MBeanParameterInfo[2];parameterInfos[0] = new MBeanParameterInfo("a", Double.TYPE.getName(), "Paramètre a");parameterInfos[1] = new MBeanParameterInfo("a", Double.TYPE.getName(), "Paramètre a");

operationInfos[0] = new MBeanOperationInfo("add", "addition de deux double", parameterInfos,Double.TYPE.getName(), MBeanOperationInfo.UNKNOWN);

MBeanOperationInfo(String name, Method method)



● Méthode getAttribute(...)

public Object getAttribute(String attributeName) throws AttributeNotFoundException, MBeanException, ReflectionException {

if(attributeName.equals("Color")){return this.color;

}else if(attributeName.equals("Name")){

return this.name;}else

throw new AttributeNotFoundException("Can't find "+attributeName);}



● Méthode getAttributes(...)● retour de type AttributeList

– étend ArrayList, mais sans généricité sur Attribute

– contient des instances de type Attribute● encapsule les nom et valeur d'un attribut

public AttributeList getAttributes(String[] attributeNames) {AttributeList list = new AttributeList();for(String name : attributeNames){

try {Object value = this.getAttribute(name);list.add(new Attribute(name, value));

} catch (AttributeNotFoundException | MBeanException | ReflectionException e) {e.printStackTrace();

}}return list;

}



● Méthode setAttribute(...)

public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException,

MBeanException, ReflectionException {String name = attribute.getName();Object value = attribute.getValue();if(name.equals("Color") && (value instanceof String)){

this.setColor((String) value);} else {

new AttributeNotFoundException("Attribut "+name+" inconnu ou en lecture seule");}

}



● Méthode setAttributes(...)

public AttributeList setAttributes(AttributeList attributes) {AttributeList list = new AttributeList();for(int i=0 ; i<attributes.size() ; i++){

try{Attribute attribute = (Attribute) attributes.get(i);this.setAttribute(attribute);String name = attribute.getName();Object value = attribute.getValue();list.add(new Attribute(name, value));

} catch(Exception e){e.printStackTrace();

}}return list;

}



● Méthode invoke(...)● est invoquée pour chaque opération

– pas pour les accesseurs/mutateurs des attributs● il faut vérifier que le nom de la méthode et la signature

soient adéquats– sinon il faut lever une ReflectionException

● il faut aussi vérifier le tableau des paramètres– les types des paramètres correspondent-ils à la signature



● Méthode invoke(...)public Object invoke(String operationName, Object[] params, String[] signature)

throws MBeanException, ReflectionException {Object retour = null;if(operationName.equals("sayHello")){

this.sayHello();retour = Void.TYPE;

}else if(operationName.equals("add")){

if(signature[0].equals(Double.TYPE.getName()) && signature[1].equals(Double.TYPE.getName())){

if(params[0] instanceof Double && params[1] instanceof Double){double a = ((Double)params[0]).doubleValue();double b = ((Double)params[1]).doubleValue();retour = new Double(a+b);

}}

} elsenew ReflectionException(new NoSuchMethodException("Unknow operation : "+operationName));

return retour;}


Dynamic MBean

● Plus complexe à coder, mais...● les opérations et attributs peuvent évoluer durant le

cycle de vie du bean– les méthodes de description du MBean sont appelées tout

au long de l'utilisation du MBean– pour un Standard MBean, l'exposition des attributs et des

méthodes passe par une interface


Dynamic MBean : codage d'un client

● Étapes de codage● construction de l'URL● récupération d'un connecteur● récupération d'une connexion au serveur JMX● utilisation de la connexion au serveur pour

– récupérer les méta-données du MBean– utiliser les attributs– invoquer les opérations


Dynamic MBean : coadeg d'un client

● Exemple de codeJMXServiceURL serviceURL = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://:3333/jmxrmi");JMXConnector jmxConnector = JMXConnectorFactory.connect(serviceURL);MBeanServerConnection serverConnection = jmxConnector.getMBeanServerConnection();

ObjectName objectName = new ObjectName("antislashn.jmx:bean=Hello,type=dynamic");

MBeanInfo beanInfo = serverConnection.getMBeanInfo(objectName);MBeanAttributeInfo[] attributeInfos = beanInfo.getAttributes();MBeanOperationInfo[] operationInfos = beanInfo.getOperations();

for(MBeanAttributeInfo att : attributeInfos){System.out.println(">>> Attribut : "+att.getName()+" == "+

serverConnection.getAttribute(objectName, att.getName()));}

for(MBeanOperationInfo op : operationInfos){System.out.println(">>> Opération : "+op.getName());if(op.getName().equals("sayHello"))

System.out.println("=> sayHello() returns "+serverConnection.invoke(objectName, op.getName(),

new Object[0], new String[0]));}

le client ne connaît pas la classe du MBean


Model MBean

● Type de MBean dynamique● n'implémente aucune interface

● Le MBean n'a pas besoin de détenir une référence vers la ressource à gérer

● Utilise la classe RequiredModelBean pour associer une description de MBean à la ressource à superviser


Model MBean

● Pour résoudre l'interface du Model MBean, on utilise une classe de méta-données● Descriptor

– interface implémentée par DescriptionSupport

– collection de paires nom/valeur (String/Object)● une paire représente un attribut, un constructeur, une opération ou

une notification● il y a un descripteur par type de champ● le descripteur décrit complètement le champ par la paire nom/valeur

– les noms utilisés sont liés à la spécification


Model MBean

● Interface Descriptor● permet la résolution des champs

– les noms de champs sont spécifiés par JMX– des noms personnalisés peuevent être ajoutés

● méthodes– Object getFieldValue(String fieldName)

– void setField(String fieldName, Object fieldValue)

– String[] getFields()

– String[] getFieldNames()

– void removeField(String fieldName)

– void setFields(String[] fieldNames,Object[] fieldValues)


Model MBean

● Champs utilisés par la spécification

● name (obligatoire) : nom utilisé par le champ

● descriptorType (obligatoire) : description du type de champ, valeurs possibles– MBean, attribute, operation, notification

● displayName : nom utilisé pour l'affichage dans le client

● getMethod : nom du getteur si le type est un attribut– doit être déclaré dans les opérations

● setMethod : nom du setteur si le type est un attribut– doit être déclaré dans les opérations


Model MBean

● Champs utilisés par la spécification● currencyTimeLimit : utilisé sur les attributs

(getteur) et retour d'opérations pour estimer sa validité– une marque lastUpdateTimeStamp est déposée sur

chaque valeur retournée– unité : ms

● log : sur les notification, indicateur booléen

● logFile : obligatoire si log est utilisé, contient le chemin d'un fichier de log


Model MBean

● Champs utilisés par la spécification● default : valeur par défaut d'un attribut

– utilise le setteur

● export : indicateur booléen utilisé pour la distribution du MBean dans un environnement distribué

● role: utilisé sur les opération, sa valeur peut être– operation, constructor, getter, setter

● persistPeriod : période de persistance en s, si une persitPolicy a été déclarée avec la valeur NoMoreOftenThan ou OnTimer


Model MBean

● Champs utilisés par la spécification● persistPolicy : stratégie de persistance, valeurs

possibles– Never, OnTimer, OnUpdate, NoMoreOftenThan

● severity : degrès de sévérité d'une notification– 0 : indéterminé– et de 1 (NonRecoverable) à 6 (informative)

● value : utilisé comme cache sur les valeur d'attribut en conjonction avec le champ currencyTimeLimit


Model MBean

● Codage d'un descripteur

● Le descripteur peut être une chaîne XML

● Peut aussi être un tableau de String, String + Object

Descriptor attrDescriptor = new DescriptorSupport();attrDescriptor.setField("name", "Name");attrDescriptor.setField("descriptorType", "attribute");attrDescriptor.setField("displayName", "Nom du Model MBean");attrDescriptor.setField("getMethod", "getName");

<descriptor><field name="name" value="Name" /><field name="descriptorType" value="attribute"/><field name="displayName" value="Nom du Model MBean"/><field name="getMethod" value="getName"/></descriptor>

Descriptor attrDescriptor = new DescriptorSupport(descriptorXML) ;


Model MBean

● Description de l'interface du MBean● comme pour le Dynamic MBean il y a un ensemble de

classes pour les méta-données– ModelMBeanAttributeInfo : une instance par attribut

– ModelMBeanConstructorInfo : une instance par constructeur

– ModelMBeanOperationInfo : une instance par opération

– ModelMBeanNotificationInfo : une instance par groupe de notifications

– ModelMBeanInfoSupport : une instance pour le MBean● conteneur des méta-données


Model MBean

● Constructeurs des classes méta-données● sauf pour ModelMBeanInfo● plusieurs constructeurs

– cf. documentation– certains ne prennent pas d'instance de Descriptor

● il y a alors création d'une instance de Descriptor par défaut, avec les champs nécessaires

– l'utilisation d'un Descriptor permet d'ajouter les champs non prévus par les constructeurs


Model MBean

● Méta-données pour les attributsattributeInfos = new ModelMBeanAttributeInfo[2];Descriptor nameDescriptor = new DescriptorSupport();nameDescriptor.setField("name", "Name");nameDescriptor.setField("descriptorType", "attribute");nameDescriptor.setField("displayName", "Nom du ModelMBean Hello");nameDescriptor.setField("getMethod", "getName");

Descriptor colorDescriptor = new DescriptorSupport();colorDescriptor.setField("name", "Color");colorDescriptor.setField("descriptorType", "attribute");colorDescriptor.setField("displayName", "Couleur ModelMBean Hello");colorDescriptor.setField("currencyTimeLimit", -1);colorDescriptor.setField("getMethod", "getColor");colorDescriptor.setField("setMethod", "setColor");

attributeInfos[0] = new ModelMBeanAttributeInfo("Name", String.class.getName(),"Nom du Model MBean", true, false,false, nameDescriptor);

attributeInfos[1] = new ModelMBeanAttributeInfo("Color",String.class.getName(),"Couleur du Model MBean", true,true,false,colorDescriptor);


Model MBean

● Méta-données pour les opérationsoperationInfos = new ModelMBeanOperationInfo[5];MBeanParameterInfo a = new MBeanParameterInfo("a", Integer.TYPE.getName(),

"Premier paramètre de l'addition");MBeanParameterInfo b = new MBeanParameterInfo("b", Integer.TYPE.getName(),

"Second paramètre de l'addition");MBeanParameterInfo color = new MBeanParameterInfo("colorr", String.class.getName(),

"Couleur du bean");operationInfos[0] = new ModelMBeanOperationInfo("add","Addition entre deux entiers",

new MBeanParameterInfo[]{a,b},Integer.TYPE.getName(),ModelMBeanOperationInfo.INFO);

operationInfos[1] = new ModelMBeanOperationInfo("sayHello","Juste un Hello, world",null,Void.TYPE.getName(),ModelMBeanOperationInfo.INFO);

operationInfos[2] = new ModelMBeanOperationInfo("getName","getName()",null,String.class.getName(),ModelMBeanOperationInfo.INFO);

operationInfos[3] = new ModelMBeanOperationInfo("getColor","getColor()",null,String.class.getName(),ModelMBeanOperationInfo.INFO);

operationInfos[4] = new ModelMBeanOperationInfo("setColor","setColor()",new MBeanParameterInfo[]{color},Void.TYPE.getName(),ModelMBeanOperationInfo.INFO);


Model MBean

● Méta-données pour le Model MBean

● Association avec la ressource

mBeanInfo = new ModelMBeanInfoSupport("ModelMBeanHello", "Exemple de Model MBean", attributeInfos, null, operationInfos, null);

MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

ObjectName mBeanName = new ObjectName("antislashn.jmx:bean=Hello,type=model");ModelMBeanHelloFactory factory = new ModelMBeanHelloFactory();

Hello hello = new Hello();

RequiredModelMBean mBean = new RequiredModelMBean(factory.getModelMBeanInfo());mBean.setManagedResource(hello,"objectReference");mbs.registerMBean(mBean, mBeanName);


Model MBean

● Exemple de construction des méta-données● extrait

Descriptor attrDescriptor = new DescriptorSupport();attrDescriptor.setField("name", "Name");attrDescriptor.setField("descriptorType", "attribute");attrDescriptor.setField("displayName", "Nom du Model MBean");attrDescriptor.setField("getMethod", "getName");

attributeInfos[0] = new ModelMBeanAttributeInfo("Name", String.class.getName(),"Nom du Model MBean",true, false,false, attrDescriptor);

attributeInfos[1] = new ModelMBeanAttributeInfo("Color",String.class.getName(),"Couleur du Model MBean",true,true,false);

mBeanInfo = new ModelMBeanInfoSupport("ModelMBeanHello", "Exemple de Model MBean", attributeInfos, null, operationInfos, null);

ModelMBeanAttributeInfo(String name, String type, String description, boolean isReadable, boolean isWritable, boolean isIs,Descriptor descriptor)


Model MBean

● Récupération du Descriptor● auprès des classes de méta-données● méthode Descriptor getDescriptor()● il est ainsi possible de gérer le descripteur

– lister les champs– ajouter des champs– ...


Model MBean

● Mise en relation de la ressource à gérer avec la description du MBean

ObjectName mBeanName = new ObjectName("antislashn.jmx:bean=Hello,type=model");

ModelMBeanHelloFactory factory = new ModelMBeanHelloFactory();Hello hello = new Hello();RequiredModelMBean mBean = new RequiredModelMBean(factory.getModelMBeanInfo());mBean.setManagedResource(hello,"ObjectReference");mbs.registerMBean(mBean, mBeanName);

classe utilitaire construisant les descripteurs

association du descripteur et de la ressource


Model MBean

● Association entre la ressource et le descripteur de MBean● type de référence

– ObjectReference : seul supporté par défaut dans le JDK– Handle– IOR– EJBHandle– RMIReference


Model MBean

● Résumé des étapes d'instrumentation d'une ressource● instancier la ressource à gérer● instancier la classe RequiredModelBean● créer les classes de méta-données nécessaires● créer la méta-donnée pour la ressource

– ModelMBeanInfo

● ajouter à l'instance de RequiredModelBean la méta-donnée de type ModelMBeanInfo

● associer la ressource


MBean - comparaison

typede

MBean

connaissancedu MBean par

le client

complexitéde

codage

utilisation des

Open Type

Standard MBean oui simple non

Dynamic MBean non tout doit être codé non

Model MBean non implémentation par défaut fournie non

MXBean oui simple oui

Open MBean non complexe oui

● Les Model MBean et Dynamic MBean sont mis en relation avec la ressource à surveiller● ils ne possèdent pas de référence vers cette ressource● ils n'encapsulent pas cette ressource


Notification d'événements

● Le changement d'état d'une ressource peut-être notifiée● par programmation● par utilisation du service de monitoring

● La notification est une information envoyée par un émetteur vers un listener via l'infrastructure JMX● contient au minimum

– le type de la notification – String● du type vendor[.application][.component][.eventGroup].event

– une référence vers l'émetteur– un numéro de séquence qui identifie l'occurrence de la notification



● Classes et interfaces principales● classe Notification : représente une notification

– envoyée par un émetteur (broadcaster) vers un récepteur (listener)

● interface NotificationFilter : permet au listener de ne recevoir qu'une partie des notifications– implémentée par NotificationFilterSupport

● interface NotificationBroadcaster : implémentée par tous les émetteurs– implémentée par NotificationBroadcastSupport

● interface NotificationListener : implémentée par les récepteurs de notification



● Un émetteur :● implémente l'interface NotificationBroadcaster

– ou étend NotificationBroadcasterSupport

● fournir à l'infrastructure JMX les notifications susceptibles d'être émises– méthode MBeanNotificationInfo[] getNotificationInfo()

● Un récepteur étends l'interface NotificationListener

● le listener peut recevoir un sous-ensemble des notifications en fournissant une filtre– le filtre implémente NotificationFilter


Notification d'événements - exemple

● Une classe Compteur fait évoluer régulièrement une valeur interne● une notification sera émise à chaque changement de

cette valeur

● La classe Compteur● implémente CompteurMBean● étend NotificationBroadcastSupport

– redéfinition de la méthode getNotificationInfo()

● maintient un numéro de séquence de notification● envoie une notification sur sa méthode setValue(...)



● Redéfinition de la méthode getNotificationInfo()

...@Overridepublic MBeanNotificationInfo[] getNotificationInfo(){

MBeanNotificationInfo[] infos = new MBeanNotificationInfo[1];

String[] types = new String[]{"antislashn.compteur.value"};String name = AttributeChangeNotification.class.getName();String description = "Un attribut de Compteur a changé";

MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description);

infos[0] = info;return infos;

}...



● Envoi de la notification● la notification comporte au moins

– le type de notification – String– une référence vers l'émetteur de la notification– le numéro de séquence

● plusieurs constructeurs permettent d'ajouter– un horodatage– un message– une référence vers un Object

● permet le passage d’informations supplémentaires entre l'émetteur et le récepteur – méthode setUserData(Object userData)



● Envoi de la notification

● Nota : la classe AttributeChangeNotification aurait pu être utilisée

● permet d'ajouter des informations sur la valeur de l'attribut

– ancienne valeur et nouvelle valeur

Notification notification = new Notification("antislashn.compteur.value", this, sequenceNumber++);

sendNotification(notification);



● Pour suivre les notification dans jconsole ou jvisualvm, il faut d'abord souscrire



● Et de voir les changements



● L'implémentation de NotificationListener permet de suivre les notifications avec son propre client● le client doit auparavant se connecter sur notre

serveur JMX– via un adaptateur RMI

● l'url comporte le port d'écoute du serveur– argument com.sun.management.jmxremote.port




● Le client doit ensuite retrouver le MBean pour s'enregistrer en tant que listener

ObjectName objectName = new ObjectName("antislashn.jmx:type=Compteur,subtype=Notification");CompteurMBean compteurMBean = JMX.newMBeanProxy(serverConnection, objectName,

CompteurMBean.class, true);serverConnection.addNotificationListener(objectName, new CompteurListener(), null, null);

le MBean peut envoyerdes notifications

pas de filtre

pas d'objet handback



● Le listener n'a qu'une méthode à implémenter● handleNotification()

– premier paramètre : la notification– seconde paramètre : l'objet handback

class CompteurListener implements NotificationListener{@Overridepublic void handleNotification(Notification notification, Object handback) {

System.out.println(">>> Notification "+notification.getSource());}

}

renvoie l'OjectName du MBeanc



● Utilisation d'une donnée utilisateur● les ancienne et nouvelle valeurs du compteur sont

encapsulées dans une classe

public class UserData implements Serializable{private int oldValue;private int newValue;

public UserData(int oldValue, int newValue) {this.oldValue = oldValue;this.newValue = newValue;

}

public int getOldValue() {return oldValue;

}public int getNewValue() {

return newValue;}

}



● Utilisation d'une donnée utilisateur● mise en place de la donnée utilisateur côté MBean●

●

●

● récupération dans le listener (côté client)

private void sendNotification() {Notification notification = new Notification("antislashn.compteur.value",

this, sequenceNumber++);UserData userData = new UserData(value-1, value);notification.setUserData(userData);sendNotification(notification);

}


System.out.println(">>> Notification "+notification.getSource());if(notification.getUserData()!=null){

UserData userData = (UserData) notification.getUserData();System.out.println("\t oldValue == "+userData.getOldValue()+

" - newValue == "+userData.getNewValue());}

}}



● Utilisation de l'objet de retour● objet créé par le listener● passé à l'émetteur de notification via la méthode addNotificationListener()

● retourné à la méthode handleNotification() du listener

● Permet de créer des contextes propres aux listeners



● Mise en place du handback● lors de l'ajout du listener● l'objet peut-être évidemment de tout type

● Récupération du handback

String typeLog = "email";serverConnection.addNotificationListener(objectName, new CompteurListener(), null, typeLog);


String typeLog = (String) handback;if(typeLog.equals("console")){

System.out.println(">>> Notification sur la console "+notification.getSource());}else if(typeLog.equals("email")){

sendEmail();}

}}


Notification d'événements - exemple● Filtrer les notifications

● par implémentation de NotificationFilter– encapsule la liste des types de notifications permis

– définit la méthode isNotificationEnabled() qui renvoie un booléen indiquant la prise en charge ou non de l'envoi de la notification au listener

● par utilisation de la classe NotificationFilterSupport– la méthode enableType() permet d'enregistrer les types de

notifications permis

● l'enregistrement du filtre est effectué lors de l'ajout du listener– méthode addNotificationListener(...)



● Filtrer les notifications● par implémentation de NotificationFilterclass CompteurNotificationFilter implements NotificationFilter {

String[] types = { "antislashn.counter.down" };

@Overridepublic boolean isNotificationEnabled(Notification notification) {

for (String type : types) {if (type.equals(notification.getType()))

return true;}return false;

}}



● Filtrer les notifications● par utilisation de NotificationFilterSupport

NotificationFilterSupport filter = new NotificationFilterSupport();filter.enableType("antislashn.counter.down");serverConnection.addNotificationListener(objectName, new CompteurListener(), filter, null);


MXBean

● Le MXBean est un Standard MBean avec des restrictions sur les types● pas d'utilisation de types personnalisés● utilisation de OpenType<T> et de ses types dérivés● le client de MXBean n'a pas besoin de connaître la

classe métier utilisée– le codage de la partie cliente est moins directe

● mais plus générique

● cf. http://docs.oracle.com/javase/7/docs/api/javax/management/MXBean.html

http://docs.oracle.com/javase/7/docs/api/javax/management/MXBean.html


MXBean

● Exemple de Standard MBean exposant une classe métier Contact

● Utilisation par le client

public interface ContactServiceMBean {void addContact(Contact contact);List<Contact> getAllContacts();Contact getContact(int id);

}

...JMXServiceURL serviceURL = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://:3333/jmxrmi");JMXConnector jmxConnector = JMXConnectorFactory.connect(serviceURL);MBeanServerConnection serverConnection = jmxConnector.getMBeanServerConnection();

ObjectName objectName = new ObjectName("antislashn.jmx:type=ContactService");ContactServiceMBean contactService = JMX.newMBeanProxy(serverConnection,

objectName, ContactServiceMBean.class);Contact c1 = contactService.getContact(1);...

La classe Contact estimportée


MXBean

● Pour transformer le Standard MBean en XMBean, il faut implémenter une interface postfixée par MXBean au lieu de MBean

public interface ContactServiceMBean {void addContact(Contact contact);List<Contact> getAllContacts();Contact getContact(int id);

}

public interface ContactServiceMXBean {void addContact(Contact contact);List<Contact> getAllContacts();Contact getContact(int id);

}


MXBean

● Le client ne récupère plus une classe métier mais un CompositeType● on interroge alors le CompositeType

– par le nom des propriétés du type métier● les collections sont transformées en tableaux


ObjectName objectName = new ObjectName("antislashn.jmx:type=MXContactService");CompositeData[] liste = (CompositeData[]) serverConnection.getAttribute(objectName, "AllContacts");for(CompositeData data : liste){

String name = (String) data.get("name");int age = (int) data.get("age");System.out.println("Contact : "+name+ " - "+age);

}

interrogation de l'attribut AllContactsdu XMBean

récupération des propriétés de l'objetmétier par leur nom


Services de monitoring● Permet d'observer les valeurs des attributs d'un

MBean● le MBean est l'objet observé● le moniteur observe le MBean à intervalle régulier

– en ms (granularity period)– une notification est envoyée lorsqu'une condition est

satisfaite● la condition varie en fonction du type de moniteur

– le moniteur peut calculer une valeur par différence (derived gauge)

● pour les attributs numériques● non activé par défaut

– cf. méthode setDifferenceMode(boolean value)


Services de monitoring

● Trois moniteurs de surveillance sont fournis par défaut dans l'implémentation JMX



● Surveillance de comptage● CounterMonitor● observe l'augmentation d'un attribut entier d'un MBean

– byte, short, int, long et classes associées– envoie une notification si la valeur de l'attribut observé

dépasse une certaine valeur (threshold)● possibilité de relancer la notification

– setOffset(Number value)– mode de calcul par différence

● if (counter[t] - counter[t-GP]) is positive then V[t] = counter[t] - counter[t-GP]● if (counter[t] - counter[t-GP]) is negative then V[t] = counter[t] - counter[t-GP] + MODULUS

– GP => garnularity period



● Surveillance d'évolution● GaugeMonitor● observe un changement arbitraire d'un attribut

numérique d'un MBean

– int, long, float, double et classes associées– envoie une notification si la valeur dérivée

● passe au-dessus d'une limite haute (high threshold)● passe en-dessous d'une limite basse (low threshold)



● Surveillance de chaîne de caractères● StringMonitor● observe un changement sur attribut de type String d'un

MBean● envoie une notification lorsque la valeur dérivée

– est égale à une chaîne de caractère précise– diffère d'une chaîne de caractère précise


CounterMonitor - exemple

● Un MBean compteur change sa propre valeur sur un thread● attribut Value

● Un CounterMonitor surveille se MBean

● Mise en place de la surveillanceMBeanServer server = ManagementFactory.getPlatformMBeanServer();

ObjectName compteurObjectName = new ObjectName("antislashn.jmx:type=Compteur");CompteurMBean compteurMBean = new Compteur();server.registerMBean(compteurMBean, compteurObjectName);

ObjectName monitorObjectName = new ObjectName("antislashn.jmx:type=Monitor");CounterMonitor monitor = new CounterMonitor();

monitor.addObservedObject(compteurObjectName);monitor.setObservedAttribute("Value");…server.registerMBean(monitor, monitorObjectName);

enregistrement du MBean Compteur

enregistrement du CounterMonitor

objet et attribut observé



● Signal généré par le CompteurMBean

● Stratégie mise en place● période de surveillance : toute les secondes● une notification est lancée si l'attribut est supérieur à 7

monitor.setGranularityPeriod(1000);monitor.setInitThreshold(7);monitor.setNotify(true);

0

100

10 s




● Stratégie mise en place● période de surveillance : toute les secondes● une notification est lancée si la valeur de l'attribut

surveillé est supérieur à 7


0

Integer.MAX_VALUE

incrément de 1 toutes les 100 ms




● Stratégie mise en place● période de surveillance : toute les secondes● une notification est lancée si la valeur de l'attribut

surveillé est supérieur à 7


0

Integer.MAX_VALUE





● Stratégie mise en place● période de surveillance : toute les secondes● une notification est lancée si l'attribut est supérieur à 7● l'offset ajouté au threshold a chaque fois que la valeur

sous surveillance est supérieure au threshold– permet de lancer plusieurs

notifications

monitor.setGranularityPeriod(1000);monitor.setInitThreshold(7);monitor.setOffset(5);monitor.setNotify(true);

0

Integer.MAX_VALUE



GaugeMonitor - exemple


0

100

10 s

GaugeMonitor monitor = new GaugeMonitor();

monitor.addObservedObject(compteurObjectName);monitor.setObservedAttribute("Value");

monitor.setGranularityPeriod(10);monitor.setThresholds(7, 3);monitor.setNotifyHigh(true);monitor.setNotifyLow(true);


Timer Service

● Émetteur de notifications programmable● intervalle fixe● date donnée● etc.

● Structure du service● le service émet des TimerNotification


Timer Service

● Classe Timer● utilise un thread secondaire● méthode addNotification(...)

– ajoute une notification à la file des notifications à envoyer– plusieurs signatures

● envoi d'une notification● envoi période de notification● envoi d'un nombre prédéfini de notification


Timer Service

● Utilisation du timer● création d'une instance de Timer● ajout d'une notification● ajout d'un listener● démarrage du timer

Timer mBean = new Timer();Date date = new Date(new Date().getTime()+Timer.ONE_SECOND*2);mBean.addNotification("antislashn.timer.test", "test 1", null, date);mBean.addNotification("antislashn.timer.test", "test 2", null, date,1000,10);mBean.addNotificationListener(new TimerNotificationListener(), null, null);mBean.start();

une notification sera envoyée à la date programmée

10 notifications seront envoyées, toutes les secondes, à partir de la date programmée


Monitoring de la JVM

● Plusieurs fonctionnalités ont été ajoutées depuis le JDK 1.5● la JVM est instrumentée avec des MBean● existence d'une API de monitoring

– permet d'obtenir des informations sur l'état de la JVM durant son exécution

● mémoire, threads, garbage collector, …

– utilisable sous forme de MBean de type MXBean● chaque MBean est identifié par son ObjectName● ils implémentent l'interface PlatformManagedObject● des méthodes la classe ManagementFactory permettent de

récupérer directement les MXBeans



● Exemple sur OperatingSystemMXBean

OperatingSystemMXBean mxBean = ManagementFactory.getOperatingSystemMXBean();System.out.println("Architecture : "+mxBean.getArch());System.out.println("Nb de processeurs : "+mxBean.getAvailableProcessors());System.out.println("Système d'exploitation : "+mxBean.getName()+" "+mxBean.getVersion());System.out.println("Charge du système : "+mxBean.getSystemLoadAverage());

Architecture : x86Nb de processeurs : 8Systeème d'exploitation : Windows 7 6.1Charge du système : -1.0

la charge n'a pas pu être calculée



● Exemple sur RuntimeMXBeanRuntimeMXBean rBean = ManagementFactory.getRuntimeMXBean();System.out.printf("Boot classpath : %s\n", rBean.getBootClassPath());System.out.printf("classpath : %s\n", rBean.getClassPath());System.out.println("Input argument :");List<String> arguments = rBean.getInputArguments();for (String arg : arguments) {

System.out.println(" " + arg);}System.out.printf("Library path : %s\n", rBean.getLibraryPath());System.out.printf("Management spec version : %s\n", rBean.getManagementSpecVersion());System.out.printf("Name : %s\n", rBean.getName());System.out.printf("Spec name : %s\n", rBean.getSpecName());System.out.printf("Vendor : %s\n", rBean.getSpecVendor());System.out.printf("Spec version : %s\n", rBean.getSpecVersion());System.out.printf("StartTime : %d ms\n", rBean.getStartTime());


Service JBoss – jusqu'à version 6

● Les services sont des archives SAR déployés dans le répertoire de déploiement● l'archive contient un fichier de description du service

– META-INF/jboss-service.xml

● Le service créé doit utiliser les classes JBoss● interface org.jboss.system.ServiceMBean● classe org.jboss.system.ServiceMBeanSupport

– fournit des méthodes de gestion du cycle de vie du service



● Diagramme de classe de l'exemple HelloService



● Code de l'exemple (extraits)public interface HelloServiceMBean extends ServiceMBean{

void setMessage(String message);String getMessage();void sayHello();

}

public class HelloService extends ServiceMBeanSupport implements HelloServiceMBean {private String message;

@Overridepublic void setMessage(String message) {

this.message = message;}

@Overridepublic String getMessage() {

return message;}

...}



● Contenu du fichier de déploiement● META-INF/jboss-service.xml

– cf. la DTD jboss-service_x_y.dtd (version x, release y)

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE server><server> <mbean code="org.antislashn.jmx.HelloService"

name="antislashn.service:service=HelloService">

<attribute name="Message">Bonjour tout le monde</attribute>

</mbean></server>

classe d'implémentation

ObjectName du service

initialisation de l'attribut Message



● Attributs les plus courants pour <mbean> :● <code> (obligatoire) : classe d'implémentation

● <name> (obligatoire) : JMX ObjectName du MBean

● <interface> : nom qualifié de l'interface, par défaut le nom de cette interface suit la spécification MBean



● Éléments fils les plus courants pour <mbean> :● <constructor (args*)> : spécifie un constructeur,

si le constructeur par défaut n'est pas utilisé– <arg> : argument du constructeur, possède les attributs type et value

● <attribute> : permet l'initialisation d'un attribut du MBean

● <depends> : spécifie une dépendance vers un autre MBean

● Cf. la DTD pour une documentation exhaustive



● La console JMX de JBoss permet de vérifier la prise en compte du déploiement du service


Service JBoss – version 7

● Deux stratégies de mise en place d'un service● service JMX MBean

– plus simple qu'avec les versions précédentes– pas besoin d'étendre les classes et interfaces JBoss

● les méthode start() et stop() seront automatiquement appelées

– le fichier META-INF/jboss-service.xml référencie un schéma XML au lieu d'une DTD

● service EJB– ce n'est pas un service JMX– avec les annotations @Singleton et @Startup



● Exemple de service JMXpublic interface HelloServiceMBean {

void setMessage(String message);String getMessage();void sayHello();

}

public class HelloService implements HelloServiceMBean {private String message;

@Overridepublic void setMessage(String message) {this.message = message;}

@Overridepublic String getMessage() {return message;}

@Overridepublic void sayHello() {System.out.println(">>> HelloService : "+message);}

public void start() throws Exception {System.out.println(">>> CYCLE DE VIE HelloService start");}

public void stop() {System.out.println(">>> CYCLE DE VIE HelloService stop");}

}



● Exemple de fichier de déploiement● META-INF/jboss-service.xml● cf. le schéma pour plus de détails

<?xml version="1.0" encoding="UTF-8"?><server xmlns="urn:jboss:service:7.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="urn:jboss:service:7.0 jboss-service_7_0.xsd">

<mbean code="org.antislashn.jmx.HelloService"name="antislashn.service:service=Hello,type=test">

<attribute name="Message">Hello, world</attribute> </mbean></server>



● Le service est disponible dans la console JBoss, ainsi que par jconsole ou jvisualvm


Console en mode distant

● jconsole ou jvisualvm peuvent se connecter en mode distant● côté serveur JMX il faut au moins lancer l'application

Java avec l'indication du port utilisé

● lancer alors la console en mode "Remote Process"

-Dcom.sun.management.jmxremote.port=3333-Dcom.sun.management.jmxremote.authenticate=false-Dcom.sun.management.jmxremote.ssl=false



● Activation du fichier des mots de passe● deux fichiers sont nécessaires

– fichier des droits d'accès● par défaut : JRE_HOME/lib/management/jmxremote.acces● définit les droits d'accès

– fichier des mots de passe● par défaut : JRE_HOME/lib/management/jmxremote.password● définit les mots de passe● le fichier modèle doit être renommé

● les fichiers doivent être en lecture seule– attention à l'héritage des droits sous Windows



● Activation du fichier des mots de passe● si les fichiers utilisé ne sont pas sous JRE_HOME/lib/management il faut ajouter les arguments suivant à la JVM– ici les fichiers sont recherché dans le répertoire du projet

● En production il est préférable● d'activer SSL● d'utiliser JAAS pour l'authentification

-Dcom.sun.management.jmxremote.access.file=jmxremote.access-Dcom.sun.management.jmxremote.password.file=jmxremote.password


Client personnalisé en mode distant

● Si le mode distant est sécurisé, il faut passer le rôle et le mot de passe au moment de la connexion● extrait de code

String[] credential = {"controlRole","titi"};Map<String,String[]> env = new HashMap<String,String[]>();env.put(JMXConnector.CREDENTIALS, credential);

JMXServiceURL serviceURL = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://:3333/jmxrmi");

JMXConnector jmxConnector = JMXConnectorFactory.connect(serviceURL,env);

MBeanServerConnection serverConnection = jmxConnector.getMBeanServerConnection();

ObjectName objectName = new ObjectName("antislashn.jmx:bean=Hello,type=standard");HelloMBean mBean = JMX.newMBeanProxy(serverConnection, objectName, HelloMBean.class);


Console en mode distant – problèmes potentiels

● Gestion des droits sous Windows

● au lancement du serveur JMX l'erreur suivante apparaît

● il faut modifier les droits (click droit sur le fichier)

Erreur: L'accès en lecture au fichier de mots de passe doit être limité: jmxremote.password

cf pagesuivante



● Gestion des droits sous Windows (suite)

décochercf pagesuivante



● Gestion des droits sous Windows (suite)

OK OK

supprimer tous les utilisateurssauf l'administrateur


Pour aller plus loin

● MXBean● MBean permetant l'utilisation des types utilisateurs au

travers des OpenType<T>

● OpenMBean

– dynamique MBean utilisant les OpenType<T>● M-Let service

● service de chargement dynamique des MBeans

● RelationService● service de mise en relation des MBeans entre eux


Pour aller plus loin

● Les OpenType<T>● décrit un type de donnée utilisé par les OpenMBeans

et les MXBeans– SimpleType : type simple

● wrapper de type primitif, String, Date, ObjectName

– CompositeType : type composé d'autres OpenType

– TabularType : données tabulaires

– ArrayType : données sous forme de tableau


Références

● Livres● Java Management Extension

– auteur : J. Steven Perry– éditeur : O'Reilly

● JMX – Managing J2EE with Java Management Extension

– auteurs : Juha Lindfors, Marc Fleury, The JBoss Group– éditeur : SAMS

● Web● http://docs.oracle.com/javase/7/docs/technotes/guides/jmx/JMX_1_4_specification.pdf

● http://www.jmdoudoux.fr/java/dej/chap-jmx.htm#jmx-12

http://docs.oracle.com/javase/7/docs/technotes/guides/jmx/JMX_1_4_specification.pdf

http://www.jmdoudoux.fr/java/dej/chap-jmx.htm#jmx-12

copyleft

Support de formation créer par

Franck SIMON

http://www.franck-simon.com

http://www.franck-simon.com/

http://www.franck-simon.com/

copyleft

Cette œuvre est mise à disposition sous licence Attribution

Pas d'Utilisation Commerciale

Partage dans les Mêmes Conditions 3.0 France.

Pour voir une copie de cette licence, visitez http://creativecommons.org/licenses/by-nc-sa/3.0/fr/

ou écrivez à

Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.

http://creativecommons.org/licenses/by-nc-sa/3.0/fr/

http://creativecommons.org/licenses/by-nc-sa/3.0/fr/

copyleft

Support de formation créer par

Franck SIMON

http://www.franck-simon.com

copyleft

Cette œuvre est mise à disposition sous licence Attribution

Pas d'Utilisation Commerciale

Partage dans les Mêmes Conditions 3.0 France.

Pour voir une copie de cette licence, visitez http://creativecommons.org/licenses/by-nc-sa/3.0/fr/

ou écrivez à

Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.

Technology

JBoss - chapitre JMX