Usare l'API Java Message Service 2.0 con il Bus di servizio di Azure Premium

Questo articolo illustra come usare l'API Java Message Service (JMS) 2.0 comune per interagire con il Bus di servizio di Azure tramite il protocollo Advanced Message Queueing Protocol (AMQP) 1.0.

Nota

Il supporto per l'API Java Message Service (JMS) 2.0 è disponibile solo nel livello Premium.>

Prerequisiti

Introduzione al bus di servizio

Questa guida presuppone che si disponga già di uno spazio dei nomi del Bus di servizio. In caso contrario, creare uno spazio dei nomi e una coda usando il portale di Azure. Per altre informazioni su come creare spazi dei nomi e code del Bus di servizio, vedere Introduzione alle code del Bus di servizio tramite il portale di Azure.

Configurare un ambiente di sviluppo in Java

Per sviluppare applicazioni Java, è necessario configurare l'ambiente di sviluppo appropriato:

  • JDK (Java Development Kit) o JRE (Java Runtime Environment) è installato.
  • JDK o JRE viene aggiunto al percorso di compilazione e alle variabili di sistema appropriate.
  • Un IDE Java viene installato per usare JDK o JRE. Ad esempio, Eclipse o IntelliJ.

Per altre informazioni su come preparare l'ambiente per sviluppatori per Java in Azure, usare questa guida.

Quali funzionalità JMS sono supportate?

La tabella seguente elenca le funzionalità di Java Message Service (JMS) attualmente supportate dal bus di servizio di Azure. Mostra anche le funzionalità non supportate.

Funzionalità API Status
Code
  • JMSContext.createQueue( String queueName)
Supportata
Argomenti
  • JMSContext.createTopic( String topicName)
Supportata
Code temporanee
  • JMSContext.createTemporaryQueue()
Supportata
Argomenti temporanei
  • JMSContext.createTemporaryTopic()
Supportata
Producer di messaggi/
JMSProducer
  • JMSContext.createProducer()
Supportata
Browser di accodamento
  • JMSContext.createBrowser(Queue queue)
  • JMSContext.createBrowser(Queue queue, String messageSelector)
Supportata
Consumer di messaggi/
JMSConsumer
  • JMSContext.createConsumer( Destinazione di destinazione)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

noLocal non è attualmente supportato
Supportata
Sottoscrizioni durevoli condivise
  • JMSContext.createSharedDurableConsumer(Topic topic, String name)
  • JMSContext.createSharedDurableConsumer(Topic, String name, String messageSelector)
Supportata
Sottoscrizioni durevoli non condivise
  • JMSContext.createDurableConsumer(Topic topic, String name)
  • createDurableConsumer(Topic, String name, String messageSelector, boolean noLocal)

noLocal non è attualmente supportato e deve essere impostato su false
Supportata
Sottoscrizioni non durevoli condivise
  • JMSContext.createSharedConsumer(Topic, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(Topic, String sharedSubscriptionName, String messageSelector)
Supportata
Sottoscrizioni non durevoli non condivise
  • JMSContext.createConsumer(Destinazione)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

noLocal non è attualmente supportato e deve essere impostato su false
Supportata
Selettori di messaggi dipende dal consumer creato Supportata
Ritardo recapito (messaggi pianificati)
  • JMSProducer.setDeliveryDelay( long deliveryDelay)
Supportata
Messaggio creato
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Oggetto Serializable)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( String text)
Supportata
Transazioni tra entità
  • Connection.createSession(true, Session.SESSION_TRANSACTED)
Supportata
Transazioni distribuite Non supportato

Download della libreria client Java Message Service (JMS)

Per usare tutte le funzionalità disponibili nel livello Premium, aggiungere la libreria seguente al percorso di compilazione del progetto: azure-servicebus-jms. Questo pacchetto fornisce alcune impostazioni predefinite necessarie, ad esempio i valori dei criteri di pre-recupero, i criteri di riconnessione, Microsoft Entra ID e il supporto dell'identità gestita.

Nota

Per aggiungere azure-servicebus-jms al percorso di compilazione, usare lo strumento di gestione delle dipendenze preferito per il progetto, ad esempio Maven o Gradle.

Compilazione di applicazioni Java

Dopo l'importazione delle dipendenze, le applicazioni Java possono essere scritte in modo indipendente dal provider JMS.

Connessione al bus di servizio di Azure con JMS

Per connettersi al Bus di servizio di Azure usando i client JMS, è necessaria la stringa di connessione disponibile in "Criteri di accesso condiviso" nel portale di Azure in Stringa di connessione primaria.

  1. Creare un'istanza di ServiceBusJmsConnectionFactorySettings

    ServiceBusJmsConnectionFactorySettings connFactorySettings = new ServiceBusJmsConnectionFactorySettings();
    connFactorySettings.setConnectionIdleTimeoutMS(20000);
    
  2. Creare un'istanza di ServiceBusJmsConnectionFactory con l'oggetto appropriato ServiceBusConnectionString.

    String ServiceBusConnectionString = "<SERVICE_BUS_CONNECTION_STRING_WITH_MANAGE_PERMISSIONS>";
    ConnectionFactory factory = new ServiceBusJmsConnectionFactory(ServiceBusConnectionString, connFactorySettings);
    
  3. Usare ConnectionFactory per creare un oggetto Connection e quindi un Session

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

    o JMSContext (per i client JMS 2.0)

    JMSContext jmsContext = factory.createContext();
    

    Importante

    Anche se con lo stesso nome, una sessione JMS e una sessione del Bus di servizio sono completamente indipendenti l'una dall'altra.

    In JMS 1.1, la sessione è un blocco predefinito essenziale dell'API che consente la creazione di MessageProducer, MessageConsumer e Message. Per altre informazioni, vedere il modello di programmazione dell'API JMS

    Nel Bus di servizio le sessioni sono costrutto sul lato servizio e sul lato client per abilitare l'elaborazione FIFO nelle code e nelle sottoscrizioni.

Scrivere l'applicazione JMS

Dopo aver creato un'istanza di Session o JMSContext, l'applicazione può usare le API JMS familiari per eseguire operazioni di gestione e dati. Fare riferimento all'elenco delle funzionalità JMS supportate per vedere quali API sono supportate. Ecco alcuni frammenti di codice di esempio per iniziare a usare JMS:

Invio di messaggi a una coda e a un argomento

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

Ricezione di messaggi da una coda

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

Ricezione di messaggi da una sottoscrizione durevole condivisa in un argomento

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

Riepilogo

Questa guida ha illustrato in che modo le applicazioni client Java che usano Java Message Service (JMS) su AMQP 1.0 possono interagire con il Bus di servizio di Azure.

È anche possibile utilizzare AMQP 1.0 per il bus di servizio da altri linguaggi, tra cui .NET, C, Python e PHP. I componenti creati con questi linguaggi possono scambiare messaggi in modo affidabile e con la massima fedeltà grazie al supporto per AMQP 1.0 nel bus di servizio.