Inviare messaggi a un argomento del bus di servizio di Azure e ricevere messaggi dalle sottoscrizioni dell'argomento (Java)

In questa guida di avvio rapido viene scritto codice Java con il pacchetto azure-messaging-servicebus per inviare messaggi a un argomento del bus di servizio di Azure e quindi ricevere messaggi dalle sottoscrizioni di tale argomento.

Prerequisiti

• Una sottoscrizione di Azure. Per completare l'esercitazione, è necessario un account Azure. È possibile attivare i vantaggi della sottoscrizione Visual Studio o MSDN oppure registrarsi per ottenere un account gratuito.
• Installare Azure SDK per Java. Se si usa Eclipse, è possibile installare Azure Toolkit for Eclipse che include Azure SDK per Java. È quindi possibile aggiungere le librerie di Microsoft Azure per Java al progetto. Se si usa IntelliJ, vedere Installare Azure Toolkit for IntelliJ.

Creare uno spazio dei nomi nel portale di Azure

Per iniziare a usare le entità di messaggistica del bus di servizio in Azure, prima di tutto è necessario creare uno spazio dei nomi con un nome univoco in Azure. Uno spazio dei nomi fornisce un contenitore di ambito per bus di servizio risorse (code, argomenti e così via) all'interno dell'applicazione.

Per creare uno spazio dei nomi:

1. Accedere al portale di Azure.

2. Passare alla pagina Tutti i servizi.

3. Sulla barra di spostamento a sinistra selezionare Integrazione nell'elenco delle categorie, passare il puntatore del mouse su bus di servizio e quindi selezionare + il pulsante nel riquadro bus di servizio.

   

4. Nel tag Informazioni di base della pagina Crea spazio dei nomi seguire questa procedura:

   1. Per Sottoscrizione scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.

   2. Per Gruppo di risorse scegliere un gruppo di risorse esistente in cui risiederà lo spazio dei nomi oppure crearne uno nuovo.

   3. Immettere un nome per lo spazio dei nomi. Il nome dello spazio dei nomi deve rispettare le convenzioni di denominazione seguenti:

      • Il nome deve essere univoco in Azure. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.
      • La lunghezza del nome è almeno 6 e al massimo 50 caratteri.
      • Il nome può contenere solo lettere, numeri, trattini "-".
      • Il nome deve iniziare con una lettera e terminare con una lettera o un numero.
      • Il nome non termina con "-sb" o "-mgmt".

   4. Per Localitàscegliere l'area in cui deve essere ospitato lo spazio dei nomi.

   5. Per Piano tariffario selezionare il piano tariffario (Basic, Standard o Premium) per lo spazio dei nomi. Per questa guida introduttiva selezionare Standard.

      Importante

      Se si vogliono usare argomenti e sottoscrizioni, scegliere Standard o Premium. Gli argomenti e le sottoscrizioni non sono supportati nel piano tariffario Basic.

      Se è stato selezionato il piano tariffario Premium, specificare il numero di unità di messaggistica. Il piano Premium fornisce l'isolamento delle risorse a livello di CPU e memoria in modo che ogni carico di lavoro venga eseguito in isolamento. Questo contenitore di risorse viene chiamato unità di messaggistica. Uno spazio dei nomi Premium ha almeno un'unità di messaggistica. È possibile selezionare 1, 2, 4, 8 o 16 unità di messaggistica per ogni spazio dei nomi bus di servizio Premium. Per altre informazioni, vedere Messaggistica Premium del bus di servizio.

   6. Selezionare Rivedi e crea nella parte inferiore della pagina.

      

   7. Nella pagina Rivedi e crea rivedere le impostazioni e selezionare Crea.

5. Al termine della distribuzione della risorsa, selezionare Vai alla risorsa nella pagina di distribuzione.

   

6. Viene visualizzata la home page dello spazio dei nomi del bus di servizio.

   

Creare un argomento usando il portale di Azure

1. Nella pagina Spazio dei nomi del bus di servizio scegliere Argomenti dal menu a sinistra.

2. Selezionare + Argomento sulla barra degli strumenti.

3. Immettere un nome per l'argomento. Lasciare invariati i valori predefiniti delle altre opzioni.

4. Seleziona Crea.

   

Creare una sottoscrizione all'argomento

1. Selezionare l'argomento creato nella sezione precedente.

   

2. Nella pagina argomento bus di servizio selezionare + Sottoscrizione sulla barra degli strumenti.

   

3. Nella pagina Crea sottoscrizione seguire questa procedura:

   1. Immettere S1 per nome della sottoscrizione.

   2. Immettere 3 per Numero massimo di recapito.

   3. Selezionare quindi Crea per creare la sottoscrizione.

      

Autenticare l'app in Azure

Questa guida introduttiva illustra due modi per connettersi a bus di servizio di Azure: senza password e stringa di connessione.

La prima opzione mostra come usare l'entità di sicurezza in Microsoft Entra ID e il controllo degli accessi in base al ruolo per connettersi a uno spazio dei nomi bus di servizio. Non è necessario preoccuparsi di avere stringa di connessione hardcoded nel codice o in un file di configurazione o in un'archiviazione sicura come Azure Key Vault.

La seconda opzione mostra come usare un stringa di connessione per connettersi a uno spazio dei nomi bus di servizio. Se non si ha esperienza con Azure, è possibile trovare l'opzione stringa di connessione più semplice da seguire. È consigliabile usare l'opzione senza password in applicazioni e ambienti di produzione reali. Per altre informazioni, consultare Autenticazione e autorizzazione. Per altre informazioni sull'autenticazione senza password, vedere la pagina di panoramica.

Inviare messaggi a un argomento

In questa sezione viene creato un progetto console Java e viene aggiunto il codice per inviare messaggi all'argomento creato.

Creare un progetto di console Java

Creare un progetto Java usando Eclipse o un altro strumento a scelta.

Configurare l'applicazione per l'uso del bus di servizio

Aggiungere riferimenti alle librerie di Azure Core e bus di servizio di Azure.

Se si usa Eclipse e si crea un'applicazione console Java, convertire il progetto Java in maven: fare clic con il pulsante destro del mouse sul progetto nella finestra Esplora pacchetti , selezionare Configura ->Converti in progetto Maven. Aggiungere quindi dipendenze a queste due librerie, come illustrato nell'esempio seguente.

    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-messaging-servicebus</artifactId>
            <version>7.13.3</version>
        </dependency>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-identity</artifactId>
            <version>1.8.0</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-messaging-servicebus</artifactId>
            <version>7.13.3</version>
        </dependency>

Aggiungere il codice per inviare messaggi all'argomento

1. Aggiungere le istruzioni import seguenti nell'argomento del file Java.

   • Senza password (scelta consigliata)
   • Stringa di connessione

   import com.azure.messaging.servicebus.*;
   import com.azure.identity.*;
   
   import java.util.concurrent.TimeUnit;
   import java.util.Arrays;
   import java.util.List;
   

2. Nella classe definire le variabili per contenere stringa di connessione (non necessarie per lo scenario senza password), il nome dell'argomento e il nome della sottoscrizione.

   • Senza password (scelta consigliata)
   • Stringa di connessione

   static String topicName = "<TOPIC NAME>";
   static String subName = "<SUBSCRIPTION NAME>";
   

   Importante

   Sostituire <TOPIC NAME> con il nome dell'argomento e <SUBSCRIPTION NAME> con il nome della sottoscrizione dell'argomento.

3. Aggiungere un metodo denominato sendMessage nella classe per inviare un messaggio all'argomento.

   • Senza password (scelta consigliata)
   • Stringa di connessione

   Importante

   Sostituire NAMESPACENAME con il nome dello spazio dei nomi del bus di servizio.

   static void sendMessage()
   {
       // create a token using the default Azure credential
       DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
               .build();
   
       ServiceBusSenderClient senderClient = new ServiceBusClientBuilder()
               .fullyQualifiedNamespace("NAMESPACENAME.servicebus.windows.net")
               .credential(credential)
               .sender()
               .topicName(topicName)
               .buildClient();
   
       // send one message to the topic
       senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
       System.out.println("Sent a single message to the topic: " + topicName);
   }
   
   

4. Aggiungere un metodo denominato createMessages nella classe per creare un elenco di messaggi. In genere, questi messaggi provengono da parti diverse dell'applicazione. In questo caso verrà creato un elenco di messaggi di esempio.

   static List<ServiceBusMessage> createMessages()
   {
       // create a list of messages and return it to the caller
       ServiceBusMessage[] messages = {
               new ServiceBusMessage("First message"),
               new ServiceBusMessage("Second message"),
               new ServiceBusMessage("Third message")
       };
       return Arrays.asList(messages);
   }
   

5. Aggiungere un metodo denominato sendMessageBatch per inviare messaggi all'argomento creato. Questo metodo crea un oggetto ServiceBusSenderClient per l'argomento, richiama il metodo createMessages per ottenere l'elenco di messaggi, prepara uno o più batch e li invia all'argomento.

   • Senza password (scelta consigliata)
   • Stringa di connessione

   Importante

   Sostituire NAMESPACENAME con il nome dello spazio dei nomi del bus di servizio.

   static void sendMessageBatch()
   {
       // create a token using the default Azure credential
       DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
               .build();
   
       ServiceBusSenderClient senderClient = new ServiceBusClientBuilder()
               .fullyQualifiedNamespace("NAMESPACENAME.servicebus.windows.net")
               .credential(credential)
               .sender()
               .topicName(topicName)
               .buildClient();
   
       // Creates an ServiceBusMessageBatch where the ServiceBus.
       ServiceBusMessageBatch messageBatch = senderClient.createMessageBatch();
   
       // create a list of messages
       List<ServiceBusMessage> listOfMessages = createMessages();
   
       // We try to add as many messages as a batch can fit based on the maximum size and send to Service Bus when
       // the batch can hold no more messages. Create a new batch for next set of messages and repeat until all
       // messages are sent.
       for (ServiceBusMessage message : listOfMessages) {
           if (messageBatch.tryAddMessage(message)) {
               continue;
           }
   
           // The batch is full, so we create a new batch and send the batch.
           senderClient.sendMessages(messageBatch);
           System.out.println("Sent a batch of messages to the topic: " + topicName);
   
           // create a new batch
           messageBatch = senderClient.createMessageBatch();
   
           // Add that message that we couldn't before.
           if (!messageBatch.tryAddMessage(message)) {
               System.err.printf("Message is too large for an empty batch. Skipping. Max size: %s.", messageBatch.getMaxSizeInBytes());
           }
       }
   
       if (messageBatch.getCount() > 0) {
           senderClient.sendMessages(messageBatch);
           System.out.println("Sent a batch of messages to the topic: " + topicName);
       }
   
       //close the client
       senderClient.close();
   }
   

Ricevere messaggi da una sottoscrizione

In questa sezione si aggiunge codice per recuperare i messaggi da una sottoscrizione all'argomento.

1. Aggiungere un metodo denominato receiveMessages per ricevere messaggi dalla sottoscrizione. Questo metodo crea un oggetto ServiceBusProcessorClient per la sottoscrizione specificando un gestore per l'elaborazione di messaggi e un altro per la gestione degli errori. Quindi avvia il processore, aspetta alcuni secondi, stampa i messaggi ricevuti e infine arresta e chiude il processore.

   • Senza password (scelta consigliata)
   • Stringa di connessione

   Importante

   • Sostituire NAMESPACENAME con il nome dello spazio dei nomi del bus di servizio.
   • Sostituire ServiceBusTopicTest in ServiceBusTopicTest::processMessage nel codice con il nome della classe.

   // handles received messages
   static void receiveMessages() throws InterruptedException
   {
       DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
               .build();
   
       // Create an instance of the processor through the ServiceBusClientBuilder
       ServiceBusProcessorClient processorClient = new ServiceBusClientBuilder()
           .fullyQualifiedNamespace("NAMESPACENAME.servicebus.windows.net")
           .credential(credential)
           .processor()
           .topicName(topicName)
           .subscriptionName(subName)
           .processMessage(context -> processMessage(context))
           .processError(context -> processError(context))
           .buildProcessorClient();
   
       System.out.println("Starting the processor");
       processorClient.start();
   
       TimeUnit.SECONDS.sleep(10);
       System.out.println("Stopping and closing the processor");
       processorClient.close();
   }
   

2. Aggiungere il processMessage metodo per elaborare un messaggio ricevuto dalla sottoscrizione bus di servizio.

   private static void processMessage(ServiceBusReceivedMessageContext context) {
       ServiceBusReceivedMessage message = context.getMessage();
       System.out.printf("Processing message. Session: %s, Sequence #: %s. Contents: %s%n", message.getMessageId(),
           message.getSequenceNumber(), message.getBody());
   }
   

3. Aggiungere il processError metodo per gestire i messaggi di errore.

   private static void processError(ServiceBusErrorContext context) {
       System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
           context.getFullyQualifiedNamespace(), context.getEntityPath());
   
       if (!(context.getException() instanceof ServiceBusException)) {
           System.out.printf("Non-ServiceBusException occurred: %s%n", context.getException());
           return;
       }
   
       ServiceBusException exception = (ServiceBusException) context.getException();
       ServiceBusFailureReason reason = exception.getReason();
   
       if (reason == ServiceBusFailureReason.MESSAGING_ENTITY_DISABLED
           || reason == ServiceBusFailureReason.MESSAGING_ENTITY_NOT_FOUND
           || reason == ServiceBusFailureReason.UNAUTHORIZED) {
           System.out.printf("An unrecoverable error occurred. Stopping processing with reason %s: %s%n",
               reason, exception.getMessage());
       } else if (reason == ServiceBusFailureReason.MESSAGE_LOCK_LOST) {
           System.out.printf("Message lock lost for message: %s%n", context.getException());
       } else if (reason == ServiceBusFailureReason.SERVICE_BUSY) {
           try {
               // Choosing an arbitrary amount of time to wait until trying again.
               TimeUnit.SECONDS.sleep(1);
           } catch (InterruptedException e) {
               System.err.println("Unable to sleep for period of time");
           }
       } else {
           System.out.printf("Error source %s, reason %s, message: %s%n", context.getErrorSource(),
               reason, context.getException());
       }
   }
   

4. Aggiornare il metodo main per richiamare i metodi sendMessage, sendMessageBatch e receiveMessages e per generare InterruptedException.

   public static void main(String[] args) throws InterruptedException {
       sendMessage();
       sendMessageBatch();
       receiveMessages();
   }
   

Eseguire l'app

Eseguire il programma per visualizzare l'output simile all'output seguente:

Sent a single message to the topic: mytopic
Sent a batch of messages to the topic: mytopic
Starting the processor
Processing message. Session: e0102f5fbaf646988a2f4b65f7d32385, Sequence #: 1. Contents: Hello, World!
Processing message. Session: 3e991e232ca248f2bc332caa8034bed9, Sequence #: 2. Contents: First message
Processing message. Session: 56d3a9ea7df446f8a2944ee72cca4ea0, Sequence #: 3. Contents: Second message
Processing message. Session: 7bd3bd3e966a40ebbc9b29b082da14bb, Sequence #: 4. Contents: Third message

Nella pagina Panoramica dello spazio dei nomi del bus di servizio nel portale di Azure è possibile visualizzare il numero di messaggi in ingresso e in uscita. Attendere un minuto e quindi aggiornare la pagina per visualizzare i valori più recenti.

Passare alla scheda Argomenti nel riquadro centrale inferiore, quindi selezionare l'argomento per visualizzare la relativa pagina Argomento del bus di servizio. In questa pagina verranno visualizzati quattro messaggi in ingresso e quattro messaggi in uscita nel grafico Messaggi.

Se si imposta come commento la chiamata receiveMessages nel metodo main e si esegue di nuovo l'app, nella pagina Argomento del bus di servizio verranno visualizzati 8 messaggi in ingresso (4 nuovi) ma solo quattro messaggi in uscita.

Se in questa pagina si seleziona una sottoscrizione si passa alla pagina Sottoscrizione del bus di servizio. In questa pagina è possibile visualizzare il numero di messaggi attivi, il numero di messaggi non recapitabili e altro ancora. In questo esempio sono presenti quattro messaggi attivi che il ricevitore non ha ancora ricevuto.

Passaggi successivi

Vedere la documentazione e gli esempi seguenti:

• Libreria client del bus di servizio di Azure per Java - Leggimi
• Esempi in GitHub
• Informazioni di riferimento sulle API Java