Partager via

Utiliser Java Message Service 2.0 avec Azure Service Bus Premium

  • Article

Cet article explique comment utiliser l’API Java Message Service (JMS) 2.0 bien connue pour interagir avec Azure Service Bus via le protocole AMQP (Advanced Message Queueing Protocol) 1.0.

Remarque

La prise en charge de l’API JMS (Java Message Service) 2.0 est uniquement disponible au niveau Premium.>

Prérequis

Prise en main de Service Bus

Ce guide présuppose que vous disposez déjà d’un espace de noms Service Bus. Dans le cas contraire, créez un espace de noms et une file d’attente à l’aide du portail Azure. Pour plus d’informations sur la création d’espaces de noms et de files d’attente Service Bus, consultez Prise en main des files d’attente Service Bus sur le portail Azure.

Configurer un environnement de développement Java

Pour développer des applications Java, vous devez configurer l’environnement de développement approprié :

  • Soit le kit JDK (Java Development Kit), soit l’environnent JRE (Java Runtime Environment) est installé.
  • Le kit JDK ou l’environnement JRE est ajouté au chemin du build et aux variables système appropriées.
  • Un environnement de développement intégré Java (Java IDE) est installé pour utiliser le kit JDK ou l’environnement JRE. Par exemple Eclipse ou IntelliJ.

Pour en savoir plus sur la préparation de votre environnement de développement pour Java sur Azure, utilisez ce guide.

Quelles sont les fonctionnalités JMS prises en charge ?

Le tableau suivant présente les fonctionnalités Java Message Service (JMS) actuellement prises en charge par Azure Service Bus. Il présente également des fonctionnalités non prises en charge.

Fonctionnalité API Statut
Files d’attente
  • JMSContext.createQueue( String queueName)
Pris en charge
Rubriques
  • JMSContext.createTopic( String topicName)
Pris en charge
Files d’attente temporaires
  • JMSContext.createTemporaryQueue()
Pris en charge
Rubriques temporaires
  • JMSContext.createTemporaryTopic()
Pris en charge
Producteur de messages /
JMSProducer
  • JMSContext.createProducer()
Pris en charge
Explorateurs de files d'attente
  • JMSContext.createBrowser(Queue queue)
  • JMSContext.createBrowser(Queue queue, String messageSelector)
Pris en charge
Consommateur de messages/
JMSConsumer
  • JMSContext.createConsumer( Destination destination)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

noLocal n'est actuellement pas pris en charge		 Pris en charge
Abonnements durables partagés
  • JMSContext.createSharedDurableConsumer(Topic topic, String name)
  • JMSContext.createSharedDurableConsumer(Topic topic, String name, String messageSelector)
Pris en charge
Abonnements durables non partagés
  • JMSContext.createDurableConsumer(Topic topic, String name)
  • createDurableConsumer(Topic topic, String name, String messageSelector, boolean noLocal)

noLocal n'est actuellement pas pris en charge et doit être défini sur false		 Pris en charge
Abonnements non durables partagés
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector)
Pris en charge
Abonnements non durables non partagés
  • JMSContext.createConsumer(Destination destination)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

noLocal n'est actuellement pas pris en charge et doit être défini sur false		 Pris en charge
Sélecteurs de messages dépend du consommateur créé Pris en charge
Délai de livraison (messages planifiés)
  • JMSProducer.setDeliveryDelay( long deliveryDelay)
Pris en charge
Message créé
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Serializable object)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( String text)
Pris en charge
Transactions entre entités
  • Connection.createSession(true, Session.SESSION_TRANSACTED)
Pris en charge
Transactions distribuées Non pris en charge

Téléchargement de la bibliothèque de client Java Message Service (JMS)

Pour utiliser toutes les fonctionnalités disponibles au niveau Premium, ajoutez la bibliothèque suivante au chemin de build du projet : azure-servicebus-jms. Ce package fournit certaines valeurs par défaut nécessaires, comme les valeurs de la stratégie de prérécupération, les stratégies de reconnexion, Microsoft Entra et la prise en charge intégrée de l’identité managée.

Remarque

Pour ajouter azure-servicebus-jms au chemin de build, utilisez l’outil de gestion des dépendances préféré pour votre projet, par exemple Maven ou Gradle.

Codage d’applications Java

Une fois les dépendances importées, les applications Java peuvent être écrites d’une façon indépendante du fournisseur JMS.

Connexion à Azure Service Bus avec JMS

Pour vous connecter à Azure Service Bus à l’aide de clients JMS, il vous faut la chaine de connexion, disponible dans les « stratégies d’accès partagé » dans le Portail Azure sous Chaîne de connexion principale.

  1. Instanciez le ServiceBusJmsConnectionFactorySettings

    ServiceBusJmsConnectionFactorySettings connFactorySettings = new ServiceBusJmsConnectionFactorySettings();
connFactorySettings.setConnectionIdleTimeoutMS(20000);

  2. Instanciez le ServiceBusJmsConnectionFactory avec le ServiceBusConnectionString approprié.

    String ServiceBusConnectionString = "<SERVICE_BUS_CONNECTION_STRING_WITH_MANAGE_PERMISSIONS>";
ConnectionFactory factory = new ServiceBusJmsConnectionFactory(ServiceBusConnectionString, connFactorySettings);

  3. Utilisez le ConnectionFactory pour créer un Connection puis un Session

    Connection connection = factory.createConnection();
Session session = connection.createSession();

    ou un JMSContext (pour les clients JMS 2.0)

    JMSContext jmsContext = factory.createContext();

    Important

    Bien qu’elles portent le même nom, une « session » JMS et une « session » Service Bus sont complètement indépendantes l’une de l’autre.

    Dans JMS 1.1, la session est un module essentiel de l’API. Elle permet la création de MessageProducer, de MessageConsumer et de Message. Pour plus d’informations, consultez le Modèle de programmation de l’API JMS

    Dans Service Bus, les sessions sont des constructions côté service et côté client qui permettent d’activer le traitement FIFO sur les files d’attente et les abonnements.

Écrire l’application JMS

Une fois que Session ou JMSContext a été instancié, votre application peut utiliser les API JMS bien connues pour effectuer des opérations de gestion et de données. Reportez-vous à la liste des fonctionnalités JMS prises en charge pour connaître les API prises en charge. Voici quelques exemples d’extraits de code pour bien démarrer avec JMS.

Envoi de messages à une rubrique et une file d'attente

// Create the queue and topic
Queue queue = jmsContext.createQueue("basicQueue");
Topic topic = jmsContext.createTopic("basicTopic");
// Create the message
Message msg = jmsContext.createMessage();

// Create the JMS message producer
JMSProducer producer = jmsContext.createProducer();

// send the message to the queue
producer.send(queue, msg);
// send the message to the topic
producer.send(topic, msg);

Réception de messages à partir de la file d'attente

// Create the queue
Queue queue = jmsContext.createQueue("basicQueue");

// Create the message consumer
JMSConsumer consumer = jmsContext.createConsumer(queue);

// Receive the message
Message msg = (Message) consumer.receive();

Réception de messages d’un abonnement durable partagé sur une rubrique

// Create the topic
Topic topic = jmsContext.createTopic("basicTopic");

// Create a shared durable subscriber on the topic
JMSConsumer sharedDurableConsumer = jmsContext.createSharedDurableConsumer(topic, "sharedDurableConsumer");

// Receive the message
Message msg = (Message) sharedDurableConsumer.receive();

Résumé

Ce guide vous a présenté les différentes interactions possibles entre Azure Service Bus et les applications clientes Java utilisant Java Message Service (JMS) avec AMQP 1.0.

Vous pouvez également utiliser l'AMQP 1.0 de Service Bus depuis d'autres langages, notamment .NET, C, Python et PHP. Les composants intégrés avec ces différents langages peuvent échanger des messages de manière fiable et fidèle en utilisant le support AMQP 1.0 dans Service Bus.

Contenu connexe