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

Articolo
03/21/2023

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

Nota

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

Prerequisiti

Introduzione al bus di servizio

In questa guida si presuppone che sia già presente 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 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 di sviluppo per Java in Azure, usare questa guida.

Quali funzionalità JMS sono supportate?

Nella tabella seguente sono elencate le funzionalità JMS (Java Message Service) attualmente supportate bus di servizio di Azure. Mostra anche le funzionalità non supportate.

Funzionalità	API	Stato
Code	JMSContext.createQueue( String queueName)	Supportato
Argomenti	JMSContext.createTopic( String topicName)	Supportato
Code temporanee	JMSContext.createTemporaryQueue()	Supportato
Argomenti temporanei	JMSContext.createTemporaryTopic()	Supportato
Producer di messaggi/ JMSProducer	JMSContext.createProducer()	Supportato
Browser di accodamento	JMSContext.createBrowser(Queue queue) JMSContext.createBrowser(Queue queue, String messageSelector)	Supportato
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	Supportato
Sottoscrizioni durevoli condivise	JMSContext.createSharedDurableConsumer(Topic topic, String name) JMSContext.createSharedDurableConsumer(Topic topic, String name, String messageSelector)	Supportato
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	Supportato
Sottoscrizioni non durevoli condivise	JMSContext.createSharedConsumer(Topic, String sharedSubscriptionName) JMSContext.createSharedConsumer(Topic, String sharedSubscriptionName, String messageSelector)	Supportato
Sottoscrizioni non durevoli non condivise	JMSContext.createConsumer(Destination) JMSContext.createConsumer( Destination destination, String messageSelector) JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal) noLocal non è attualmente supportato e deve essere impostato su false	Supportato
Selettori di messaggi	dipende dal consumer creato	Supportato
Ritardo recapito (messaggi pianificati)	JMSProducer.setDeliveryDelay( long deliveryDelay)	Supportato
Messaggio creato	JMSContext.createMessage() JMSContext.createBytesMessage() JMSContext.createMapMessage() JMSContext.createObjectMessage( Oggetto Serializable) JMSContext.createStreamMessage() JMSContext.createTextMessage() JMSContext.createTextMessage( Testo stringa)	Supportato
Transazioni tra entità	Connection.createSession(true, Session.SESSION_TRANSACTED)	Supportato
Transazioni distribuite		Non supportato

Download della libreria client JMS (Java Message Service)

Per usare tutte le funzionalità disponibili nel livello Premium, aggiungere la libreria seguente al percorso di compilazione del progetto.

Azure-servicebus-jms

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 aver importato le dipendenze, le applicazioni Java possono essere scritte in modo indipendente dal provider JMS.

Connessione a bus di servizio di Azure tramite JMS

Per connettersi con 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.

Creare un'istanza di ServiceBusJmsConnectionFactorySettings

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

Creare un'istanza di con l'oggetto ServiceBusJmsConnectionFactory appropriato ServiceBusConnectionString.

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

Usare per ConnectionFactory 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 tra loro.

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

Nel bus di servizio le sessioni sono costrutto lato servizio e client per abilitare l'elaborazione FIFO in code e sottoscrizioni.

Scrivere l'applicazione JMS

Dopo aver creato un'istanza di Session o JMSContext , l'applicazione può usare le API JMS note 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 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.

Passaggi successivi

Per altre informazioni su bus di servizio di Azure e dettagli sulle entità JMS (Java Message Service), vedere i collegamenti seguenti: