Vous êtes sur la page 1sur 20

S.

LYAZID 1

TP Internet des Objets.


Niveau Master 1 Réseaux & Multimédias.

Dans un premier temps, aller sur la page https://activemq.apache.org/ télécharger la version ActiveMQ 5
"Classic".

Installation et utilisation ActiveMQ


Pour plus de détails peuvent être trouvés en suivant le lien https://activemq.apache.org/getting-started.

Vérifier que vous avez java sur votre machine (version supérieure 1.7). Il suffit de lancer une commande
shell et de saisir l’instruction suivante : java –version. Si vous avez plusieurs versions, il suffit de modifier
le chemin vers la jdk adéquate. Si ce n’est pas le cas, renseigner la valeur JAVA_HOME dans la variable
environnement.

Ensuite ajouter une variable d’environnement ACTIVEMQ_HOME comme le montre les figures
suivantes :
S.LYAZID 2

Pour ce faire, il faut aller dans la variable d’environnement comme l’illustre la figure suivante :

1
2

3
1

Lancer un shell, et exécuter la commande activemq start


S.LYAZID 3

La fin de la fenêtre de la console doit fournir les lignes suivantes (Si ce n’est pas le cas, lire les exceptions
sur la console afin de corriger et pouvoir lancer le broker activemq.) :

Gestion de ActiveMQ
Vous pouvez utiliser l’interface à partir de votre navigateur préféré (Google Chrome,
Mozilla, etc. ). Pour ce faire, saisir l’adresse suivant http://localhost:8161/admin ou
http://127.0.0.1:8161/admin ou tout simplement Dans le navigateur : http://localhost:8161/
User : admin pwd : admin
User : user, pwd :user
Vous pouver modifier le nom et les mots de passe dans le fichier :
apache-activemq-5.16.3\conf\ jetty-realm.properties (voir figures suivantes).
S.LYAZID 4

Enfin voici la page web de votre broker.

Remarquer les vues : Queue, Topic, souscripteurs.

Queue
Topic

Créer une queue


S.LYAZID 5

Dans le champ Queue Name, renseigner un nom de votre choix. Et faire un clic sur Create
La page suivante devrait afficher le nom de la queue, ensuite donner le nom de la queue dans le champ :
Queue Name

Faire un clic sur sendTo (figure suivante)

Observer le nombre d’informations pouvant être renseignées.


Ecrire un message à envoyer dans la partie Message body

Faire un clic sur send


S.LYAZID 6

Faire un clic sur Q1 (ce nom peut être différent en fonction de ce que vous avez donné lors de la création
de votre queue)

Ensuite faire un clic sur ID :…..


S.LYAZID 7

Application JMS avec eclipse.


Dans ce qui suit, nous allons utiliser l’IDE Eclipse pour concevoir une application Java basée sur le
Broker ActiveMQ.
Étape 1. Lancer ActiveMQ si ce n’est pas déjà fait
Étape 2. Vérifier à partir de votre navigateur qu’ActiveMQ est lancé.
Étape 3. Lancer votre IDE tel qu’Eclipse.
Créer un projet Java, dans cet exemple, le projet se nomme tp1JMS. Créer une classe nommée Producer
dans un package nommé package com.bba;
Ajouter ce code :

public static void main(String[] args) {


ConnectionFactory connectionFactory;
Connection connection = null;
Session session = null;
Destination destination;
Message message;
boolean useTransaction = false;
MessageProducer producer = null;
try {
connectionFactory = new ActiveMQConnectionFactory();
String link = ActiveMQConnection.DEFAULT_BROKER_URL;
// localhost:61616
connection = connectionFactory.createConnection();
connection.start();
session = connection.createSession(useTransaction,
Session.AUTO_ACKNOWLEDGE);
destination = session.createQueue("MyfirstQueuewithEclipse");
producer = session.createProducer(destination);
message = session.createTextMessage("This is my first message....");
producer.send(message);
} catch (JMSException jmsEx) {
} finally {
try {
producer.close();
session.close();
connection.close();
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

Il faut ajouter le fichier jar ActiveMQ à votre application tp1JMS comme indiquer sur la figure
suivante. Vous avez appris forcément comment ajouter un fichier jar, soit directement à partir de build
Path ou en à partir d’une librairie de USER. Le fichier jar se trouve dans le répertoire :
S.LYAZID 8

Il faut faire un clic sur chaque sur chaque et importer le package adéquat.
S.LYAZID 9

A la fin, vous devez importer les packages suivants :


import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

+
A partir d’eclipse vous allez vous connecter au broker et créer une queue nommée
MyfirstQueuewithEclipse

Exécuter le code de dans la classe java


S.LYAZID 10

Faire un clic sur Queues dans ActiveMq vous devez vérifier que la queue est créée

Faire un double clic pour se rendre au contenu du message envoyé.

Dans ce qui suit nous allons lire le message à partir d’une application java.
Créer un projet Java, ensuite créer une classe Consumer dans un package com.bba ;
Copier le code suivant :

public static void main(String[] args) {


ConnectionFactory connectionFactory = null;
Connection connection = null;
Session session = null;
S.LYAZID 11

Destination destination;
MessageConsumer consumer = null;
TextMessage message;
boolean useTransaction = false;
try {
connectionFactory = new ActiveMQConnectionFactory();
destination = new ActiveMQQueue("MyfirstQueuewithEclipse");
connection = connectionFactory.createConnection();
connection.start();
session = connection.createSession(useTransaction,
Session.AUTO_ACKNOWLEDGE);
consumer = session.createConsumer(destination);
message = (TextMessage) consumer.receive();
System.out.println("Received message: " + message);
} catch (JMSException jmsEx) {
} finally {
try {
consumer.close();
session.close();
connection.close();
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

Importer le fichier jar ActiveMQ à partir de la librairie créée précédemment, de mon côté j’ai donné le
nom MQLibrary.

Exécuter le code de la classe, vous devez obtenir la console eclipse suivante :


S.LYAZID 12

Aller à la fin de la console, vous allez visualiser le message envoyé à partir de la classe Producer.

Actualiser le navigateur, le broker vous informe que le message a été retiré de la queue. Cette information
est donnée par l’onglet : Messages Enqueued (figure suivante)

Concumer.java
Exécuter le code de la classe , aucune information n’est obtenue car le message est déjà
lu.
S.LYAZID 13

Essayer de rentrer un nouveau message via le broker, cette fois-ci vous allez visualiser sur eclipse le
message envoyé dans le broker sans réexécuté le code de la classe. En effet, le consommateur côté eclipse
était en attente d’un message.

Topic Application.
Dans cette application, vous allez créer un Topic (implémenter le principe publich/subscribe). Il
s’agit ici d’envoyer un seul message, plusieurs consommateurs peuvent recevoir le même message. Pour
ce faire, créer un projet java. Puis, créer une classe java et copier le même code de Producer. Dans ce
nouveau code, il faut modifier la ligne :
destination = session.createQueue("MyfirstQueuewithEclipse"); par la ligne

suivante :
destination = session.createTopic("TopicwithEclipse");

 On veut créer un Topic à la place de Queue.


 Ensuite exécuter le code de la classe.
 Aller dans le navigateur où ActiveMQ est lancé. Vous devez visualiser à la fin de la page votre
Topic nommé TopicwithEclipse
S.LYAZID 14

Si vous lancez plusieurs consommateurs dans eclipse, alors ils vont tous recevoir le même message. Par
conter avec Queue, un seul va recevoir le message , voir les deux figures juste après.

Tous les souscripteurs reçoivent le même message

Par contre la figure suivante montre le principe principe point-to-point (Queue), où un seul
processus reçoit un message. Remarquer que le processus qui a reçu le message meurt, figure A, et que
les autres sont encore en attente de message (les points (voyants) rouge indiquent que les processus sont
actifs, tandis que le premier est éteint). Ainsi, envoyer un autre message permettra à un seul processus
parmi les trois restant d’intercepter le message (voir la figure B).

Figure A 1
S.LYAZID 15

Figure B 1

Dans ce qui suit vous allez apprendre à réaliser une application pour gérer les capteurs de
manières asynchrone via le protocole JMS.
Pour comprendre le but du travail ci-après, il faut remarquer que lors de l’exécution du code ci-dessous,
tous souscripteur (subscriber) s’arrête (meurt) une fois qu’il reçoit le message. En principe ce cas ne
devrait pas se produire. Pour ce faire, vous devrez faire ce qui suit :
1- Créer un listener
2- Pour les besoins de ce test, créer un objet java sérialisé a échangé via le réseau
Les deux points ci-dessus sont réalisé dans le code des classes suivantes. Dans un premier temps,
commencer à créer un package nommé listener.mq dans un nouveua projet java (vous pouvez donner le
nom qui vous convient), ensuite copier les classes avec le code. Ne pas oublier surtout d’importer la
librairie:
package listener.mq;

import java.io.Serializable;

public class MyMsg implements Serializable {


private static final long serialVersionUID = -7670265615867065220L;

private String texte;

public String getTexte() {


return texte;
}
public void setTexte(String texte) {
this.texte = texte;
}
}
S.LYAZID 16

package listener.mq;

import java.util.Properties;

import javax.jms.JMSException;
import javax.jms.Topic;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQTopic;

public class ClientTopListener {

private Topic mycanal;


private TopicSubscriber tcon;
private ActiveMQTopic destination;

public ClientTopListener(int clientNumber) {


try {
Properties props = new Properties();
props.setProperty(Context.INITIAL_CONTEXT_FACTORY,
"org.apache.activemq.jndi.ActiveMQInitialContextFactory");
props.setProperty(Context.PROVIDER_URL, "tcp://localhost:61616");
InitialContext initialctx = new InitialContext(props);
ActiveMQConnectionFactory factory = new
ActiveMQConnectionFactory("tcp://localhost:61616");
// cette instruction est pour autoriser la désérialization ObjectMessage.getObject()
factory.setTrustAllPackages(true);
javax.jms.TopicConnection conn = factory.createTopicConnection();
destination = new ActiveMQTopic("TopicListener");
javax.jms.TopicSession session = conn.createTopicSession(false,
TopicSession.AUTO_ACKNOWLEDGE);
tcon = session.createSubscriber(destination);
subs();
conn.start();
System.out.println("je suis le client #" + clientNumber);
} catch (NamingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public void subs() {


try {

tcon.setMessageListener(new ConsumerMsgListener());
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

public static void main(String[] args) throws InterruptedException {


new ClientTopListener(1);

}
}
S.LYAZID 17

package listener.mq;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import org.apache.activemq.ActiveMQConnectionFactory;
public class ProducerViaTopicLitener {
ActiveMQConnectionFactory connectionFactory;
Connection connection = null;
Session session = null;
Destination destination;
Message message;
boolean useTransaction = false;
MessageProducer producer = null;
public ProducerViaTopicLitener () {
try {
connectionFactory = new ActiveMQConnectionFactory();
connection = connectionFactory.createConnection();
connection.start();
session = connection.createSession(useTransaction, Session.AUTO_ACKNOWLEDGE);
destination = session.createTopic("TopicListener");
producer = session.createProducer(destination);
publish();
} catch (JMSException jmsEx) {
} finally {
try {
producer.close();
session.close();
connection.close();
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public void publish() throws JMSException {
BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));

String ligne = null;

while (true) {
System.out.println("Saisir votre texte:");
try {
MyMsg msg = new MyMsg();
ligne = entree.readLine();
msg.setTexte(ligne);
ObjectMessage _message = session.createObjectMessage(msg);
producer.send(_message);

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

}
}

public static void main(String[] args) {


new ProducerViaTopicLitener ();
}
}
S.LYAZID 18

package listener.mq;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;

public class ConsumerMsgListener implements MessageListener{

@Override
public void onMessage(Message message) {
ObjectMessage myobject=(ObjectMessage) message;
MyMsg mess = null;
try {

mess = (MyMsg) myobject.getObject();


System.out.println(" message received :" +mess.getTexte());
} catch (JMSException e) {
e.printStackTrace();
}
}
}

Une fois que le code compile. Lire listing de chaque classe pour y essayer de comprendre un peu (nous
allons vois le détail pendant les séances de TPs).
Remarque : pour des raisons de sécurité, si vous retirer la ligne
factory.setTrustAllPackages(true);
dans la classe ClientTopListener, alors l’échange d’Objet java même sérialisé
ne sera pas autorisé (pour plus de détails voir lien :
https://activemq.apache.org/objectmessage

Avant d’exécuter le code, il faut ouvrir le fichier wrapper.conf qui se trouve apache-activemq-
5.16.3\bin\win64 (si ‘os est 64, sinon ouvrir celui qui est dans apache-activemq-5.16.3\bin\win32)
Ajouter la ligne suivante :
wrapper.java.additional.13=-Dorg.apache.activemq.SERIALIZABLE_PACKAGES="*"

 Ouvrir le navigateur, je suppose que le broker ActiveMq est lancé.


 Exécuter la classe ClientTopListener (2 ,3 ,… comme vous le souhaitez)
S.LYAZID 19

 Exécuter une seconde fois la classe ClientTopListener


 Exécuter ensuite la classe ProducerViaTopicLitener
Dans la console dédiée à la classe à ProducerViaTopicLitener , essayer d’écrire des lignes de textes (à
chaque validation, les clients vont recevoir les lignes saisies), voir figure suivante :

Travail à faire :
1- Arrêter les processus dans eclispe
2- Aller sur le navigateur est supprimer TopicListener. Pour
ce faire, sélectionner delete dans l’onglet Operations
3- Ensuite exécuter la classe ProducerViaTopicLitener.
Saisir ensuite dans la console le texte suivant : Ceci est
mon premier message.
4- Exécuter la classe ClientTopListener (2 ,3 ,… comme
vous le souhaitez)
5- Qu’est-ce que vous remarquez ?
6- Saisir le texte : Ceci est mon second message
dans la console de ProducerViaTopicLitener comme le
montre la figure suivante
Question : le premier message n’a pas été récupéré, tous les clients ont raté ce message. Proposez
une solution pour résoudre ce problème ?
S.LYAZID 20

7- Dans les exemples ci-dessus, nous avons des clients qui écoutent soient sur une Queue ou Topic,
Question : on vous demande de créer un client qui écoute sur une Queue en mode Listener et
Topic Listener.
Question : Supprimer un message après un certain temps si aucun client ne récupère le message.
Question : Créer un client qui se connecte, se déconnecte et se reconnecte une seconde fois.
Alors ce client ne devrait pas perdre tous les messages qui lui sont destinés ?

Vous aimerez peut-être aussi