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 e la ricezione di messaggi da code e sottoscrizioni di argomenti/bus di servizio tramite Spring Framework.

È 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 bus di servizio, nello spazio dei nomi bus di servizio di Azure appena creato assegnare il mittente dati bus di servizio di Azure e bus di servizio di Azure ricevitore dati ruoli per l'account Microsoft Entra in uso. 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

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

Usare Spring Cloud bus di servizio di Azure Starter

Il modulo Spring Cloud bus di servizio di Azure Starter importa bus di servizio libreria client 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 bus di servizio

Per installare il modulo Spring Cloud bus di servizio di Azure 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.11.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.17.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 altre informazioni sulla versione usata per questa distinta base, vedere La versione di Spring Cloud azure da usare.

  • Artefatto di Spring Cloud bus di servizio di Azure:

    <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 client bus di servizio.

  • È 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 bus di servizio offre più client per interagire con bus di servizio. 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. Configurare lo spazio dei nomi e la coda bus di servizio, 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 bus di servizio coda. 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!

Compilare client bus di servizio a livello di codice

È 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 ServiceBusSenderClient fagioli 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 con il <service-bus-fully-qualified-namespace> nome host bus di servizio dal portale di Azure. Sostituire il segnaposto con il <service-bus-queue-name> nome della coda personalizzato configurato nello spazio dei nomi bus di servizio.

  2. Inserire i fagioli client nell'applicazione, come illustrato nell'esempio seguente:

    @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 normale:

  • I nomi dello spazio dei nomi e della coda/argomento/sottoscrizione sono hardcoded.
  • Se si usano @Value per ottenere configurazioni dall'ambiente Spring, non è possibile avere hint 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 fagioli client da soli non è necessaria 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 dei servizi di Azure della Guida per sviluppatori di Spring Cloud Azure.

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

È anche possibile connettersi a cloud di Azure diversi. Per altre informazioni, vedere Connessione a cloud di Azure diversi.

Usare Spring Cloud bus di servizio di Azure JMS Starter

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


Questa guida illustra come usare Spring Cloud bus di servizio di Azure Starter per l'API JMS 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 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.11.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.17.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 altre informazioni sulla versione usata per questa distinta base, vedere La versione di Spring Cloud azure da usare.

  • L'artefatto di Spring Cloud bus di servizio di Azure 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 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 altre informazioni su MessageConverter, vedere il progetto dell'utilità di avvio Spring per il JMS ufficiale.

  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 <service-bus-queue-name> nome della coda personalizzato configurato nello spazio dei nomi bus di servizio.

    Se si usa un argomento o una sottoscrizione, modificare il destination parametro come nome dell'argomento e deve containerFactory essere 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 con il <service-bus-queue-name> nome della coda personalizzato configurato nello spazio dei nomi bus di servizio.

    Suggerimento

    Assicurarsi di aggiungere l'annotazione, che attiva l'individuazione @EnableIntegration dei metodi annotati con @JmsListener, creando il contenitore listener dei messaggi sotto le quinte.

  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 bus di servizio 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 a code e argomenti bus di servizio in modo asincrono e sincrono.
  • @ServiceBusListener: contrassegnare un metodo come destinazione di un listener di messaggi bus di servizio nella 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 bus di servizio

Per installare il modulo Spring Messaging bus di servizio di Azure, 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.11.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.17.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 altre informazioni sulla versione usata per questa distinta base, vedere La versione di Spring Cloud azure da usare.

  • Gli artefatti spring Messaging bus di servizio 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 bus di servizio, 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 di come nome dell'argomento destination e aggiungere il subscription parametro 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, che attiva l'individuazione @EnableAzureMessaging dei metodi annotati con @ServiceBusListener, creando il contenitore listener dei messaggi sotto le quinte.

  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 bus di servizio di Azure fornisce supporto per spring integration framework con bus di servizio.

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 canale in ingresso inoltra i messaggi da una coda di bus di servizio o una sottoscrizione a un canale di messaggio. Un adattatore di canale in uscita pubblica messaggi da un canale di messaggio a una coda e un argomento bus di servizio.

Questa guida illustra come usare Spring Integration bus di servizio di Azure 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 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.11.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.17.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 altre informazioni sulla versione usata per questa distinta base, vedere La versione di Spring Cloud azure da usare.

  • 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 bus di servizio, 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 Spring Cloud Stream bus di servizio Binder

Per chiamare l'API bus di servizio in un'applicazione Spring Cloud Stream, usare il modulo Spring Cloud bus di servizio di Azure 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.11.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.17.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 altre informazioni sulla versione usata per questa distinta base, vedere La versione di Spring Cloud azure da usare.

  • Elemento Spring Cloud bus di servizio di Azure 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 bus di servizio, 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 sink di eventi, configurare il gestore di associazione 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 l'utilizzo sostituendo il <service-bus-queue-name> segnaposto, come illustrato 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 bus di servizio, assicurarsi di modificare le proprietà di consume-in-0 associazione 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 gestore di associazione 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 bus di servizio, assicurarsi di modificare in entity-typetopic.

  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 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

Esempi di Spring Cloud per sviluppatoriSpring bus di servizio di Azure Cloud

Vedi anche

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