Freigeben über

Verwenden der Java Message Service 2.0-API mit Azure Service Bus Premium

  • Artikel

Dieser Artikel erläutert die Verwendung der beliebten API JMS 2.0 (Java Message Service) für die Interaktion mit Azure Service Bus über das AMQP (Advanced Message Queueing Protocol) 1.0-Protokoll.

Hinweis

Unterstützung für die Java Message Service (JMS) 2.0-API ist nur im Premium-Tarif verfügbar.>

Voraussetzungen

Erste Schritte mit Service Bus

In diesem Leitfaden wird davon ausgegangen, dass Sie bereits über einen Service Bus-Namespace verfügen. Falls nicht, erstellen Sie einen Namespace und eine Warteschlange über das Azure-Portal. Weitere Informationen zum Erstellen von Namespaces und Warteschlangen für Service Bus finden Sie unter Erste Schritte mit Service Bus-Warteschlangen im Azure-Portal.

Einrichten einer Java-Entwicklungsumgebung

Zum Entwickeln von Java-Anwendungen müssen Sie die entsprechende Entwicklungsumgebung einrichten:

  • Entweder das JDK (Java Development Kit) oder die JRE (Java Runtime Environment) ist installiert.
  • Das JDK oder die JRE wird dem Buildpfad und den entsprechenden Systemvariablen hinzugefügt.
  • Es wird eine Java-IDE installiert, um das JDK oder die JRE zu verwenden. Beispielsweise Eclipse oder IntelliJ.

Weitere Informationen zum Vorbereiten Ihrer Entwicklerumgebung für Java in Azure finden Sie in diesem Handbuch.

Welche JMS-Funktionen werden unterstützt?

In der folgenden Tabelle sind die zurzeit von Azure Service Bus unterstützten JMS-Funktionen (Java Message Service) aufgelistet. Außerdem werden Funktionen angezeigt, die nicht unterstützt werden.

Funktion API Status
Warteschlangen
  • JMSContext.createQueue( String queueName)
Unterstützt
Themen
  • JMSContext.createTopic( String topicName)
Unterstützt
Temporäre Warteschlangen
  • JMSContext.createTemporaryQueue()
Unterstützt
Temporäre Themen
  • JMSContext.createTemporaryTopic()
Unterstützt
Message Producer /
JMSProducer
  • JMSContext.createProducer()
Unterstützt
Warteschlangenbrowser
  • JMSContext.createBrowser(Queue queue)
  • JMSContext.createBrowser(Queue queue, String messageSelector)
Unterstützt
Message Consumer/
JMSConsumer
  • JMSContext.createConsumer( Destination destination)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

„noLocal“ wird zurzeit nicht unterstützt.		 Unterstützt
Freigegebene dauerhafte Abonnements
  • JMSContext.createSharedDurableConsumer(Topic topic, String name)
  • JMSContext.createSharedDurableConsumer(Topic topic, String name, String messageSelector)
Unterstützt
Nicht freigegebene dauerhafte Abonnements
  • JMSContext.createDurableConsumer(Topic topic, String name)
  • createDurableConsumer(Topic topic, String name, String messageSelector, boolean noLocal)

„noLocal“ wird zurzeit nicht unterstützt und sollte auf „false“ festgelegt werden.		 Unterstützt
Freigegebene nicht dauerhafte Abonnements
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector)
Unterstützt
Nicht freigegebene nicht dauerhafte Abonnements
  • JMSContext.createConsumer(Destination destination)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

„noLocal“ wird zurzeit nicht unterstützt und sollte auf „false“ festgelegt werden.		 Unterstützt
Nachrichtenselektoren Abhängig vom erstellten Consumer. Unterstützt
Tägliche Zustellung (geplante Nachrichten)
  • JMSProducer.setDeliveryDelay( long deliveryDelay)
Unterstützt
Nachricht erstellt
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Serializable object)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( String text)
Unterstützt
Entitätsübergreifende Transaktionen
  • Connection.createSession(true, Session.SESSION_TRANSACTED)
Unterstützt
Verteilte Transaktionen Nicht unterstützt

Herunterladen der JMS-Clientbibliothek (Java Message Service)

Fügen Sie dem Buildpfad des Projekts die folgende Bibliothek hinzu, um alle im Premium-Tarif verfügbaren Features nutzen zu können: azure-servicebus-jms. Dieses Paket beinhaltet standardmäßig einige erforderliche Standardwerte wie Prefetch-Richtlinienwerte, Richtlinien für das erneute Verbinden, Microsoft Entra ID und Managed Identity-Unterstützung.

Hinweis

Um dem Buildpfad azure-servicebus-jms hinzuzufügen, verwenden Sie das bevorzugte Tool zur Verwaltung von Abhängigkeiten für Ihr Projekt wie Maven oder Gradle.

Programmieren von Java-Anwendungen

Nachdem die Abhängigkeiten importiert worden sind, können die Java-Anwendungen in einer vom JMS-Anbieter unabhängigen Weise geschrieben werden.

Herstellen einer Verbindung mit Azure Service Bus mithilfe von JMS

Zum Herstellen einer Verbindung mit Azure Service Bus mithilfe von JMS-Clients benötigen Sie die Zeichenfolge, die im Azure-Portal in den „SAS-Richtlinien“ unter Primäre Verbindungszeichenfolge verfügbar ist.

  1. Instanziieren der ServiceBusJmsConnectionFactorySettings

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

  2. Instanziieren Sie die ServiceBusJmsConnectionFactory mit dem entsprechenden ServiceBusConnectionString-Element.

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

  3. Verwenden Sie die ConnectionFactory, um eine Connection und dann eine Session

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

    oder einen JMSContext (für JMS 2.0-Clients) zu erstellen.

    JMSContext jmsContext = factory.createContext();

    Wichtig

    Obwohl eine JMS-„Sitzung“ und eine Service Bus-„Sitzung“ ähnlich benannt sind, sind sie voneinander vollständig unabhängig.

    In JMS 1.1 ist die Sitzung ein wesentlicher Baustein der API, der die Erstellung von MessageProducer, MessageConsumer und der Message selbst ermöglicht. Weitere Informationen finden Sie im Tutorial zum JMS-API-Programmiermodell.

    In Service Bus handelt es sich bei Sitzungen um dienst- und clientseitige Konstrukte zum Aktivieren der FIFO-Verarbeitung für Warteschlangen und Abonnements.

Schreiben der JMS-Anwendung

Nachdem Session oder JMSContext instanziiert worden ist, kann die Anwendung die vertrauten JMS-APIs verwenden, um sowohl Verwaltungs- als auch Datenvorgänge auszuführen. Der Liste der unterstützten JMS-Features können Sie entnehmen, welche APIs unterstützt werden. Hier finden Sie einige Beispielcodeschnipsel für die ersten Schritte mit JMS:

Senden von Nachrichten an eine Warteschlange und ein Thema

// 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);

Empfangen von Nachrichten aus einer Warteschlange

// 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();

Empfangen von Nachrichten aus einem freigegebenen permanenten Abonnement für ein Thema

// 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();

Zusammenfassung

In diesem Leitfaden wurde gezeigt, wie Java-Clientanwendungen, die Java Message Service (JMS) über AMQP 1.0 verwenden, mit Azure Service Bus interagieren können.

Sie können Service Bus AMQP 1.0 auch mit anderen Sprachen verwenden, unter anderem .NET, C, Python und PHP. Komponenten, die mit diesen verschiedenen Sprachen geschrieben wurden, können mit der AMQP 1.0-Unterstützung in Service Bus Nachrichten zuverlässig und bei voller Vertraulichkeit austauschen.

Zugehöriger Inhalt