Condividi tramite

Usare Azure Service Bus nelle applicazioni Spring

Questo articolo illustra come usare Azure Service Bus nelle applicazioni Java compilate con Spring Framework.

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

Spring Cloud Azure offre vari moduli per l'invio e la ricezione di messaggi da Service Bus queues e topics/subscriptions tramite framework Spring.

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

Prerequisiti

Nota

Per concedere all'account l'accesso alle risorse Service Bus, nello spazio dei nomi Azure Service Bus appena creato, assegnare i ruoli Azure Service Bus Data Sender e Azure Service Bus Data Receiver all'account Microsoft Entra attualmente in uso. Per altre informazioni, vedere Assegnare i ruoli di Azure utilizzando 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 Azure Identity. Spring Cloud Azure usa DefaultAzureCredential, che la libreria di identità 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 Authenticate Azure-hosted Java applications.

Per usare Azure CLI, IntelliJ o altri metodi per completare l'autenticazione negli ambienti di sviluppo locali, vedere autenticazione Azure negli ambienti di sviluppo Java. Per completare l'autenticazione negli ambienti di hosting Azure, è consigliabile usare l'identità gestita. Per altre informazioni, vedere Che sono identità gestite per le risorse Azure?

Nota

Azure Service Bus per l'API JMS attualmente non supporta DefaultAzureCredential. Se si usa Spring JMS con Service Bus, ignorare questo passaggio.

Usare Spring Cloud Azure Service Bus Starter

Il modulo Spring Cloud Azure Service Bus Starter importa Service Bus Java libreria client con spring boot framework. È possibile usare Spring Cloud Azure e i Azure SDK insieme, in un modello non che si escludono a vicenda. È quindi possibile continuare a usare l'API client Service Bus Java nell'applicazione Spring.

Aggiungi la dipendenza di Service Bus

Per installare il modulo Spring Cloud Azure Service Bus Starter, aggiungere le dipendenze seguenti al file pom.xml:

  • L'elenco dei materiali di Spring Cloud Azure (BOM):

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

    Nota

    Se si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.1.0.

    Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.1.0.

    Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

    Questo Bill of Material (BOM) deve essere configurato 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 questo BOM, vedere Quale versione di Spring Cloud Azure dovrei usare.

  • Il componente Spring Cloud Azure Service Bus:

    <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 Service Bus Java 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 l'autoconfigurazione dei bean client dal contenitore di Spring IoC, presenta i seguenti vantaggi rispetto al secondo modo. Questi vantaggi offrono un'esperienza più flessibile ed efficiente durante lo sviluppo con i client 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 offre più client per interagire con Service Bus. Lo starter fornisce anche la configurazione automatica per tutti i client e i generatori client di Service Bus. In questo caso si usano solo ServiceBusSenderClient e ServiceBusProcessorClient come esempi.

Usare la configurazione automatica di Spring Boot

Per inviare e ricevere messaggi da Service Bus, configurare l'applicazione attenendosi alla procedura seguente:

  1. Configura lo spazio dei nomi e la coda di 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

    Ad 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 classe ServiceBusProcessorClientConfiguration 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!

Creare clienti Service Bus a livello di codice

Puoi creare quei bean client da solo, 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 classe ServiceBusClientConfiguration Java come illustrato nell'esempio seguente. Questa classe viene utilizzata 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

    Assicurarsi di sostituire il segnaposto <service-bus-fully-qualified-namespace> con il nome host del Service Bus come indicato nel portale di Azure. Sostituisci il segnaposto <service-bus-queue-name> con il nome della coda configurato nel namespace di Service Bus.

  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, la creazione dei bean client manualmente non è necessaria con Spring Cloud Azure. È invece possibile inserire direttamente i fagioli e usare le proprietà di configurazione che si ha già familiarità con per configurare Service Bus.

Spring Cloud Azure fornisce anche le configurazioni globali seguenti per diversi scenari. Per altre informazioni, vedere la sezione Global configuration for Azure Service SDK della configurazione di Spring Cloud Azure configuration.

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

È anche possibile connettersi a cloud Azure diversi. Per altre informazioni, vedere Connect to different Azure clouds.

Usare Spring Cloud Azure Service Bus JMS Starter

Il modulo Spring Cloud Azure Service Bus JMS Starter fornisce Spring JMS integrazione con Service Bus. Il video seguente descrive come integrare le applicazioni Spring JMS con Azure Service Bus usando JMS 2.0.


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

Aggiungi la dipendenza di Service Bus

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

  • L'elenco dei materiali di Spring Cloud Azure (BOM):

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

    Nota

    Se si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.1.0.

    Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.1.0.

    Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

    Questo Bill of Material (BOM) deve essere configurato 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 questo BOM, vedere Quale versione di Spring Cloud Azure dovrei usare.

  • Il prodotto Spring Cloud Azure Service Bus JMS:

    <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 connection string e il piano tariffario per il Service Bus, 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 consente di 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 classe QueueReceiveService 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

    Assicurati di sostituire il segnaposto <service-bus-queue-name> con il nome della coda configurato nello spazio dei nomi del Service Bus.

    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

    Assicurati di sostituire il segnaposto <service-bus-queue-name> con il nome della coda configurato nello spazio dei nomi del Service Bus.

    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 Service Bus e AMQP 1.0.

Usare Spring Messaging con Azure Service Bus

Il modulo Spring Messaging Azure Service Bus fornisce supporto per Spring Messaging framework con Service Bus.

Se si usa Spring Messaging Azure Service Bus, è possibile usare le funzionalità seguenti:

  • ServiceBusTemplate: inviare messaggi a code e topic di Service Bus in modo asincrono e sincrono.
  • @ServiceBusListener: contrassegnare un metodo per essere il target di un listener di messaggi Service Bus sulla destinazione.

Questa guida illustra come usare Spring Messaging Azure Service Bus per inviare e ricevere messaggi da Service Bus.

Aggiungi la dipendenza di Service Bus

Per installare il modulo Spring Messaging Azure Service Bus, aggiungere le dipendenze seguenti al file pom.xml:

  • L'elenco dei materiali di Spring Cloud Azure (BOM):

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

    Nota

    Se si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.1.0.

    Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.1.0.

    Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

    Questo Bill of Material (BOM) deve essere configurato 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 questo BOM, vedere Quale versione di Spring Cloud Azure dovrei usare.

  • Gli artifact di avvio di Spring Messaging Service Bus e Spring Cloud Azure:

    <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 classe ConsumerService 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 il contenitore listener dei messaggi in modo trasparente.

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

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

Utilizzare Spring Integration con Azure Service Bus

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

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

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

Questa guida illustra come usare Spring Integration Azure Service Bus per inviare e ricevere messaggi da Service Bus.

Aggiungi la dipendenza di Service Bus

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

  • L'elenco dei materiali di Spring Cloud Azure (BOM):

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

    Nota

    Se si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.1.0.

    Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.1.0.

    Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

    Questo Bill of Material (BOM) deve essere configurato 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 questo BOM, vedere Quale versione di Spring Cloud Azure dovrei usare.

  • L'artifatto di Spring Cloud Azure Service Bus 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 classe QueueReceiveConfiguration 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 classe QueueSendConfiguration 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 Spring Cloud Stream Service Bus Binder

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

Questa guida illustra come usare Spring Cloud Stream Service Bus Binder per inviare e ricevere messaggi da Service Bus.

Aggiungi la dipendenza di Service Bus

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

  • L'elenco dei materiali di Spring Cloud Azure (BOM):

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

    Nota

    Se si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.1.0.

    Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.1.0.

    Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

    Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

    Questo Bill of Material (BOM) deve essere configurato 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 questo BOM, vedere Quale versione di Spring Cloud Azure dovrei usare.

  • L'artifatto di Spring Cloud Azure Service Bus Integration:

    <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 del 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 utilizzare da una sottoscrizione Service Bus, assicurarsi di modificare le proprietà di associazione 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 argomento di Service Bus, assicurarsi di modificare il entity-type in topic.

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

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

Distribuire su 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 offre la gestione del ciclo di vita usando monitoraggio e diagnostica completi, gestione della configurazione, individuazione dei servizi, integrazione 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 SpringSpring Cloud Azure Service Bus Samples

Vedi anche

Per ulteriori informazioni sui Spring Boot Starters disponibili per Microsoft Azure, consultare Che cos'è Spring Cloud Azure?

  • Last updated on