Condividi tramite

Usare bus di servizio di Azure nelle applicazioni Spring

  • Articolo

Questo articolo illustra come usare bus di servizio di Azure nelle applicazioni Java compilate con Spring Framework.

Azure offre una piattaforma di messaggistica asincrona denominata bus di servizio di Azure (bus di servizio), basata sullo standard Advanced Message Queueing Protocol 1.0 (AMQP 1.0). È possibile usare bus di servizio nell'intera gamma di piattaforme di Azure supportate.

Spring Cloud Azure offre vari moduli per l'invio di messaggi a e la ricezione da code e argomenti di Service Bus, nonché sottoscrizioni, tramite i framework Spring.

È possibile usare i moduli seguenti in modo indipendente o combinarli per casi d'uso diversi:

Prerequisiti

Nota

Per concedere l'accesso del tuo account alle risorse di Azure Service Bus, nel tuo spazio dei nomi appena creato di Azure Service Bus, assegna i ruoli di Mittente Dati di Azure Service Bus e Ricevitore Dati di Azure Service Bus all'account Microsoft Entra che stai attualmente utilizzando. Per ulteriori informazioni, vedi Assegnare ruoli di Azure usando il portale di Azure.

Importante

Spring Boot versione 2.5 o successiva è necessario per completare i passaggi di questa esercitazione.

Preparare l'ambiente locale

In questa esercitazione le configurazioni e il codice non dispongono di alcuna operazione di autenticazione. Tuttavia, la connessione a un servizio di Azure richiede l'autenticazione. Per completare l'autenticazione, è necessario usare la libreria client di Identità di Azure. Spring Cloud Azure usa DefaultAzureCredential, che la libreria di identità di Azure fornisce per ottenere le credenziali senza modifiche al codice.

DefaultAzureCredential supporta più metodi di autenticazione e determina il metodo da usare in fase di esecuzione. Questo approccio consente all'app di usare metodi di autenticazione diversi in ambienti diversi, ad esempio ambienti locali o di produzione, senza implementare codice specifico dell'ambiente. Per altre informazioni, vedere la sezione DefaultAzureCredential di Autenticare le applicazioni Java ospitate in Azure.

Per usare l'interfaccia della riga di comando di Azure, IntelliJ o altri metodi per completare l'autenticazione negli ambienti di sviluppo locali, vedere Autenticazione di Azure in ambienti di sviluppo Java. Per completare l'autenticazione negli ambienti di hosting di Azure, è consigliabile usare l'identità gestita. Per altre informazioni, vedere Informazioni sulle identità gestite per le risorse di Azure

Nota

Azure Service Bus dell'API JMS al momento non supporta DefaultAzureCredential. Se si usa Spring JMS con bus di servizio, ignorare questo passaggio.

Usa lo Starter di Spring Cloud Azure Service Bus

Il modulo Spring Cloud Azure Service Bus Starter importa la libreria client di Service Bus Java con il framework Spring Boot. È possibile usare Insieme Spring Cloud Azure e Azure SDK, in un modello che non si escludono a vicenda. È quindi possibile continuare a usare l'API client Java bus di servizio nell'applicazione Spring.

Aggiungere la dipendenza di Service Bus

Per installare il modulo Spring Cloud bus di servizio di Azure Starter, aggiungere le dipendenze seguenti al file pom.xml:

  • Lista dei Materiali (BOM) di Spring Cloud Azure.

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.19.0. Questa distinta base deve essere configurata nella <dependencyManagement> sezione del file di pom.xml . In questo modo tutte le dipendenze di Spring Cloud Azure usano la stessa versione. Per ulteriori informazioni sulla versione utilizzata per questa distinta base, vedere Quale versione di Spring Cloud Azure dovrei usare.

  • Artefatto di Azure Service Bus di Spring Cloud

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-servicebus</artifactId>
</dependency>

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

Questa guida illustra come usare i client Java bus di servizio nel contesto di un'applicazione Spring. Ecco due alternative. Il modo consigliato consiste nell'usare la configurazione automatica di Spring Boot e usare i client predefiniti dal contesto Spring. L'alternativa consiste nel creare client in modo autonomo a livello di codice.

Il primo modo, che comporta il cablaggio automatico dei fagioli client dal contenitore Spring IoC, presenta i vantaggi seguenti rispetto al secondo modo. Questi vantaggi offrono un'esperienza più flessibile ed efficiente durante lo sviluppo con i client di Service Bus.

  • È possibile usare la configurazione esterna in modo che sia possibile usare lo stesso codice dell'applicazione in ambienti diversi.

  • È possibile delegare il processo di apprendimento del modello di generatore e registrare questo client nel contesto dell'applicazione nel framework Spring Boot. Questa delega consente di concentrarsi su come usare i client con i propri requisiti aziendali.

  • È possibile usare l'indicatore di integrità in modo semplice per controllare lo stato e l'integrità dell'applicazione e dei componenti interni.

Nell'esempio di codice seguente viene illustrato come usare ServiceBusSenderClient e ServiceBusProcessorClient con queste due alternative.

Nota

Azure Java SDK per Service Bus fornisce diversi client per interagire con Service Bus. Lo starter fornisce anche la configurazione automatica per tutti i client bus di servizio e i generatori client. In questo caso si usano solo ServiceBusSenderClient e ServiceBusProcessorClient come esempi.

Usare la configurazione automatica di Spring Boot

Per inviare e ricevere messaggi da bus di servizio, configurare l'applicazione attenendosi alla procedura seguente:

  1. Configura lo spazio dei nomi e la coda del Service Bus, come illustrato nell'esempio seguente:

    spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
spring.cloud.azure.servicebus.entity-name=<your-servicebus-queue-name>
spring.cloud.azure.servicebus.entity-type=queue

    Suggerimento

    In questo esempio viene usata la coda del Service Bus. Per usare argomento/sottoscrizione, è necessario aggiungere la spring.cloud.azure.servicebus.processor.subscription-name proprietà e modificare il entity-type valore in topic.

  2. Creare una nuova ServiceBusProcessorClientConfiguration classe Java come illustrato nell'esempio seguente. Questa classe viene usata per registrare il messaggio e il gestore degli errori di ServiceBusProcessorClient.

    @Configuration(proxyBeanMethods = false)
public class ServiceBusProcessorClientConfiguration {

    @Bean
    ServiceBusRecordMessageListener processMessage() {
        return context -> {
            ServiceBusReceivedMessage message = context.getMessage();
            System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n", message.getMessageId(),
                    message.getSequenceNumber(), message.getBody());
        };
    }

    @Bean
    ServiceBusErrorHandler processError() {
        return context -> {
            System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                    context.getFullyQualifiedNamespace(), context.getEntityPath());
        };
    }
}

  3. Inserire l'oggetto ServiceBusSenderClient nell'applicazione Spring e chiamare le API correlate per inviare messaggi, come illustrato nell'esempio seguente:

    @SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    public ServiceBusQueueApplication(ServiceBusSenderClient senderClient) {
        this.senderClient = senderClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(ServiceBusQueueApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // send one message to the queue
        senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
        System.out.printf("Sent a message to the queue");
        senderClient.close();

        // wait the processor client to consume messages
        TimeUnit.SECONDS.sleep(10);
    }

}

    Nota

    Per impostazione predefinita, il ciclo di vita del bean autowired ServiceBusProcessorClient viene gestito dal contesto Spring. Il processore viene avviato automaticamente all'avvio del contesto dell'applicazione Spring e arrestato quando il contesto dell'applicazione Spring si arresta. Per disabilitare questa funzionalità, configurare spring.cloud.azure.servicebus.processor.auto-startup=false.

  4. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

    Sent a message to the queue
Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!

Sviluppare client di Service Bus programmaticamente

È possibile creare questi fagioli client da soli, ma il processo è complicato. Nelle applicazioni Spring Boot è necessario gestire le proprietà, apprendere il modello di generatore e registrare il client nel contesto dell'applicazione Spring. Nell'esempio di codice seguente viene illustrato come eseguire questa operazione:

  1. Creare una nuova ServiceBusClientConfiguration classe Java come illustrato nell'esempio seguente. Questa classe viene usata per dichiarare i bean ServiceBusSenderClient e ServiceBusProcessorClient.

    @Configuration(proxyBeanMethods = false)
public class ServiceBusClientConfiguration {

    private static final String SERVICE_BUS_FQDN = "<service-bus-fully-qualified-namespace>";
    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @Bean
    ServiceBusClientBuilder serviceBusClientBuilder() {
        return new ServiceBusClientBuilder()
                   .fullyQualifiedNamespace(SERVICE_BUS_FQDN)
                   .credential(new DefaultAzureCredentialBuilder().build());
    }

    @Bean
    ServiceBusSenderClient serviceBusSenderClient(ServiceBusClientBuilder builder) {
        return builder
               .sender()
               .queueName(QUEUE_NAME)
               .buildClient();
    }

    @Bean
    ServiceBusProcessorClient serviceBusProcessorClient(ServiceBusClientBuilder builder) {
        return builder.processor()
                      .queueName(QUEUE_NAME)
                      .processMessage(ServiceBusClientConfiguration::processMessage)
                      .processError(ServiceBusClientConfiguration::processError)
                      .buildProcessorClient();
    }

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

    private static void processError(ServiceBusErrorContext context) {
        System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                context.getFullyQualifiedNamespace(), context.getEntityPath());
    }
}

    Nota

    Assicurati di sostituire il segnaposto <service-bus-fully-qualified-namespace> con il nome host del Service Bus dal portale di Azure. Sostituire il segnaposto <service-bus-queue-name> con il nome della coda personalizzato configurato nello spazio dei nomi del bus di servizio.

  2. Inietta i bean client nella tua applicazione, come illustrato nell'esempio che segue:

    @SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    private final ServiceBusProcessorClient processorClient;

    public ServiceBusQueueApplication(ServiceBusSenderClient senderClient, ServiceBusProcessorClient processorClient) {
        this.senderClient = senderClient;
        this.processorClient = processorClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(ServiceBusQueueApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // send one message to the queue
        senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
        System.out.printf("Sent a message to the queue");
        senderClient.close();

        System.out.printf("Starting the processor");
        processorClient.start();
        TimeUnit.SECONDS.sleep(10);
        System.out.printf("Stopping and closing the processor");
        processorClient.close();
    }

}

  3. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

    Sent a message to the queue
Starting the processor
...
Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!
Stopping and closing the processor

L'elenco seguente illustra i motivi per cui questo codice non è flessibile o elegante:

  • I nomi della coda/argomento/sottoscrizione e dello spazio dei nomi sono codificati in modo fisso.
  • Se usi @Value per ottenere configurazioni dall'ambiente Spring, non è possibile avere suggerimenti IDE nel file application.properties.
  • Se si ha uno scenario di microservizio, è necessario duplicare il codice in ogni progetto ed è facile commettere errori e rendere difficile la coerenza.

Fortunatamente, non è necessario creare i client bean da te con Spring Cloud Azure. È invece possibile inserire direttamente i fagioli e usare le proprietà di configurazione con cui si ha già familiarità per configurare bus di servizio.

Spring Cloud Azure offre anche le configurazioni globali seguenti per diversi scenari. Per altre informazioni, vedere la sezione Configurazione globale per gli SDK del servizio di Azure di Spring Cloud.

  • Opzioni proxy.
  • Opzioni di ripetizione dei tentativi.
  • Opzioni client di trasporto AMQP.

È anche possibile connettersi a cloud di Azure diversi. Per ulteriori informazioni, vedere Connettersi a cloud diversi di Azure.

Usare il Service Bus di Spring Cloud Azure JMS Starter

Il modulo Starter JMS per Service Bus di Spring Cloud Azure fornisce l'integrazione Spring JMS con Service Bus. Il video seguente descrive come integrare le applicazioni Spring JMS con bus di servizio di Azure usando JMS 2.0.


Questa guida mostra come usare Spring Cloud Azure Service Bus Starter con l'API JMS per inviare messaggi a e ricevere messaggi da Service Bus.

Aggiungere la dipendenza Service Bus

Per installare il modulo Spring Cloud bus di servizio di Azure JMS Starter, aggiungere le dipendenze seguenti al file pom.xml:

  • Spring Cloud Azure Bill of Materials (BOM):

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.19.0. Questa Bill of Material (BOM) deve essere configurata nella sezione <dependencyManagement> del file pom.xml. In questo modo tutte le dipendenze di Spring Cloud Azure usano la stessa versione. Per ulteriori informazioni sulla versione utilizzata per questa BOM, consultare Quale versione di Spring Cloud Azure dovrei usare?.

  • L'artefatto JMS di Spring Cloud Azure Service Bus:

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-servicebus-jms</artifactId>
</dependency>

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

  1. Configurare il stringa di connessione e il piano tariffario per il bus di servizio, come illustrato nell'esempio seguente:

    spring.jms.servicebus.connection-string=<service-bus-namespace-connection-string>
spring.jms.servicebus.pricing-tier=<service-bus-pricing-tier>

  2. Creare il ricevitore di messaggi.

    Spring fornisce i mezzi per pubblicare messaggi in qualsiasi POJO (Plain Old Java Object). Prima di tutto, definire una classe generica User che archivia e recupera il nome dell'utente, come illustrato nell'esempio seguente:

    public class User implements Serializable {

    private static final long serialVersionUID = -295422703255886286L;

    private String name;

    public User() {
    }

    public User(String name) {
        setName(name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

    Suggerimento

    Serializable viene implementato per usare il metodo send in JmsTemplate nel framework Spring. In caso contrario, è necessario definire un bean personalizzato MessageConverter per serializzare il contenuto in JSON in formato testo. Per ulteriori informazioni su MessageConverter, consultare il progetto iniziale ufficiale di Spring JMS.

  3. Da qui è possibile creare una nuova QueueReceiveService classe Java, come illustrato nell'esempio seguente. Questa classe viene usata per definire un ricevitore di messaggi.

    @Component
public class QueueReceiveService {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @JmsListener(destination = QUEUE_NAME, containerFactory = "jmsListenerContainerFactory")
    public void receiveMessage(User user) {
        System.out.printf("Received a message from %s.", user.getName());
    }
}

    Nota

    Assicurarsi di sostituire il segnaposto con il nome della coda <service-bus-queue-name> configurato nel proprio spazio dei nomi del bus di servizio.

    Se si utilizza un argomento o una sottoscrizione, modificare il parametro destination in modo che diventi il nome dell'argomento, e assicurarsi che containerFactory sia topicJmsListenerContainerFactory. Aggiungere anche il subscription parametro per descrivere il nome della sottoscrizione.

  4. Collegare un mittente e un destinatario per inviare e ricevere messaggi con Spring, come illustrato nell'esempio seguente:

    @SpringBootApplication
@EnableJms
public class ServiceBusJmsStarterApplication {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ServiceBusJMSQueueApplication.class, args);
        JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);

        // Send a message with a POJO - the template reuse the message converter
        System.out.println("Sending a user message.");
        jmsTemplate.convertAndSend(QUEUE_NAME, new User("Tom"));
    }
}

    Nota

    Assicurarsi di sostituire il segnaposto <service-bus-queue-name> con il nome della coda personalizzato configurato nel proprio spazio dei nomi del bus di servizio.

    Suggerimento

    Assicurarsi di aggiungere l'annotazione @EnableIntegration, che attiva l'individuazione dei metodi annotati con @JmsListener, creando il contenitore listener dei messaggi in modo trasparente.

  5. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

    Sending a user message.
Received a message from Tom.

Altre informazioni

Per altre informazioni, vedere Come usare l'API JMS con bus di servizio e AMQP 1.0.

Usare Spring Messaging Service Bus di Azure

Il modulo Spring Messaging bus di servizio di Azure fornisce il supporto per il framework Spring Messaging con bus di servizio.

Se si usa Spring Messaging bus di servizio di Azure, è possibile usare le funzionalità seguenti:

  • ServiceBusTemplate: invia messaggi alle code e ai topic di Bus di Servizio in modo asincrono e sincrono.
  • @ServiceBusListener: designare un metodo come target di un ascoltatore di messaggi Service Bus sulla destinazione.

Questa guida illustra come usare Spring Messaging bus di servizio di Azure per inviare e ricevere messaggi da bus di servizio.

Aggiungere la dipendenza Service Bus

Per installare il modulo Spring Messaging bus di servizio di Azure, aggiungere le dipendenze seguenti al file pom.xml:

  • L'Elenco dei Materiali (BOM) di Spring Cloud Azure:

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.19.0. Questa Elenco Materiale (BOM) deve essere configurata nella <dependencyManagement> sezione del tuo file pom.xml. In questo modo tutte le dipendenze di Spring Cloud Azure usano la stessa versione. Per ulteriori informazioni sulla versione utilizzata per questa distinta base, vedere Quale versione di Spring Cloud Azure dovrei utilizzare.

  • Gli artefatti Spring Messaging Service bus e Spring Cloud Azure starter:

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter</artifactId>
</dependency>
<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-messaging-azure-servicebus</artifactId>
</dependency>

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

  1. Configurare lo spazio dei nomi e il tipo di coda per il Service Bus, come illustrato nell'esempio seguente.

    spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
spring.cloud.azure.servicebus.entity-type=queue

    Nota

    Se si usa un argomento o una sottoscrizione, modificare il spring.cloud.azure.servicebus.entity-type valore in topic.

  2. Creare una nuova ConsumerService classe Java come illustrato nell'esempio seguente. Questa classe viene usata per definire un ricevitore di messaggi.

    @Service
public class ConsumerService {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @ServiceBusListener(destination = QUEUE_NAME)
    public void handleMessageFromServiceBus(String message) {
        System.out.printf("Consume message: %s%n", message);
    }

}

    Nota

    Se si usa un argomento o una sottoscrizione, modificare il parametro di annotazione destination come nome dell'argomento e aggiungere il parametro group per descrivere il nome della sottoscrizione.

  3. Collegare un mittente e un destinatario per inviare e ricevere messaggi con Spring, come illustrato nell'esempio seguente:

    @SpringBootApplication
@EnableAzureMessaging
public class Application {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(Application.class);
        ServiceBusTemplate serviceBusTemplate = applicationContext.getBean(ServiceBusTemplate.class);
        System.out.println("Sending a message to the queue.");
        serviceBusTemplate.sendAsync(QUEUE_NAME, MessageBuilder.withPayload("Hello world").build()).subscribe();
    }
}

    Suggerimento

    Assicurarsi di aggiungere l'annotazione @EnableAzureMessaging che attiva l'individuazione dei metodi annotati con @ServiceBusListener, creando in background il contenitore dei listener dei messaggi.

  4. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

    Sending a message to the queue.
Consume message: Hello world.

Usare Spring Integration bus di servizio di Azure

Il modulo Spring Integration Service Bus di Azure fornisce supporto per il framework Spring Integration con il Service Bus.

Se l'applicazione Spring usa canali di messaggio Spring Integration, è possibile instradare i messaggi tra i canali dei messaggi e bus di servizio usando gli adattatori di canale.

Un adattatore di canale in ingresso inoltra i messaggi da una coda o sottoscrizione del Service Bus a un canale di messaggi. Un adattatore di canale in uscita pubblica messaggi da un canale di messaggio a una coda e un argomento nel Service Bus.

Questa guida illustra come usare Spring Integration bus di servizio di Azure per inviare e ricevere messaggi da bus di servizio.

Aggiungere la dipendenza Service Bus

Per installare il modulo Spring Cloud bus di servizio di Azure Integration Starter, aggiungere le dipendenze seguenti al file pom.xml:

  • Spring Cloud Azure Bill of Materials (BOM):

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.19.0. Questa distinta dei materiali deve essere configurata nella <dependencyManagement> sezione del tuo file pom.xml. In questo modo tutte le dipendenze di Spring Cloud Azure usano la stessa versione. Per ulteriori informazioni sulla versione utilizzata per questa distinta base, vedere Quale versione di Spring Cloud Azure dovrei utilizzare.

  • Elemento Spring Cloud bus di servizio di Azure Integration:

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-integration-servicebus</artifactId>
</dependency>

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

  1. Configurare lo spazio dei nomi del Service Bus, come illustrato nell'esempio seguente:

    spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>

  2. Creare una nuova QueueReceiveConfiguration classe Java come illustrato nell'esempio seguente. Questa classe viene usata per definire un ricevitore di messaggi.

    @Configuration
public class QueueReceiveConfiguration {

    private static final String INPUT_CHANNEL = "queue.input";
    private static final String QUEUE_NAME = "<your-servicebus-queue-name>";
    private static final String SERVICE_BUS_MESSAGE_LISTENER_CONTAINER = "queue-listener-container";

    /**
     * This message receiver binding with {@link ServiceBusInboundChannelAdapter}
     * via {@link MessageChannel} has name {@value INPUT_CHANNEL}
     */
    @ServiceActivator(inputChannel = INPUT_CHANNEL)
    public void messageReceiver(byte[] payload) {
        String message = new String(payload);
        System.out.printf("New message received: '%s'%n", message);
    }

    @Bean(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER)
    public ServiceBusMessageListenerContainer messageListenerContainer(ServiceBusProcessorFactory processorFactory) {
        ServiceBusContainerProperties containerProperties = new ServiceBusContainerProperties();
        containerProperties.setEntityName(QUEUE_NAME);
        return new ServiceBusMessageListenerContainer(processorFactory, containerProperties);
    }

    @Bean
    public ServiceBusInboundChannelAdapter queueMessageChannelAdapter(
        @Qualifier(INPUT_CHANNEL) MessageChannel inputChannel,
        @Qualifier(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER) ServiceBusMessageListenerContainer listenerContainer) {
        ServiceBusInboundChannelAdapter adapter = new ServiceBusInboundChannelAdapter(listenerContainer);
        adapter.setOutputChannel(inputChannel);
        return adapter;
    }

    @Bean(name = INPUT_CHANNEL)
    public MessageChannel input() {
        return new DirectChannel();
    }
}

  3. Creare una nuova QueueSendConfiguration classe Java come illustrato nell'esempio seguente. Questa classe viene usata per definire un mittente di messaggi.

    @Configuration
public class QueueSendConfiguration {

    private static final String OUTPUT_CHANNEL = "queue.output";
    private static final String QUEUE_NAME = "<your-servicebus-queue-name>";

    @Bean
    @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
    public MessageHandler queueMessageSender(ServiceBusTemplate serviceBusTemplate) {
        serviceBusTemplate.setDefaultEntityType(ServiceBusEntityType.QUEUE);
        DefaultMessageHandler handler = new DefaultMessageHandler(QUEUE_NAME, serviceBusTemplate);
        handler.setSendCallback(new ListenableFutureCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                System.out.println("Message was sent successfully.");
            }

            @Override
            public void onFailure(Throwable ex) {
                System.out.println("There was an error sending the message.");
            }
        });

        return handler;
    }

    /**
     * Message gateway binding with {@link MessageHandler}
     * via {@link MessageChannel} has name {@value OUTPUT_CHANNEL}
     */
    @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
    public interface QueueOutboundGateway {
        void send(String text);
    }
}

  4. Collegare un mittente e un destinatario per inviare e ricevere messaggi con Spring, come illustrato nell'esempio seguente:

    @SpringBootApplication
@EnableIntegration
@Configuration(proxyBeanMethods = false)
public class ServiceBusIntegrationApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(ServiceBusIntegrationApplication.class, args);
        QueueSendConfiguration.QueueOutboundGateway outboundGateway = applicationContext.getBean(QueueSendConfiguration.QueueOutboundGateway.class);
        System.out.println("Sending a message to the queue");
        outboundGateway.send("Hello World");
    }

}

    Suggerimento

    Assicurarsi di aggiungere l'annotazione @EnableIntegration , che abilita l'infrastruttura Spring Integration.

  5. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

    Message was sent successfully.
New message received: 'Hello World'

Usare il Binder di Service Bus di Spring Cloud Stream

Per chiamare l'API di Service Bus in un'applicazione Spring Cloud Stream, usa il modulo Spring Cloud Azure Service Bus Stream Binder.

Questa guida illustra come usare Spring Cloud Stream bus di servizio Binder per inviare e ricevere messaggi da bus di servizio.

Aggiungere la dipendenza Bus di Servizio

Per installare il modulo Spring Cloud bus di servizio di Azure Stream Binder, aggiungere le dipendenze seguenti al file pom.xml:

  • Spring Cloud Azure Bill of Materials (BOM):

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.19.0. Questa distinta base (BOM) deve essere configurata nella <dependencyManagement> sezione del tuo file pom.xml. In questo modo tutte le dipendenze di Spring Cloud Azure usano la stessa versione. Per ulteriori informazioni sulla versione usata per questa distinta base dei componenti software, consultare Quale versione di Spring Cloud Azure dovrei usare.

  • Artefatto di integrazione del Service Bus di Azure di Spring Cloud.

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-stream-binder-servicebus</artifactId>
</dependency>

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

  1. Configurare lo spazio dei nomi di Service Bus, come illustrato nell'esempio seguente:

    spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>

  2. Creare il ricevitore di messaggi.

    Per usare l'applicazione come ricevitore di eventi, configurare il binder di input specificando le informazioni seguenti:

    • Dichiarare un Consumer bean che definisce la logica di gestione dei messaggi. Ad esempio, il bean seguente Consumer è denominato consume:

      @Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: '%s'.%n", message.getPayload());
    };
}

    • Aggiungere la configurazione per specificare il queue nome per il consumo sostituendo il <service-bus-queue-name> segnaposto, come mostrato nell'esempio seguente:

      # name for the `Consumer` bean
spring.cloud.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>

      Nota

      Per consumare da una sottoscrizione di Service Bus, assicurarsi di modificare le proprietà di associazione di consume-in-0 come illustrato nell'esempio seguente.

      spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>

  3. Creare il mittente del messaggio.

    Per usare l'applicazione come origine evento, configurare il binder di output specificando le informazioni seguenti:

    • Definire un Supplier bean che definisce il punto in cui provengono i messaggi dall'interno dell'applicazione.

      @Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}

    • Aggiungere la configurazione per specificare il nome per l'invio queue sostituendo il <your-servicebus-queue-name> segnaposto nell'esempio seguente:

      # "consume" is added from the previous step
spring.cloud.function.definition=consume;supply
spring.cloud.stream.bindings.supply-out-0.destination=<your-servicebus-queue-name>
spring.cloud.stream.servicebus.bindings.supply-out-0.producer.entity-type=queue

      Nota

      Per inviare a un topic del Service Bus, assicurarsi di modificare entity-type in topic.

  4. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

    Sending a message.
New message received: 'Hello world'.

Distribuire in Azure Spring Apps

Ora che l'applicazione Spring Boot è in esecuzione in locale, è possibile spostarla nell'ambiente di produzione. Azure Spring Apps semplifica la distribuzione di applicazioni Spring Boot in Azure senza modifiche al codice. Il servizio gestisce l'infrastruttura delle applicazioni Spring per consentire agli sviluppatori di concentrarsi sul codice. Azure Spring Apps fornisce la gestione del ciclo di vita tramite funzionalità complete di monitoraggio e diagnostica, gestione della configurazione, individuazione dei servizi, integrazione di CI/CD, distribuzioni blu/verde e altro ancora. Per distribuire l'applicazione in Azure Spring Apps, vedere Distribuire la prima applicazione in Azure Spring Apps.

Passaggi successivi

Azure per sviluppatori SpringEsempi di Service Bus di Azure Spring Cloud

Vedi anche

Per altre informazioni sugli starter Spring Boot disponibili per Microsoft Azure, vedere Che cos'è Spring Cloud Azure?