Spring met à votre disposition 2 dispositifs rendant l’utilisation de JMS très simple :

- JmsTemplate : gère la connexion vers le serveur déclaré et l’envoi des données

- SimpleMessageListenerContainer : assure la réception des messages et l’appel à votre classe en charge de traiter la réception des objets.

1ère étape : déclaration du serveur

Dans un fichier xml de configuration Spring, insérez ces lignes (dans notre exemple, il s’agit de la déclaration des 2 serveurs ActiveMQ locaux) :

    <!-- ActiveMQ Sender -->
    <bean id="connectionFactorySender" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://localhost:61616"/>
    </bean>

    <!-- ActiveMQ Receiver -->
    <bean id="connectionFactoryListener" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://localhost:61616"/>
    </bean>

ainsi que la déclaration de la queue qui sera utilisée pour nos échanges de messages :

    <bean id="categs_backup_queue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg value="categs_backup"/>
    </bean>

2ème étape : gestion de l’émission des messages

Dans notre exemple, nous échangerons des POJOs représentants des catégories afin de les sauvegarder sur un autre serveur.

Voici l’implémentation de la classe servant à envoyer ces messages :

public class CategorieBackupSenderImpl implements CategorieBackupSender {
    private JmsTemplate jmsTemplate;
    private Queue queue;

    @Required
    public void setConnectionFactory(ConnectionFactory cf) {
        this.jmsTemplate = new JmsTemplate(cf);
    }

    @Required
    public void setQueue(Queue queue) {
        this.queue = queue;
    }

    /* (non-Javadoc)
     * @see com.bp.jms.CategorieBackupSender#simpleSend()
     */
    public void send(final Categorie categ) {
        this.jmsTemplate.send(this.queue, new MessageCreator() {
            public ObjectMessage createMessage(Session session) throws JMSException {
              return (ObjectMessage) session.createObjectMessage(categ);
            }
        });
    }
}

Les deux setters servent à Spring pour renseigner les propriétés nécessaires au bon fonctionnement de cette classe : le template (JmsTemplate) qui utilise la connexion au serveur JMS (ConnectionFactory) et la queue (Queue).

La méthode Send fait appel au template pour créer le message à partir de notre POJO via la classe MessageCreator.

Il nous reste à déclarer ce composant dans le XML de configuration Spring :

    <bean id="categorieBackupSender" class="com.bp.categories.jms.impl.CategorieBackupSenderImpl">
        <property name="connectionFactory" ref="connectionFactorySender"/>
        <property name="queue" ref="categs_backup_queue"/>
    </bean>

C’est tout pour l’émission des messages ! La bonne nouvelle c’est que la réception n’est guère plus compliquée

3è étape : gestion de la réception des messages

Voici la classe gérant cette réception :

public class CategorieBackupListener implements MessageListener {

    private CategorieService categorieService;

    /**
     * @param categorieService the categorieService to set
     */
    @Required
    public void setCategorieService(CategorieService categorieService) {
        this.categorieService = categorieService;
    }

    public void onMessage(Message message) {
        if (message instanceof ObjectMessage) {
            try {
                Categorie categ = (Categorie) ((ObjectMessage) message).getObject();
                categorieService.backup(categ);
            }
            catch (JMSException ex) {
                throw new RuntimeException(ex);
            }
        }
        else {
            throw new IllegalArgumentException("Message must be of type ObjectMessage");
        }
    }
}

Le source est assez parlant de lui-même. Suite à la réception du message, le service CategorieService est appelé afin d’effectuer le traitement approprié.

De même que pour l’émission, la configuration Spring est importante…

    <bean id="categorieBackupListener" class="com.bp.categories.jms.CategorieBackupListener">
        <property name="categorieService" ref="categorieService" />
    </bean>

    <bean id="listener" class="org.springframework.jms.listener.SimpleMessageListenerContainer">
       <property name="connectionFactory" ref="connectionFactoryListener"/>
       <property name="destination" ref="categs_backup_queue"/>
       <property name="concurrentConsumers" value="3"/>
       <property name="messageListener" ref="categorieBackupListener"/>
    </bean>

Bien entendu dans cet exemple nous échangeons des POJOs reconnus par JMS comme simple Object. Il est possible d’améliorer tout ça, ne serait-ce que pour s’assurer que l’objet reçu est bien l’objet attendu ou aussi pour échanger des objets de différents types en utilisant la même queue.

4ème étape : fonctionnement de notre exemple

Nous devons déclarer nos deux beans :

        categorieService = (CategorieService) Context.getContext().getBean("categorieService");
        categorieBackupSender = (CategorieBackupSender) Context.getContext().getBean("categorieBackupSender");

puis la récupération de nos objets et leur envoi :

        List<Categorie> categs = categorieService.getCategs();
        if (categs != null) {
            for (Categorie categ: categs) {
                categorieBackupSender.send(categ);
            }
        }

La réception se met en route automatique dès l’instanciation du listener.

Si vous voulez contrôler le fonctionnement du listener, alors il faut déclarer un troisième bean :

        listener = ((SimpleMessageListenerContainer) Context.getContext().getBean("listener"));

Voilà, cet exemple ne présente sans doute pas toutes les possibilités que l’on peut faire de JMS avec Spring, mais c’est un bon début