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 över PROTOKOLLET ADVANCED Message Queueing Protocol (AMQP 1.0).

Anteckning

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 Portal. 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 Portal.

Konfigurera en Java Development-miljö

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

  • Antingen är JDK (Java Development Kit) eller JRE (Java Runtime Environment) installerat.
  • 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 utvecklarmiljön 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 inte för närvarande		 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, booleskt 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(Ämnesämne, SträngdeladePrenumerationsnamn, SträngmeddelandeVälj)
 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

Anteckning

Om du vill lägga till Azure-servicebus-jms i byggsökvägen använder du det önskade beroendehanteringsverktyget för projektet, till exempel Maven eller Gradle.

Koda Java-program

När beroendena har importerats kan Java-programmen skrivas på ett JMS-providerberoende sätt.

Ansluta till Azure Service Bus med JMS

För att ansluta med Azure Service Bus med JMS-klienter behöver du anslutningssträngen som är tillgänglig i principerna för delad åtkomst i Azure Portal 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 a 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 sig Message själv. Mer information finns i programmeringsmodellen för JMS API

    I Service Bus skapas sessioner 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 instansierats 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 som använder 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 full återgivning med hjälp av AMQP 1.0-stödet i Service Bus.

Nästa steg

Mer information om Azure Service Bus och information om JMS-entiteter (Java Message Service) finns i länkarna nedan –