Dela via

Använda Java Message Service 2.0 API med Azure Service Bus Premium

  • Artikel

Den här artikeln beskriver hur du använder det populära Java Message Service (JMS) 2.0-API :et för att interagera med Azure Service Bus via PROTOKOLLET ADVANCED Message Queueing Protocol (AMQP) 1.0.

Kommentar

Stöd för Java Message Service (JMS) 2.0 API är endast tillgängligt på premiumnivån.>

Förutsättningar

Kom igång med Service Bus

Den här guiden förutsätter att du redan har ett Service Bus-namnområde. Om du inte gör det skapar du ett namnområde och en kö med hjälp av Azure-portalen. Mer information om hur du skapar Service Bus-namnområden och -köer finns i Komma igång med Service Bus-köer via Azure-portalen.

Konfigurera en Java Development-miljö

För att utveckla Java-program måste du konfigurera lämplig utvecklingsmiljö –

  • Antingen installeras JDK (Java Development Kit) eller JRE (Java Runtime Environment).
  • JDK eller JRE läggs till i byggsökvägen och lämpliga systemvariabler.
  • En Java IDE installeras för att använda JDK eller JRE. Till exempel Eclipse eller IntelliJ.

Om du vill veta mer om hur du förbereder din utvecklarmiljö för Java i Azure kan du använda den här guiden.

Vilka JMS-funktioner stöds?

I följande tabell visas de JMS-funktioner (Java Message Service) som Azure Service Bus stöder för närvarande. Den visar även funktioner som inte stöds.

Funktion API Status
Köer
  • JMSContext.createQueue( String queueName)
Stöds
Ämnen
  • JMSContext.createTopic( String topicName)
Stöds
Tillfälliga köer
  • JMSContext.createTemporaryQueue()
Stöds
Tillfälliga ämnen
  • JMSContext.createTemporaryTopic()
Stöds
Meddelandeproducent/
JMSProducer
  • JMSContext.createProducer()
Stöds
Köwebbläsare
  • JMSContext.createBrowser(kökö)
  • JMSContext.createBrowser(Kökö, SträngmeddelandeVälj)
Stöds
Meddelandekonsument/
JMSConsumer
  • JMSContext.createConsumer( Målmål)
  • JMSContext.createConsumer( Målmål, SträngmeddelandeVälj)
  • JMSContext.createConsumer( Målmål, SträngmeddelandeVälj, boolesk noLocal)

noLocal stöds för närvarande inte		 Stöds
Delade varaktiga prenumerationer
  • JMSContext.createSharedDurableConsumer(Ämnesämne, Strängnamn)
  • JMSContext.createSharedDurableConsumer(Ämnesämne, Strängnamn, SträngmeddelandeVälj)
Stöds
Ej delade varaktiga prenumerationer
  • JMSContext.createDurableConsumer(Ämnesämne, Strängnamn)
  • createDurableConsumer(Ämnesämne, Strängnamn, SträngmeddelandeVälj, boolesk noLocal)

noLocal stöds för närvarande inte och bör anges till false		 Stöds
Delade icke-varaktiga prenumerationer
  • JMSContext.createSharedConsumer(Ämnesämne, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector)
Stöds
Ej delade icke-varaktiga prenumerationer
  • JMSContext.createConsumer(målmål)
  • JMSContext.createConsumer( Målmål, SträngmeddelandeVälj)
  • JMSContext.createConsumer( Målmål, SträngmeddelandeVälj, boolesk noLocal)

noLocal stöds för närvarande inte och bör anges till false		 Stöds
Meddelandeväljare beror på vilken konsument som skapats Stöds
Leveransfördröjning (schemalagda meddelanden)
  • JMSProducer.setDeliveryDelay( long deliveryDelay)
Stöds
Meddelande har skapats
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Serializable object)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( Strängtext)
Stöds
Transaktioner mellan entiteter
  • Connection.createSession(true, Session.SESSION_TRANSACTED)
Stöds
Distribuerade transaktioner Stöds inte

Ladda ned JMS-klientbiblioteket (Java Message Service)

Om du vill använda alla tillgängliga funktioner på premiumnivån lägger du till följande bibliotek i projektets byggsökväg: azure-servicebus-jms. Det här paketet innehåller några nödvändiga standardvärden som prefetch-principvärden, återanslutningsprinciper, Microsoft Entra-ID och stöd för hanterad identitet direkt.

Kommentar

Om du vill lägga till azure-servicebus-jms i byggsökvägen använder du det önskade beroendehanteringsverktyget för ditt projekt som Maven eller Gradle.

Koda Java-program

När beroendena har importerats kan Java-programmen skrivas på ett oberoende JMS-provider.

Ansluta till Azure Service Bus med JMS

För att ansluta till Azure Service Bus med JMS-klienter behöver du den niska veze som är tillgänglig i principerna för delad åtkomst i Azure-portalen under Primär anslutningssträng.

  1. Instansiera ServiceBusJmsConnectionFactorySettings

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

  2. Instansiera ServiceBusJmsConnectionFactory med lämplig ServiceBusConnectionString.

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

  3. ConnectionFactory Använd för att antingen skapa en Connection och sedan enSession

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

    eller en JMSContext (för JMS 2.0-klienter)

    JMSContext jmsContext = factory.createContext();

    Viktigt!

    Även om den heter på samma sätt är en JMS-session och Service Bus-session helt oberoende av varandra.

    I JMS 1.1 är session en viktig byggsten i API:et som gör det möjligt att skapa MessageProducer, MessageConsumeroch Message sig själv. Mer information finns i programmeringsmodellen för JMS API

    I Service Bus är sessioner konstruktionen på tjänst- och klientsidan för att aktivera FIFO-bearbetning i köer och prenumerationer.

Skriva JMS-programmet

Session När eller JMSContext har instansierat kan ditt program använda de välbekanta JMS-API:erna för att utföra både hanterings- och dataåtgärder. Se listan över JMS-funktioner som stöds för att se vilka API:er som stöds. Här följer några exempelkodfragment för att komma igång med JMS –

Skicka meddelanden till en kö och ett ämne

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

Ta emot meddelanden från en kö

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

Ta emot meddelanden från en delad varaktig prenumeration i ett ämne

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

Sammanfattning

Den här guiden visar hur Java-klientprogram med Java Message Service (JMS) via AMQP 1.0 kan interagera med Azure Service Bus.

Du kan också använda Service Bus AMQP 1.0 från andra språk, inklusive .NET, C, Python och PHP. Komponenter som skapats med dessa olika språk kan utbyta meddelanden på ett tillförlitligt sätt och med fullständig återgivning med hjälp av AMQP 1.0-stöd i Service Bus.

Relaterat innehåll