TP4 : Utilisation de JMS et de Message Driven Beans

Faisons marcher l'exemple du cours

Repartez du TP3. Dans la liste des EJBs, ajoutez un Message Driven Bean. Vous suivrez les étapes ci-dessous :

1) Ajouter un message driven bean au projet EJB (celui avec le grain de café)

2) Configurer le bean. On lui donne un nom puis on indique le nom de la Queue de messages (ici "jms/logginMessages"). On indique aussi le type du gestionnaire de messages (Queue).

Le Bean est généré puis ajouté au projet. Le source doit ressembler à cela :

package tp2;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.Message;
import javax.jms.MessageListener;

/**
 *
 * @author michel
 */
@MessageDriven(mappedName = "jms/loggingMessages", activationConfig =  {
        @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
        @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
    })
public class MDBduCours implements MessageListener {
    
    public MDBduCours() {
    }

    public void onMessage(Message message) {
    }
    
}

Dans la méthode onMessage(), mettez le code de l'exemple du cours. Ce Bean doit ressembler à celui-ci une fois terminé: 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package tp2;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

/**
 *
 * @author michel
 */
@MessageDriven(mappedName = "jms/loggingMessages", activationConfig = {
    @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
})
public class MDBduCours implements MessageListener {

    public MDBduCours() {
    }

    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            TextMessage tm = (TextMessage) message;
            try {
                String text = tm.getText();
                System.out.println("Received new message :" + text);
            } catch (JMSException e) {
            }
        }
    }
}

Notez que le nom de la destination est "jms/NewMessage", si vous allez voir dans la console d'administration du serveur d'application après avoir déployé le projet, vous trouverez sous jms/resources sa définition. C'est la même chose que pour les sources de données : on peut déployer de nouveaux Topic ou Queues de messages à la volée. Leur définition est ajoutée (dans le cas de Glassfish) dans le descripteur propriétaire sun-resources.xml :

Vous pouvez jeter un oeil à ce fichier, vous retrouverez la source de données du TP3 ainsi que la définition de la Queue de messages "jms/loggingMessages".

Créez une servlet de test pour ce bean

Vous allez ajouter au projet web une servlet de test, appelez-la par exemple ServletTestMDB. Cette servlet enverra lors de son invocation un message texte à l'EJB précédente. 

Ouvrez le source de la Servlet. Vous retrouvez une Servlet vide classique. On va utiliser un wizard pour insérer du code afin que cette Servlet soit capable d'envoyer un message à la Queue de messages jms/loggingMessages. Rappel : la Servlet ne sait pas que le Message Driven Bean existe, elle se contente juste d'envoyer un message indiquant qu'elle souhaite un traitement.

Avec netbeans, faites dans le source de la servlet, curseur dans la méthode ProcessRequest, bouton de droite / insert code / send JMS Message :

Cela va faire apparaitre un wizard dans lequel vous allez indiquer le nom de la Queue de message dans laquelle vous allez publier :

Cela va générer du code. Etudiez-le ! Essayez de comprendre ce qu'il fait.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package tp2;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Resource;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 *
 * @author michel
 */
public class ServletTestMDB extends HttpServlet {
    @Resource(name = "jms/loggingMessages")
    private Queue loggingMessages;
    @Resource(name = "jms/loggingMessagesFactory")
    private ConnectionFactory loggingMessagesFactory;
   
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        
    } 

    // <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
    /** 
     * Handles the HTTP <code>GET</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    } 

    /** 
     * Handles the HTTP <code>POST</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }

    /** 
     * Returns a short description of the servlet.
     * @return a String containing servlet description
     */
    @Override
    public String getServletInfo() {
        return "Short description";
    }// </editor-fold>

    private Message createJMSMessageForjmsLoggingMessages(Session session, Object messageData) throws JMSException {
        // TODO create and populate message to send
        TextMessage tm = session.createTextMessage();
        tm.setText(messageData.toString());
        return tm;
    }

    private void sendJMSMessageToLoggingMessages(Object messageData) throws JMSException {
        Connection connection = null;
        Session session = null;
        try {
            connection = loggingMessagesFactory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            MessageProducer messageProducer = session.createProducer(loggingMessages);
            messageProducer.send(createJMSMessageForjmsLoggingMessages(session, messageData));
        } finally {
            if (session != null) {
                try {
                    session.close();
                } catch (JMSException e) {
                    Logger.getLogger(this.getClass().getName()).log(Level.WARNING, "Cannot close session", e);
                }
            }
            if (connection != null) {
                connection.close();
            }
        }
    }

}

En particulier, notez que les lignes :

Correspondent aux 4 premières étapes indiquées en cours, que l'on pourrait écrire (en utilisant explicitement JMS) comme ceci :

// 1 Récupération de la factory JMS 
InitialContext ctx = new InitialContext();  
 opicConnectionFactory factory = (TopicConnectionFactory) ctx.lookup("jms/NewMessageFactory");  
	
// 2 Use connection factory to create a JMS connection  
TopicConnection connection = factory.createTopicConnection();   

//3 Use connection to create a session  
TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);   

// 4 Lookup destination    
Topic topic = (Topic) ctx.lookup("jms/NewMessage");

Evidemment, avec les annotations de code c'est plus simple !

Des méthodes utilitaires sont également générées, en particulier la méthode sendJMSMessageToNewMessage qui prend un objet en paramètre (messageData). Regardez ce qu'elle fait... Elle nous mache le travail. Sauf que par défaut elle suppose que le message est un textMessage. Pour la question suivante du TP, vous utilisez un ObjectMessage, il faudra donc légèrement modifier la ligne de création du message.

Regardez également la méthode processRequest. Elle est finalement très concise, pour envoyer un message texte on se contente d'une ligne de code :

Compilez, déployez, testez la servlet de test et vérifiez dans la console du serveur que le message est bien arrivé !

Allez, au boulot ! Faisons une vraie application !

Vous allez maintenant modifier le TP2. Aux fonctionnalités de virement, de création, de modification de solde, vous allez ajouter la notion de "opération bancaire".

Une opération bancaire est une "trace" d'une opération qui a été effectuée sur un compte particulier. Lorsque vous consultez votre compte bancaire sur l'application web de votre banque et que vous examinez les opérations sur un compte, chaque ligne affichée est "opération bancaire".

 En effet, lorsque vous émettez un chèque ou lorsque vous achetez des produits avec votre carte bleue, la banque est contactée et une ligne est ajoutée dans la table des opérations bancaires.

Pour le moment nous n'allons pas utiliser de "relations" au sens des "relations entre tables". On laissera la table des opérations déconnectée de la table des comptes.

 Vous allez juste créer un entity bean OperationBancaire qui permettra d'enregistrer dans une BD des opérations. La table sera créée à partir de la classe du Bean, comme pour le TP 2. Une opération a un numéro (auto-généré), une date, un descriptif (magasin où on a acheté), un type (chèque ou CB ou virement par exemple) et un montant. Le client de ce bean sera un Message Driven Bean.

Sa méthode onMessage() récupère un message de type ObjectMessage qui est en fait une instance d'un objet OperationBancaire et utilise un entity manager pour ajouter les données dans la base. Vous complèterez le bean du TP2 pour qu'il puisse fournir des fonctionalités comme afficher le détail des transactions d'un compte, avec pour paramètre le numéro de compte par exemple. Bien entendu, pour complèter le tableau, vous écrirez les jsps et servlets qu'il manque, clients du Message Driven Bean et du bean gestionnaire de comptes.

Chaque fois qu'une création de compte, qu'un virement, qu'une modification sur un compte est effectuée, on emet un message que le Message Driven Bean traitera (il écrira une ligne de plus dans la table des opérations bancaires).