Formazione
Modulo
È possibile inviare e ricevere messaggi dal bus di servizio di Azure con le applicazioni Spring Boot.
Questo browser non è più supportato.
Esegui l'aggiornamento a Microsoft Edge per sfruttare i vantaggi di funzionalità più recenti, aggiornamenti della sicurezza e supporto tecnico.
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:
Spring Cloud bus di servizio di Azure Starter consente di inviare e ricevere messaggi con la libreria client bus di servizio Java SDK con le funzionalità spring boot.
Spring Cloud bus di servizio di Azure JMS Starter consente di usare l'API JMS per inviare e ricevere messaggi con bus di servizio code e argomenti/sottoscrizioni.
Spring Messaging bus di servizio di Azure consente di interagire con bus di servizio tramite l'API Spring Messaging.
Spring Integration bus di servizio di Azure consente di connettere i canali di messaggio spring integration con bus di servizio.
Spring Cloud Stream Binder per bus di servizio consente di usare bus di servizio come middleware di messaggistica nelle applicazioni Spring Cloud Stream.
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.
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.
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.
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.18.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 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>
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.
Per inviare e ricevere messaggi da bus di servizio, configurare l'applicazione attenendosi alla procedura seguente:
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
.
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());
};
}
}
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
.
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!
È 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:
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.
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();
}
}
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:
@Value
per ottenere configurazioni dall'ambiente Spring, non è possibile avere hint IDE nel file application.properties .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 del servizio di Azure di Spring Cloud.
È anche possibile connettersi a cloud di Azure diversi. Per altre informazioni, vedere Connettersi a cloud di Azure diversi.
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.
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.18.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 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>
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>
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.
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.
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.
Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:
Sending a user message.
Received a message from Tom.
Per altre informazioni, vedere Come usare l'API JMS con bus di servizio e AMQP 1.0.
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.
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.18.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 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>
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
.
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 group
parametro per descrivere il nome della sottoscrizione.
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.
Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:
Sending a message to the queue.
Consume message: Hello world.
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.
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.18.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 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>
Configurare lo spazio dei nomi del bus di servizio, come illustrato nell'esempio seguente:
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
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();
}
}
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);
}
}
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.
Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:
Message was sent successfully.
New message received: 'Hello World'
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.
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.18.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 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>
Configurare lo spazio dei nomi del bus di servizio, come illustrato nell'esempio seguente:
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
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>
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-type
topic
.
Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:
Sending a message.
New message received: 'Hello world'.
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.
Per altre informazioni sugli starter Spring Boot disponibili per Microsoft Azure, vedere Che cos'è Spring Cloud Azure?
Formazione
Modulo
È possibile inviare e ricevere messaggi dal bus di servizio di Azure con le applicazioni Spring Boot.