JMS Cours

Intergiciels pour la rpartition
JMS : Java Message Service
Patrice Torguet
torguet@irit.fr
Universit Paul Sabatier
Plan du cours
l
l
l
l
l
l
l
l
Introduction aux MOM

Introduction JMS
Quelques mots sur JNDI
Connexions et Sessions
Destinations, producteurs et consommateurs
Les Messages
Mcanisme de Requte/Rponse
Exemple complet

l
l
l
MOM : Message Oriented Middleware

Intergiciels orients Messages
But :
Cration de messages complexes (pas uniquement des

tableaux doctets)
Emission/Rception de messages
Eventuellement : stockage de messages

l
l
Message Passing et Message Queuing

Les messages peuvent soit :
tre envoys directement dune application lautre.

Cest ce quon appelle du passage de message. MPI est
un exemple de MOM utilisant le Message Passing.
tre stocks dans des files de message avant dtre
rcuprs ultrieurement.

l
l
l
La plupart des MOM grant le Message Queueing

permettent 2 concepts :
Les files de messages : qui stockent les messages
produits jusqu leur consommation.
Les sujets de discussion : qui permettent une
communication un vers plusieurs. Des applications
sabonnent un sujet et lorsquun message est
envoy sur le sujet, tous les abonns le reoivent.

l
Les sujets de discussion peuvent parfois fonctionner

en cascade :

l
Avantages des MOM par MQ
Le plus gros avantage est lasynchronisme des

communications. Une application peut produire des
messages alors que le rcepteur nest pas prsent. Ceci
est trs utile pour grer le nomadisme.
Pour les sujets on dispose du concept dabonnement
persistant (une file stocke les messages publis pour un
abonn qui nest pas prsent).
Autre avantage : sret de fonctionnement. Si le
rcepteur sarrte cause dune erreur, les messages non
traits compltement seront disponibles aprs le
redmarrage.
Introduction JMS
l
l
JMS est une API Java qui permet de travailler avec

des MOM fonctionnant en mode Message Queuing
Pour travailler avec JMS il faut :
lAPI JMS qui permet dcrire les applications qui

schangent les message : package javax.jms disponible
dans jms-1.1.jar
Un fournisseur (provider) JMS qui gre ladministration
des files de message, le stockage des messages... Il peut
soit tre implment en Java ou tre un front-end JMS
pour une application existante crite dans un autre
langage
Introduction JMS
App 1
App 2
App 3
API JMS
Fournisseur JMS / MOM
10
App C
Introduction JMS
l
Ce que dfinit JMS
11
La cration de messages structurs (enttes, proprits,

corps)
La connexion a un fournisseur JMS nomm via JNDI
La rcupration dune file ou dun sujet nomms via
JNDI
La production dun message dans une file ou un sujet
La consommation dun message depuis une file ou un
sujet
Introduction JMS
l
Ce qui nest pas dfini par le standard
12
Ladministration (cration, destruction, vidage...) des files

Comment sont stockes les files
La rpartition dun fournisseur JMS
Linteroprabilit entre plusieurs fournisseurs JMS (cf.
MOMA : MOM Association)
...
Introduction JMS
l
Hirarchie de classes/interfaces
13
JMS dfinit deux ensembles de classes/interfaces pour les

files et pour les sujets (exemple QueueConnection et
TopicConnection)
pour permettre une utilisation gnrique JMS dfinit un
ensemble supplmentaire de classes gnriques (exemple
Connection)
Ici nous prsenterons essentiellement cet ensemble
gnrique.
Introduction JMS
l
MOMs compatibles JMS :
14
ActiveMQ de Apache
OpenJMS de The OpenJMS Group
JBoss Messaging de JBoss
JORAM de Objectweb
Weblogic de BEA
Oracle AQ
SAP NetWeaver WebAS Java JMS de SAP AG
SonicMQ de Progress Software
Sun Java System Message Queue
Introduction JMS
l
MOMs compatibles JMS (suite) :
15
TIBCO Software
webMethods Broker Server de webMethods
WebSphere Application Server dIBM
WebSphere MQ dIBM (appel prcdemment
MQSeries)

l
l
l
l
JNDI : Java Name and Directory Interface

API pour grer des annuaires de donnes ou
dobjets
Les annuaires peuvent tre grs par des fichiers ou
par des systmes dannuaires rpartis comme LDAP
JNDI offre essentiellement deux mthodes :
16
Bind : qui permet de donner un nom une ressource

Lookup : qui permet de trouver la ressource partir du
nom
JNDI est utilis par RMI, JMS et Java EE
17
l
l
18
JMS utilise deux concepts pour grer la connexion

entre un client et le fournisseur :
Les connexions qui peuvent grer la concurrence
via des threads. Elles sont cres partir dune
usine connexion (ConnectionFactory) rcupre
via JNDI. Lors de leur cration on peut prciser un
login/mot de passe.
Les sessions qui sont mono-thread. Elles sont cres
partir dune connexion. Elles peuvent grer des
transactions recouvrables (commit/rollback)
l
Code :
Context contexte = null;
Connection connexion = null;
String factoryName = "ConnectionFactory";
Session session = null;
// note ce code peut gnrer des NamingException et JMSException
// cration du contexte JNDI.
contexte = new InitialContext();
// rcupration de la ConnectionFactory
ConnectionFactory cf = (ConnectionFactory) contexte.lookup(factoryName);
// cration de la connexion
connexion = cf.createConnection();
// avec login : connexion = cf.createConnection("login", "pass");
19
// cration de la session sans transaction et avec des acquittements automatiques

session = connexion.createSession(false, Session.AUTO_ACKNOWLEDGE);
// avec transaction : session = connexion.createSession(true, 0);
...
Destinations, producteurs et
consommateurs
l
20
Les destinations reprsentent les files/sujets que

lon utilise pour produire/consommer des messages.
Elles sont rcupres via JNDI.
Une session peut crer des producteurs
(MessageProducer) et des consommateurs de
message (MessageConsumer)
Pour pouvoir recevoir il faut dmarrer la
connexion : connexion.start(); !!!
consommateurs
l
Les consommateurs peuvent tre synchrones

(bloquants avec ou sans expiration) ou asynchrones
(callback)
Pour les callbacks on utilise linterface
MessageListener
21
On doit dfinir la mthode void onMessage(Message m)

qui va traiter les messages ds quils sont disponibles
Attention : cette mthode doit rcuprer toutes les
exceptions (y compris les RuntimeException) !!!
Puis on doit rfrencer le listener auprs du
consommateur : conso.setMessageListener(ml);
Producteur Anonyme
l
Pour viter davoir un producteur pour chaque

destination on peut crer un producteur anonyme :
MessageProducer anon_prod = session.createProducer(null);
Pour lutiliser on utilisera une version de la mthode

send qui prends une destination en paramtre :
anon_prod.send(dest, message);
22
consommateurs
l
Code :
...
MessageProducer mp = null;
MessageConsumer mc = null;
// rcupration de la Destination
Destination dest = (Destination) contexte.lookup(FileProduction);
// cration du producteur
mp = session.createProducer(dest);
// rcupration de la Destination
Destination dest = (Destination) contexte.lookup(FileConsommation);
// cration du consommateur
mc = session.createConsumer(dest);
// dmarre la connexion (il faut le faire pour pouvoir recevoir)
connexion.start();
...
23
consommateurs
l
Spcifique aux files :
24
On peut crer la place dun MessageConsumer un

QueueBrowser pour examiner les messages sans les
prlever
consommateurs
l
Spcifique aux sujets :
25
On peut crer un abonn persistant en utilisant la classe

TopicSubscriber ( la place de MessageConsumer).
On devra prciser un nom qui sera utilis pour retrouver
les messages stocks pendant que le programme de
rception nest pas disponible
Dautre part il faut que le client est le mme identifiant
(gr via lappli dadministration du fournisseur)
Pour dtruire labonn persistant il faudra utiliser la
mthode unsuscribe de Session
consommateurs
l
Sans Abonn persistant :

M3 et M4 ne sont pas reus
Avec Abonn persistant

Tous sont reus
26
consommateurs
l
Code :
// cration du browser
QueueBrowser browser = session.createBrowser(queue);
// dmarrage de la connexion
connection.start();
// consultation des messages prsents
Enumeration messages = browser.getEnumeration();
while (messages.hasMoreElements()) {
Message message = (Message) messages.nextElement();
}
// cration de labonn persistant (
TopicSubscriber subscriber = session.createDurableSubscriber(topic, nomAboPersist);
// dmarre la connexion. Si labonn existait dj on va recevoir les messages
// en attente ds ce moment
connection.start();
while(true) {
Message message = subscriber.receive();
}
27
Schma rcapitulatif
28
Usines Connexions, Destinations et

Java EE
l
Avec un serveur dentreprise Java EE on utilise en

gnral linjection de ressource pour les CF et les
destinations ainsi :
@Resource(lookup = "jms/ConnectionFactory")
private static ConnectionFactory connectionFactory;
@Resource(lookup = "jms/Queue")
private static Queue queue;
@Resource(lookup = "jms/Topic")
private static Topic topic;
29
Les Messages
l
Les Messages comportent :
Il y a 5 sous-types de messages :
30
Des enttes standard ;

Des proprits applicatives nommes (optionnelles) ;
Un corps dpendant du type de message.
texte (TextMessage)
associations noms-donnes (MapMessage)
flot de donnes (StreamMessage)
flot de donnes binaires (BytesMessage)
objet (ObjectMessage)
Les Messages
l
Les enttes standard
31
JMSDestination : rfrence vers la file / le sujet utilis

pour transfrer le message
JMSReplyTo : rfrence vers une autre file/sujet que lon
doit utiliser pour rpondre au message
JMSType : type applicatif du message (String)
... : dautres enttes existent mais sont peu utilises et pas
gres par tous les fournisseurs
Pour chaque entte on dispose dune mthode set et

dune mthode get (exemple : setJMSReplyTo)
Les Messages
l
l
l
l
Les proprits nommes

Il sagit de donnes de types de base (int, float...) ou
String qui sont repres par un nom.
Pour chaque type on a une mthode set et une
mthode get
exemple :
32
void setIntProperty(String, int)

int getIntProperty(String)
Les Messages
l
33
Il y a un mcanisme de conversion automatique

suivant le tableau :
Les Messages
l
l
l
Lors de la cration des consommateurs on peut

prciser un filtre utilisant les enttes et proprits
La syntaxe reprend celle de SQL92
Exemples :
34
JMSType=car AND color=red AND year < 2008 (o

color et year sont des proprits de type String et int)
JMSType IN (car, motorbike, van)
age BETWEEN 15 AND 19 (age prop de type int)
age >= 15 AND age <= 19
Les Messages
l
Code :
// cration dun consommateur avec slecteur
mc = session.createConsumer(dest, JMSType IN (un, deux, trois));
// on ne recevra que des messages dun de ces 3 types
Message m = mc.receive();
35
Les Messages
l
Les messages textes (TextMessage)
Les messages transportants des objets

(ObjectMessage)
36
Ils permettent de transporter un texte quelconque

Utile pour linteroprabilit : transporter du texte XML
mthodes : setText / getText
Ils permettent de transporter un objet srialis

mthodes : setObject / getObject
spcifique Java (interoprablit impossible avec un
autre langage)
Les Messages
l
Les messages associatifs (MapMessage)
Les messages de type flot (StreamMessage)
37
Ils transportent des donnes de type de base, String ou

byte[] (tableaux doctets non interprts) associes des
noms (idem proprits)
mthodes : void setInt(String, int) / int getInt(String) ...
Ils transportent des donnes (types de base, String, byte
[]) places les unes la suite des autres
mthodes : void writeInt(int) / int readInt()
Ces 2 types utilisent des conversions similaires au

proprits
Les Messages
l
Les messages de type flot binaire (BytesMessage)
38
Ils transportent des donnes (types de base, String, byte

[]) places les unes la suite des autres
mthodes : void writeInt(int) / int readInt()
diffrence avec prcdent : pas de conversion
peu utilis car non interoprable
Les Messages
l
Mthodes utilitaires :
39
clearBody() sert effacer toutes les donnes dun

message
getPropertyNames() renvoie une numration des noms
des proprits contenues dans un message
Remarque : un message reu est en lecture seule
Les Messages
l
Code (ct production) :

// cration de l'ObjectMessage et affectation de l'objet envoyer
ObjectMessage message = session.createObjectMessage();
message.setJMSType("type"); // header
message.setIntProperty("i", 10); // prop1
message.setStringProperty("ch", "bonjour"); // prop2
message.setObject(obj); // corps : obj est srialisable
// envoie l'objet
mp.send(message);
// autres exemples
TextMessage tmess = session.createTextMessage("Bonjour");
MapMessage mmess = session.createMapMessage();
mmess.setBoolean("bool", true);
mmess.setFloat("PI", 3.1459f);
mmess.setString("ch", "test");
StreamMessage smess = session.createStreamMessage();
smess.writeInt(1);
smess.writeString("test");
mp.send(tmess); mp.send(mmess); mp.send(smess);
40
Les Messages
l
41
Code (ct consommation) :
// rcupration d'un message

Message m = mc.receive();
// on s'assure qu'il est du bon type
if (m instanceof ObjectMessage) {
ObjectMessage om = (ObjectMessage)m;
// rcupration de l'objet transport
Object o = om.getObject();
// enttes et proprits
String type = om.getJMSType();
int i = om.getIntProperty("i");
String ch = om.getStringProperty("ch");
}
// autres exemples
TextMessage tmess = (TextMessage) mc.receive(100); // attente pendant 100 ms
if (mmess != null) System.out.println(tmess.getText());
MapMessage mmess = (MapMessage) mc.receiveNoWait(); // pas d'attente
if (mmess != null) {
boolean b = mmess.getBoolean("bool");
String ch = mmess.getString("ch");
float f = mmess.getFloat("PI");

}
l
Outils :
Fonctionnement :
42
Entte JMSReplyTo
Files temporaires (cres avec la mthode
createTemporaryQueue de Session)
Lapplication 1, cre une file temporaire, cre un message
requte, y indique la file temporaire en JMSreplyTo et
produit le message ;
Lapplication 2, rcupre le message, le traite, cre la
rponse, utilise la session pour crer un producteur sur la
file temporaire (getJMSReplyTo) et utilise ce producteur
pour envoyer la rponse.
App 1
Tempo 1
File
App 3
43
Tempo 2
App 2
App 1
Tempo 1
File
App 3
44
Tempo 2
App 2
App 1
Tempo 1
File
App 3
45
Tempo 2
App 2
App 1
Tempo 1
File
App 3
46
Tempo 2
App 2
App 1
Tempo 1
File
App 3
47
Tempo 2
App 2
App 1
Tempo 1
File
App 3
48
Tempo 2
App 2
App 1
Tempo 1
Sujet
App 2
App 3
49
App 1
Tempo 1
Sujet
App 2
App 3
50
App 1
Tempo 1
Sujet
App 2
App 3
51
App 1
Tempo 1
Sujet
App 2
App 3
52
App 1
Tempo 1
Sujet
App 2
App 3
53
App 1
Tempo 1
Sujet
App 2
App 3
54
Gestion des transactions

l
2 types de transactions :
Pour utiliser les transactions locales on crera une

session ainsi :
55
Locales, gres par la session, ne concernent que JMS

Distribues, gres par JTA, peuvent concerner : JMS,
JDBC, EJB...
NB : Dans les EJB on est oblig dutiliser JTA
Session session = connection.createSession(true, 0);
Ensuite on utilisera :
session.commit();
session.rollback();

l
l
l
56
Ds que la session est cre une transaction

commence
Aprs chaque commit ou rollback une nouvelle
transaction commence
Si on ferme la session/connexion sans avoir fait de
commit toutes les oprations sont annules !

l
l
l
l
57
Lorsquon fait un commit, les messages produits sont

envoys et les messages reus sont acquitts
Lorsquon fait un rollback, les messages produits
sont dtruits et les messages reus sont rcuprs par
le fournisseur et livrs nouveau lors de prochains
receive (sauf si ils ont expirs)
On peut faire des send et receive dans la mme
transaction mais il faut quils soient indpendants
Si un receive correspond au traitement dun message
envoy a va bloquer puisque le message nest
envoy que lors du commit
p.send(m1); m1
p.send(m2);
s.commit() m2
m1 = c.receive();
s.rollback();
File
m2 = c.receive();
m1 = c.receive();
s.commit();
58
p.send(m1);
p.send(m2);
s.commit()
m1 = c.receive();
s.rollback();
m1
m2File
m2 = c.receive();
m1 = c.receive();
s.commit();
59
p.send(m1);
p.send(m2);
s.commit()
m1m1 = c.receive();
s.rollback();
m2File
m2 = c.receive();
m1 = c.receive();
s.commit();
60
p.send(m1);
p.send(m2);
s.commit()
m1m1 = c.receive();
s.rollback();
File
m2
m2 = c.receive();
m1 = c.receive();
s.commit();
61
p.send(m1);
p.send(m2);
s.commit()
m1 = c.receive();
s.rollback();
File
m1
m2
m2 = c.receive();
m1 = c.receive();
s.commit();
62
p.send(m1);
p.send(m2);
s.commit()
m1 = c.receive();
s.rollback();
File
m2
m2 = c.receive();
m1 = c.receive();
m1
s.commit();
63
Fiabilit de JMS
l
Pour grer la fiabilit des applications utilisant JMS

on peut :
64
contrler lacquittement des messages

rendre les messages persistants
dfinir des priorits sur les messages
prciser une date dexpiration pour un message
Fiabilit de JMS
l
Contrler lacquittement des messages
Normalement on doit faire la chose suivante

l
l
l
65
Recevoir un message
Le traiter
Acquitter le message
Cependant, si on choisi le mode automatique

dacquittement des messages et quon utilise lopration
receive lacquittement se fera lors de la rception
Donc si le traitement conduit un crash de lapplication
le message sera perdu
Fiabilit de JMS
l
Contrler lacquittement des messages
Solution : utiliser lacquittement manuel des messages

Lors de la cration de la session :
l
Lors de la rception dun message :

l
l
l
66
Session s = c.createSession(false,
Session.CLIENT_ACKNOWLEDGE);
Message m = c.receive(); // rception du message
...
// traitement du message
m.acknowledge();
// acquittement du message
Fiabilit de JMS
l
67
NB : avec les message listener on peut toujours

utiliser Session.AUTO_ACKNOWLEDGE puisque
lacquittement auto se fait aprs lappel de la
mthode onMessage
Il existe aussi une option
Session.DUPS_OK_ACKNOWLEDGE qui indique
que lacquittement peut se faire plus tard pour
amliorer lefficacit de la communication client/
fournisseur => mais on peut avoir des traitements
dupliqus si le fournisseur plante
Fiabilit de JMS
l
68
Si des messages dune file ou dun sujet avec abonn

persistant nont pas t acquitts quand la session est
ferme ils seront livrs nouveau
On peut vrifier cela en testant le champ dentte
JMSRedelivered qui vaut vrai si il y a dj eu
livraison
On peut utiliser la mthode recover de Session pour
redmarrer la livraison au premier message non
acquitt
Fiabilit de JMS
l
Rendre les messages persistants
JMS permet 2 modes de livraison :

l
69
PERSISTENT (par dfaut) signifie que le fournisseur doit

stocker le message sur disque et ainsi en cas de crash fournisseur
il ne sera pas perdu
NON_PERSISTENT signifie que le fournisseur na pas stocker
le message sur disque et donc quil peut tre perdu
Le second mode amliore les performances mais diminue

la fiabilit
Fiabilit de JMS
l
Rendre les messages persistants
Choix sur le producteur (pour tous les messages envoys

per celui-ci) :
l
Choix message par message

l
l
70
producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
producer.send(message, DeliveryMode.NON_PERSISTENT, 3,
10000);
NB : les 3mes et 4mes paramtres sont la priorit et
lexpiration
Fiabilit de JMS
l
Dfinir des priorits sur les messages
On peut choisir une priorit parmi 10 (de 0 9) pour

indiquer des messages prioritaires ou non
Les messages de priorit suprieure seront livrs avant
ceux de priorit infrieure
Par dfaut les messages ont la priorit 4
Ici aussi on peut le faire pour tous les messages envoys
par un producteur :
l
71
producer.setPriority(7);
ou en utilisant la version longue de send
Fiabilit de JMS
l
Prciser une date dexpiration pour un message
Par dfaut les messages nexpirent jamais

On peut choisir une dure de vie maximale (en
milisecondes), 0 indique quils nexpirent jamais.
Ici aussi on peut le faire pour tous les messages dun
producteur :
l
72
producer.setTimeToLive(60000); // expiration aprs 1 minute
ou avec la version longue de send
Exemple complet
l
Producteur (ici avec gestion de transaction) :
public static void main(String[] args) {

Context context = null;
ConnectionFactory factory = null;
Connection connection = null;
String destName = null;
Destination dest = null;
int count = 1;
MessageProducer sender = null;
String text = "Message ";
if (args.length < 1 || args.length > 2) {
System.out.println("usage: Sender <destination> [count]");
System.exit(1);
}
73
destName = args[0];
if (args.length == 2) {
count = Integer.parseInt(args[1]);
}
Exemple complet
try {
// cration du contexte JNDI.
context = new InitialContext();
// recherche de la ConnectionFactory
factory = (ConnectionFactory) context.lookup(factoryName);
// recherche de la Destination
dest = (Destination) context.lookup(destName);
connection = factory.createConnection();
// cration de la session avec transaction
session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
// cration du producteur
sender = session.createProducer(dest);
// dmarrage de la connexion (optionnel ici)
connection.start();
74
Exemple complet
try {

75
for (int i = 0; i < count; ++i) {

TextMessage message = session.createTextMessage();
message.setText(text + (i + 1));
sender.send(message);
System.out.println("Sent: " + message.getText());
}
session.commit();
} catch(Exception e) {

session.rollback();
}
} catch (JMSException exception) {
exception.printStackTrace();
} catch (NamingException exception) {
Exemple complet
} finally {
// fermeture du contexte
if (context != null) {
try {
context.close();
}
}
// fermeture de la connexion
if (connection != null) {
try {
connection.close();
}
}
}
}
76
Exemple complet
l
Consommateur (ici asynchrone avec callback) :

// classe contenant le callback
public class SampleListener implements MessageListener {
// chaque rception cette mthode est appele automatiquement
public void onMessage(Message message) {
if (message instanceof TextMessage) {
TextMessage text = (TextMessage) message;
try {
System.out.println("Received: " + text.getText());
System.err.println("Failed to get message text: " + exception);
}
}
}
}
77
Exemple complet
l
Consommateur (ici asynchrone avec callback) :

public static void main(String[] args) {
Context context = null;
ConnectionFactory factory = null;
Connection connection = null;
String destName = null;
Destination dest = null;
MessageConsumer receiver = null;
BufferedReader waiter = null;
if (args.length != 1) {
System.out.println("usage: Listener <destination>");
System.exit(1);
}
destName = args[0];
78
Exemple complet
try {
// cre le contexte JNDI
context = new InitialContext();
// cherche la ConnectionFactory
factory = (ConnectionFactory) context.lookup(factoryName);
// cherche la Desination
dest = (Destination) context.lookup(destName);
connection = factory.createConnection();
// cration de la session
session = connection.createSession(
false, Session.AUTO_ACKNOWLEDGE);
// cration du rcepteur
receiver = session.createConsumer(dest);
79
// abonne un listener
receiver.setMessageListener(new SampleListener());
Exemple complet
// dmarre la connexion pour commencer la rception asynchrone des messages

connection.start();
System.out.println("Waiting for messages...");
System.out.println("Press [return] to quit");
waiter = new BufferedReader(new InputStreamReader(System.in));
waiter.readLine();
} catch (IOException exception) {
80
Exemple complet
} finally {
// ferme le contexte
if (context != null) {
try {
context.close();
}
}
// ferme la connexion
if (connection != null) {
try {
connection.close();
}
}
}
}
81
Remerciements et Questions ?
l
Ce cours est bas sur :
82
Le tutoriel sur Java EE dOracle:

http://download.oracle.com/javaee/6/tutorial/doc/
index.html
Le cours sur les MOM et JMS de Didier Donsez :
http://www-adele.imag.fr/users/Didier.Donsez/cours/
Le livre Java Messaging dEric Bruno
La page JMS de Wikipedia :
http://en.wikipedia.org/wiki/Java_Message_Service

JMS Cours

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

JMS Cours

Transféré par

Droits d'auteur :

Formats disponibles

Intergiciels pour la rpartition

JMS : Java Message Service

Introduction aux MOM

Introduction aux MOM

MOM : Message Oriented Middleware

Cration de messages complexes (pas uniquement des

Introduction aux MOM

Message Passing et Message Queuing

tre envoys directement dune application lautre.

Introduction aux MOM

La plupart des MOM grant le Message Queueing

Introduction aux MOM

Les sujets de discussion peuvent parfois fonctionner

Introduction aux MOM

Introduction aux MOM

Avantages des MOM par MQ

Le plus gros avantage est lasynchronisme des

JMS est une API Java qui permet de travailler avec

lAPI JMS qui permet dcrire les applications qui

Fournisseur JMS / MOM

Ce que dfinit JMS

La cration de messages structurs (enttes, proprits,

Ce qui nest pas dfini par le standard

Ladministration (cration, destruction, vidage...) des files

JMS dfinit deux ensembles de classes/interfaces pour les

MOMs compatibles JMS :

MOMs compatibles JMS (suite) :

Quelques mots sur JNDI

JNDI : Java Name and Directory Interface

Bind : qui permet de donner un nom une ressource

JNDI est utilis par RMI, JMS et Java EE

Quelques mots sur JNDI

JMS utilise deux concepts pour grer la connexion

// cration de la session sans transaction et avec des acquittements automatiques

Les destinations reprsentent les files/sujets que

Les consommateurs peuvent tre synchrones

On doit dfinir la mthode void onMessage(Message m)

Pour viter davoir un producteur pour chaque

Pour lutiliser on utilisera une version de la mthode

Spcifique aux files :

On peut crer la place dun MessageConsumer un

Spcifique aux sujets :

On peut crer un abonn persistant en utilisant la classe

Sans Abonn persistant :

Avec Abonn persistant

Usines Connexions, Destinations et

Avec un serveur dentreprise Java EE on utilise en

Les Messages comportent :

Des enttes standard ;

Les enttes standard

JMSDestination : rfrence vers la file / le sujet utilis

Pour chaque entte on dispose dune mthode set et

Les proprits nommes

void setIntProperty(String, int)

Il y a un mcanisme de conversion automatique

Lors de la cration des consommateurs on peut

JMSType=car AND color=red AND year < 2008 (o

Les messages textes (TextMessage)

Les messages transportants des objets

Ils permettent de transporter un texte quelconque

Ils permettent de transporter un objet srialis

Les messages associatifs (MapMessage)

Les messages de type flot (StreamMessage)