Le tant attendu Java EE 7 est finalement arrivé et avec lui JMS 2.0, la première évolution de JMS en plus d'une décade.
Le plus notable dans les nouvelles spécifications JMS est l'expressivité optimale de ce qu'Oracle appelle l'API "Simplifiée". Par exemple, la nouvelle API pour envoyer et recevoir des messages élimine la plupart du code inutile et réduit de manière importante le nombre de lignes de code nécessaires. Si vous utilisez un serveur d'applications, la nouvelle API supporte l'injection de dépendances, ce qui permet au serveur de gérer les objets JMS et de fait simplifie encore l'application.
Le framework est complètement rétro-compatible, de telle sorte que vous êtes libre d'utiliser votre code historique tout en implémentant l'API Simplifiée pour votre nouveau code. Il n'existe pas de volonté de déprécier l'ancienne API.
JMS 2.0 fait partie de la plateforme Java EE 7, mais peut également être utilisée sur une plateforme Java SE, bien que toutes les fonctionnalités ne soient pas disponibles dans les 2 cas.
Comparons quelques extraits de code qui utilisent l'ancienne et la nouvelle API.
Listing 1. Syntaxe JMS 1.0 pour envoyer un message
1 public void sendMessage(ConnectionFactory factory,
Queue queue, String message) {
2 try {
3 Connection connection =
factory.createConnection();
4 try {
5 Session session = connection.createSession(
false, Session.AUTO_ACKNOWLEDGE);
6 MessageProducer messageProducer
= session.createProducer(queue);
7 TextMessage textMessage
= session.createTextMessage(message);
8
9 messageProducer.send(textMessage);
10
11 } finally {
12 connection.close();
13 }
14 } catch (JMSException e) {
15 // handle exception
16 }
17 }
Listing 2. Syntaxe JMS 2.0 Syntax pour envoyer le même Message
18 public void sendMessage(ConnectionFactory factory,
Queue queue, String message) {
19 try (JMSContext context
= factory.createContext()) {
20
21 context.createProducer().send(queue, message);
22
23 } catch (JMSRuntimeException e) {
24 // handle exception
25 }
26 }
Analysons les différences. Premièrement, nous utilisons le "try-with-resources" de Java 7 à la ligne 19. Le nouveau JMSContext AutoCloseable remplace à la fois l'ancienne classe Connection et la classe Session. Lorsqu'il est inclus dans une clause try (ligne 19), l'intégralité de la mise en place du code "try" original est évité (lignes 4, 11, 12 et 13). La création du message est également maintenant implicite, de telle sorte que le code produit est une version allégée du code original.
De plus, l'ancienne exception vérifiée JMSException est maintenant remplacée par l'exception non-vérifiée JMSRuntimeException de telle sorte qu'il n'y ait plus besoin de la gérer explicitement.
Il s'agit de code d'envoi de message. Le code de réception est également concis.
L'API Simplifiée ne constitue qu'une partie de la nouvelle API JMS 2.0. Il existe en sus quelques améliorations sémantiques. Les fonctionnalités suivantes sont maintenant supportées :
- Mode d'envoi asynchrone - A la différence du mode classique synchrone qui bloque jusqu'à ce qu'un acquittement soit envoyé depuis le serveur, le mode asynchrone retourne immédiatement sans bloquer. Une fois l'acquittement reçu, une méthode de rappel asynchrone est invoquée. Le mode asynchrone est supporté à la fois sur le nouveau JMSProducer et son alter-ego historique MessageProducer. Par exemple, votre application peut définir un CompletionListener avec l'interface suivante :
public interface CompletionListener {
void onCompletion(Message message);
void onException(Message message, Exception exception);
}
Lors de l'envoi du message, vous appelez
messageProducer.send(message,completionListener);
- Remise retardée de message - Permet à un client JMS de planifier la remise future d'un message en fournissant le support pour le traitement différé, comme la fin de la journée. L'application peut indiquer le temps minimum en millisecondes de conservation du message par le système avant la remise à un consommateur. L'API est identique pour MessageProducer et JMSProducer :
Pour MessageProducer:
public void setDeliveryDelay(long deliveryDelay)
Pour JMSProducer:
public JMSProducer setDeliveryDelay(long deliveryDelay)
- Le partage de l'abonnement au même sujet permet la consommation scalable de messages provenant de cet abonnement. De nouvelles méthodes sont fournis pour les abonnements temporaires
MessageConsumer messageConsumer = session.
createSharedConsumer(topic,sharedSubscriptionName);
La méthode actuelle est utilisée pour les abonnements durables
MessageConsumer messageConsumer = session.
createDurableConsumer(topic,durableSubscriptionName);
Il ne s'agit que de quelques-unes des nombreuses nouvelles fonctionnalités. Vous pouvez suivre un tutoriel détaillé avec l'intégralité des extraits de code dans l'article OTN "What's New in JMS 2.0".