Entités Java message service (JMS) 2.0

Les applications clientes se connectant à Azure Service Bus Premium et utilisant la bibliothèque JMS Azure Service Bus peuvent se servir des entités ci-dessous.

Files d’attente

Les files d’attente dans JMS sont sémantiquement comparables aux files d’attente Service Bus traditionnelles.

Pour créer une file d’attente, utilisez les méthodes ci-dessous dans la classe JMSContext :

Queue createQueue(String queueName)

Rubriques

Les rubriques dans JMS sont sémantiquement comparables aux files d’attente Service Bus traditionnelles.

Pour créer une rubrique, utilisez les méthodes ci-dessous dans la classe JMSContext :

Topic createTopic(String topicName)

Files d’attente temporaires

Si une application cliente nécessite une entité temporaire qui existe pendant la durée de vie de l’application, elle peut utiliser des files d’attente temporaires. Ces entités sont utilisées dans le modèle Demande-Réponse.

Pour créer une file d’attente temporaire, utilisez les méthodes ci-dessous dans la classe JMSContext :

TemporaryQueue createTemporaryQueue()

Rubriques temporaires

Tout comme les files d’attente temporaires, des rubriques temporaires permettent la publication/l’abonnement via une entité temporaire qui existe pendant la durée de vie de l’application.

Pour créer une rubrique temporaire, utilisez les méthodes ci-dessous dans la classe JMSContext :

TemporaryTopic createTemporaryTopic()

JMS (Java Message Service) et abonnements

Bien qu’elles soient sémantiquement similaires aux Abonnements (qui, en fait, existent sur une rubrique et activent la sémantique de publication/abonnement), les spécifications de Java Message Service présentent les concepts d’attributs Partagé, Non partagé, **Durable et Non durable pour un abonnement donné.

Abonnements durables partagés

Un abonnement durable partagé est utilisé lorsque tous les messages publiés sur une rubrique doivent être reçus et traités par une application, que l’application consomme ou non activement l’abonnement à tout moment.

Toute application authentifiée pour recevoir des messages de Service Bus peut en recevoir de l’abonnement durable partagé.

Pour créer un abonnement durable partagé, utilisez les méthodes ci-dessous sur la classe JMSContext –

JMSConsumer createSharedDurableConsumer(Topic topic, String name)

JMSConsumer createSharedDurableConsumer(Topic topic, String name, String messageSelector)

L’abonnement durable partagé continue à exister, sauf s’il est supprimé à l’aide de la méthode unsubscribe sur la classe JMSContext.

void unsubscribe(String name)

Abonnements durables non partagés

À l’instar d’un abonnement durable partagé, un abonnement durable non partagé est utilisé lorsque tous les messages publiés sur une rubrique doivent être reçus et traités par une application, que l’application consomme ou non activement l’abonnement.

Toutefois, étant donné qu’il s’agit d’un abonnement non partagé, seule l’application qui a créé l’abonnement peut recevoir des messages de ce dernier.

Pour créer un abonnement durable non partagé, utilisez les méthodes ci-dessous à partir de la classe JMSContext –

JMSConsumer createDurableConsumer(Topic topic, String name)

JMSConsumer createDurableConsumer(Topic topic, String name, String messageSelector, boolean noLocal)

L’abonnement durable non partagé continue à exister, sauf s’il est supprimé à l’aide de la méthode unsubscribe sur la classe JMSContext.

void unsubscribe(String name)

Abonnements non durables partagés

Un abonnement partagé non durable est utilisé lorsque plusieurs applications clientes doivent recevoir et traiter des messages d’un seul abonnement, uniquement jusqu’à ce qu’ils les consomment/les reçoivent activement.

Étant donné que l’abonnement n’est pas durable, il n’est pas persistant. Les messages ne sont pas reçus par cet abonnement lorsqu’il n’y a aucun consommateur actif.

Pour créer un abonnement partagé non durable, créez un JmsConsumer comme indiqué dans les méthodes ci-dessous de la classe JMSContext –

JMSConsumer createSharedConsumer(Topic topic, String sharedSubscriptionName)

JMSConsumer createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector)

L’abonnement partagé non durable continue d’exister jusqu’à ce qu’il y ait des consommateurs actifs qui le reçoivent.

Abonnements non durables non partagés

Un abonnement non partagé non durable est utilisé lorsque l’application cliente doit recevoir et traiter des messages d’un seul abonnement, uniquement jusqu’à ce qu’elle les consomme/les reçoive activement. Un seul consommateur peut exister sur cet abonnement, autrement dit le client qui a créé l’abonnement.

Étant donné que l’abonnement n’est pas durable, il n’est pas persistant. Les messages ne sont pas reçus par cet abonnement lorsqu’il n’y a aucun consommateur actif.

Pour créer un abonnement non-partagé non durable, créez un JMSConsumer comme indiqué dans les méthodes ci-dessous de la classe JMSContext –

JMSConsumer createConsumer(Destination destination)

JMSConsumer createConsumer(Destination destination, String messageSelector)

JMSConsumer createConsumer(Destination destination, String messageSelector, boolean noLocal)

L’abonnement non partagé non durable continue d’exister jusqu’à ce qu’il y ait un consommateur actif qui le reçoit.

Sélecteurs de messages

À l’instar des filtres et actions qui existent pour les abonnements Service Bus standard, les sélecteurs de messages existent pour les abonnements JMS.

Les sélecteurs de messages peuvent être configurés sur chacun des abonnements JMS et exister sous la forme d’une condition de filtre sur les propriétés d’en-tête de message. Seuls les messages avec des propriétés d’en-tête correspondant à l’expression du sélecteur de messages sont remis. La valeur Null ou une chaîne vide indique qu’il n’existe aucun sélecteur de message pour l’abonnement/le consommateur JMS.

Concepts supplémentaires pour les abonnements Java Message Service (JMS) 2.0

Étendue du client

Les abonnements, tels qu’ils sont spécifiés dans l’API Java Message Service (JMS) 2.0, peuvent être ou non étendus à une ou à des applications clientes spécifiques (identifiées avec l’élément clientId approprié).

Une fois l’abonnement délimité, il n’est accessible qu’à partir d’applications clientes qui ont le même ID client.

Toute tentative d’accès à un abonnement délimité sur un ID client particulier (par exemple, clientId1) depuis une application ayant un autre ID client (par exemple, clientId2) entraîne la création d’un autre abonnement délimité sur l’autre ID client (clientId2).

Partageabilité

Les abonnements partagés permettent à plusieurs clients/consommateurs (autrement dit, des objets JMSConsumer) de recevoir les messages qu’ils envoient.

Les abonnements non partagés n’autorisent qu’un seul client/consommateur (c’est-à-dire l’objet JMSConsumer) à recevoir les messages qu’ils envoient. Si un objet JMSConsumer est créé sur un abonnement non partagé alors qu’il a déjà une écoute JMSConsumer active des messages qu’il contient, une exception JMSException est déclenchée.

Durabilité

Les abonnements durables sont conservés et continuent à collecter des messages à partir de la rubrique, qu’une application (JMSConsumer) consomme ou non des messages à partir de celle-ci.

Les abonnements non durables ne sont pas rendus persistants et recueillent des messages à partir de la rubrique tant qu’une application (JMSConsumer) utilise des messages de celle-ci.

Représentation d’abonnements étendus aux clients

Étant donné que les abonnements (JMS) étendus aux clients doivent coexister avec les abonnements existants, la façon dont les abonnements étendus aux clients (JMS) sont représentés suit le format ci-dessous.

• <NOM-ABONNEMENT>$<ID-CLIENT>$D (pour les abonnements durables)
• <NOM-ABONNEMENT>$<ID-CLIENT>$ND (pour les abonnements non durables)

Ici, $ est le délimiteur.

Étapes suivantes

Pour plus d’informations et des exemples d’utilisation de la messagerie Service Bus, consultez les rubriques avancées suivantes :

• Présentation de la messagerie Service Bus
• Utiliser Java Message Service 2.0 avec Azure Service Bus Premium