Condividi tramite

Guida per sviluppatori di JMS 2.0 del bus di servizio di Azure

Questa guida contiene informazioni dettagliate che consentono di comunicare con il bus di servizio di Azure usando l'API Java Message Service (JMS) 2.0.

In qualità di sviluppatore Java, se sei nuovo al bus di servizio di Azure, considera la lettura degli articoli seguenti.

Come iniziare Concetti

Modello di programmazione JMS (Java Message Service)

Il modello di programmazione api Java Message Service è come illustrato nelle sezioni seguenti:

Annotazioni

Il livello Premium del bus di servizio di Azure supporta JMS 1.1 e JMS 2.0.

Bus di servizio di Azure: il livello Standard supporta funzionalità JMS 1.1 limitate. Per altri dettagli, vedere questa documentazione.

JMS - Blocchi predefiniti

I blocchi predefiniti seguenti sono disponibili per comunicare con l'applicazione JMS.

Annotazioni

La guida seguente è stata adattata dall'Esercitazione di Oracle Java EE 6 per Java Message Service (JMS)

Per una migliore comprensione del servizio messaggi Java (JMS) è consigliabile fare riferimento a questa esercitazione.

Factory di connessione

L'oggetto factory di connessione viene usato dal client per connettersi al provider JMS. La fabbrica di connessioni incapsula un set di parametri di configurazione della connessione definiti dall'amministratore.

Ogni factory di connessione è un'istanza delle interfacce ConnectionFactory, QueueConnectionFactory o TopicConnectionFactory.

Per semplificare la connessione con il bus di servizio di Azure, queste interfacce vengono implementate rispettivamente tramite ServiceBusJmsConnectionFactory, ServiceBusJmsQueueConnectionFactoryo ServiceBusJmsTopicConnectionFactory .

Importante

Le applicazioni Java che usano l'API JMS 2.0 possono connettersi al bus di servizio di Azure usando la stringa di connessione o usando un TokenCredential per sfruttare l'autenticazione supportata da Microsoft Entra. Quando si usa l'autenticazione supportata da Microsoft Entra, assicurarsi di assegnare ruoli e autorizzazioni all'identità in base alle esigenze.

Creare un'identità gestita assegnata dal sistema in Azure e usare questa identità per creare un oggetto TokenCredential.

TokenCredential tokenCredential = new DefaultAzureCredentialBuilder().build();

È quindi possibile creare un'istanza della factory di connessione con i parametri seguenti.

  • Credenziale token: rappresenta una credenziale in grado di fornire un token OAuth.
  • Host: nome host dello spazio dei nomi del livello Premium del bus di servizio di Azure.
  • Contenitore delle proprietà ServiceBusJmsConnectionFactorySettings, che contiene
    • connectionIdleTimeoutMS: timeout di connessione inattiva in millisecondi.
    • traceFrames: flag booleano per raccogliere frame di traccia AMQP per il debug.
    • altri parametri di configurazione

La factory può essere creata come illustrato di seguito. Le credenziali del token e l'host sono parametri obbligatori, ma le altre proprietà sono facoltative.

String host = "<YourNamespaceName>.servicebus.windows.net";
ConnectionFactory factory = new ServiceBusJmsConnectionFactory(tokenCredential, host, null);

Destinazione JMS

Una destinazione è l'oggetto utilizzato da un client per specificare la destinazione dei messaggi prodotti e l'origine dei messaggi utilizzati.

Le destinazioni eseguono il mapping alle entità nel bus di servizio di Azure: code (in scenari da punto a punto) e argomenti (in scenari pub-sub).

Connessioni

Una connessione incapsula una connessione virtuale con un provider JMS. Utilizzando Azure Service Bus, rappresenta una connessione di stato tra l'applicazione e Azure Service Bus tramite AMQP.

Una connessione viene creata dalla fabbrica di connessioni, come illustrato nell'esempio seguente:

Connection connection = factory.createConnection();

Sessioni

Una sessione è un contesto a thread singolo per la produzione e l'utilizzo di messaggi. Può essere usato per creare messaggi, produttori di messaggi e consumatori, ma fornisce anche un contesto transazionale per consentire il raggruppamento di invii e ricezioni in un'unità atomica di lavoro.

È possibile creare una sessione dall'oggetto connessione, come illustrato nell'esempio seguente:

Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);

Annotazioni

L'API JMS non supporta la ricezione di messaggi da code o argomenti del bus di servizio con sessioni di messaggistica abilitate.

Modalità di sessione

È possibile creare una sessione con una delle modalità seguenti.

Modalità di sessione Comportamento
Session.AUTO_ACKNOWLEDGE La sessione riconosce automaticamente la ricezione di un messaggio da parte di un client quando la sessione è stata restituita correttamente da una chiamata a ricevere o quando il listener del messaggio ha chiamato la sessione per elaborare correttamente il messaggio.
Session.CLIENT_ACKNOWLEDGE Il client riconosce un messaggio utilizzato chiamando il metodo di conferma del messaggio.
Session.DUPS_OK_ACKNOWLEDGE Questa modalità di riconoscimento indica alla sessione di riconoscere pigramente la consegna dei messaggi.
Session.SESSION_TRANSACTED Questo valore può essere passato come argomento al metodo createSession(int sessionMode) nell'oggetto Connection per specificare che la sessione deve utilizzare una transazione locale.

Quando la modalità sessione non è specificata, per impostazione predefinita viene selezionata la Session.AUTO_ACKNOWLEDGE .

JMSContext

Annotazioni

JMSContext viene definito come parte della specifica JMS 2.0.

JMSContext combina le funzionalità fornite dagli oggetti di connessione e di sessione. Può essere creato dall'oggetto factory di connessione.

JMSContext context = connectionFactory.createContext();

Modalità JMSContext

Proprio come l'oggetto Session , JMSContext può essere creato con le stesse modalità di riconoscimento indicate nelle modalità sessione.

JMSContext context = connectionFactory.createContext(JMSContext.AUTO_ACKNOWLEDGE);

Quando la modalità non viene specificata, il JMSContext.AUTO_ACKNOWLEDGE viene selezionato per impostazione predefinita.

Produttori di messaggi JMS

Un producer di messaggi è un oggetto creato usando JMSContext o una sessione e usato per l'invio di messaggi a una destinazione.

Può essere creato come oggetto autonomo, come illustrato nell'esempio seguente:

JMSProducer producer = context.createProducer();

Oppure creato in fase di esecuzione quando è necessario inviare un messaggio.

context.createProducer().send(destination, message);

Consumer di messaggi JMS

Un consumer di messaggi è un oggetto creato da un JMSContext o da una sessione e utilizzato per la ricezione di messaggi inviati a una destinazione. Può essere creato come illustrato in questo esempio:

JMSConsumer consumer = context.createConsumer(dest);

Ricezione sincrona tramite metodo receive()

Il consumer di messaggi fornisce un modo sincrono per ricevere messaggi dalla destinazione tramite il metodo receive().

Se non viene specificato alcun argomento/timeout o viene specificato un timeout di '0', il consumer si blocca a tempo indefinito a meno che il messaggio non arrivi o la connessione venga interrotta (a prescindere da quale sia precedente).

Message m = consumer.receive();
Message m = consumer.receive(0);

Quando viene specificato un argomento positivo diverso da zero, il consumer si blocca fino alla scadenza del timer.

Message m = consumer.receive(1000); // time out after one second.

Ricezione asincrona con listener di messaggi JMS

Un listener di messaggi è un oggetto utilizzato per la gestione asincrona dei messaggi in una destinazione. Implementa l'interfaccia MessageListener, che contiene il metodo onMessage in cui deve risiedere la logica di business specifica.

È necessario creare un'istanza di un oggetto listener di messaggi e registrarlo in un consumer di messaggi specifico usando il metodo setMessageListener.

Listener myListener = new Listener();
consumer.setMessageListener(myListener);

Utilizzo da argomenti

I consumer di messaggi JMS vengono creati in base a una destinazione, che può essere una coda o un argomento.

I consumer nelle code sono semplicemente oggetti lato client che risiedono nel contesto della sessione (e connessione) tra l'applicazione client e il bus di servizio di Azure.

I consumatori su argomenti, tuttavia, hanno 2 parti -

  • Un oggetto lato client che risiede nel contesto della sessione(oppure JMSContext) e,
  • Una sottoscrizione che è un'entità nell'Azure Service Bus.

Le sottoscrizioni sono documentate qui e possono essere una delle seguenti:

  • Sottoscrizioni durevoli condivise
  • Sottoscrizioni non durevoli condivise
  • Sottoscrizioni durevoli non condivise
  • Sottoscrizioni non durevoli non condivise

Browser di accodamento JMS

L'API JMS fornisce un QueueBrowser oggetto che consente all'applicazione di esplorare i messaggi nella coda e visualizzare i valori di intestazione per ogni messaggio.

È possibile creare un Browser di coda usando JMSContext come nell'esempio seguente:

QueueBrowser browser = context.createBrowser(queue);

Annotazioni

L'API JMS non fornisce un'API per esplorare un argomento.

Questo perché l'argomento stesso non archivia i messaggi. Non appena il messaggio viene inviato al topic, viene inoltrato alle sottoscrizioni appropriate.

Selettori di messaggi JMS

I selettori di messaggi possono essere usati dalle applicazioni riceventi per filtrare i messaggi ricevuti. Con i selettori di messaggio, l'applicazione ricevente scarica il lavoro di filtro dei messaggi al provider JMS (in questo caso, il bus di servizio di Azure) anziché assumerne la responsabilità.

I selettori possono essere utilizzati durante la creazione di uno dei consumer seguenti:

  • Sottoscrizione durevole condivisa
  • Sottoscrizione durevole non condivisa
  • Sottoscrizione non durevole condivisa
  • Sottoscrizione non condivisa non durevole
  • Consumer della coda
  • Browser di accodamento

Annotazioni

I selettori di Service Bus non supportano le parole chiave SQL "LIKE" e "BETWEEN".

Disposizione AMQP e mappatura delle operazioni del Service Bus

Ecco come si traduce una disposizione AMQP in un'operazione del Service Bus:

ACCEPTED = 1; -> Complete()
REJECTED = 2; -> DeadLetter()
RELEASED = 3; (just unlock the message in service bus, will then get redelivered)
MODIFIED_FAILED = 4; -> Abandon() which increases delivery count
MODIFIED_FAILED_UNDELIVERABLE = 5; -> Defer()

Riassunto

Questa guida per sviluppatori ha illustrato in che modo le applicazioni client Java che usano Java Message Service (JMS) possono connettersi con il bus di servizio di Azure.

Passaggi successivi

Per altre informazioni sul bus di servizio di Azure e sui dettagli sulle entità JMS (Java Message Service), vedere gli articoli seguenti: