TOC

Mensagens com o Spring AMQP

Mensagens com o Spring AMQP

*1. Visão geral *

Neste tutorial, exploraremos a comunicação baseada em mensagens no AMQP usando a estrutura Spring AMQP. Primeiro, abordaremos alguns dos principais conceitos de mensagens. Em seguida, passaremos a um exemplo prático.

===* 2. Comunicação baseada em mensagem __ *

Mensagens é uma técnica para comunicação entre aplicativos. Ele se baseia na passagem de mensagens assíncrona em vez da arquitetura baseada em resposta de solicitação síncrona.* Os produtores e consumidores de mensagens são dissociados por uma camada intermediária de mensagens conhecida como intermediário de mensagens *. Um intermediário de mensagens fornece recursos como armazenamento persistente de mensagens, filtragem de mensagens e transformação de mensagens.

Em um caso de mensagens entre aplicativos gravados em Java, a API JMS (Java Message Service) é comumente usada. Para interoperabilidade entre diferentes fornecedores e plataformas, não poderemos usar clientes e corretores JMS. É aqui que o AMQP é útil .

*3. AMQP - Protocolo avançado de enfileiramento de mensagens __ *

AMQP é uma especificação de fio padrão aberto para comunicação de mensagens assíncronas. Ele fornece uma descrição de como uma mensagem deve ser construída.

====* 3.1 Como o Amqp é diferente do Jms *

Como o AMQP é um padrão de protocolo binário de plataforma neutra, as bibliotecas podem ser escritas em diferentes linguagens de programação e executadas em diferentes ambientes.

Não há bloqueio de protocolo baseado em fornecedor, como é o caso ao migrar de um broker JMS para outro. Para obter mais detalhes, consulte JMS vs AMQP e Entendendo o AMQP. Alguns dos corretores AMQP amplamente utilizados são RabbitMQ , OpenAMQ e StormMQ.

====* 3.2 Entidades AMQP __ *

Resumidamente, o AMQP é composto por trocas, filas e ligações:

  • Exchanges são como agências postais ou caixas de correio e os clientes publicam uma mensagem em uma central AMQP. Existem quatro tipos de troca integrados

  • Troca direta - direciona mensagens para uma fila, correspondendo a uma chave de roteamento completa

  • Fanout Exchange - Encaminha mensagens para todas as filas ligadas a ele

  • Troca de tópico - direciona mensagens para várias filas, correspondendo uma chave de roteamento a um padrão

  • Troca de cabeçalhos - direciona as mensagens com base nos cabeçalhos

  • Queues são vinculados a uma troca usando uma chave de roteamento *Messages são enviadas para uma central com uma chave de roteamento. A central distribui cópias das mensagens para as filas

Para obter mais detalhes, consulte AMQP Concepts e https://spring.io/blog/2011/04/01/routing-topologies- for-performance-and-scalability-with-rabbitmq/[Topologias de roteamento.]

====* 3.3 Spring AMQP *

O Spring AMQP compreende dois módulos: spring-amqp e spring-rabbit. Juntos, esses módulos fornecem abstrações para:

  • Entidades do AMQP - criamos entidades com as classes Message, Queue, Binding e Exchange

  • Gerenciamento de conexões - nos conectamos ao nosso broker RabbitMQ usando um CachingConnectionFactory

  • Publicação de mensagens - usamos um RabbitTemplate para enviar mensagens *Consumo de mensagens - usamos um _ @ RabbitListener_ para ler mensagens de uma fila

===* 4. Configurar um Broker Rabbitmq *

Precisamos de um corretor RabbitMQ disponível para nos conectarmos. A maneira mais simples de fazer isso é usando o Docker para buscar e executar uma imagem RabbitMQ para nós:

docker run -d -p 5672:5672 -p 15672:15672 --name my-rabbit rabbitmq:3-management

Expomos a porta 5672 para que nosso aplicativo possa se conectar ao RabbitMQ.

E expomos a porta 15672 para que possamos ver o que nosso broker RabbitMQ está fazendo através da UI de gerenciamento: http://localhost: 15672 ou da API HTTP: http://localhost: 15672/api/index.html.

===* 5. Criando nosso aplicativo Spring Amqp *

Então, agora vamos criar nosso aplicativo para enviar e receber um simples "Olá, mundo!" mensagem usando o Spring AMQP.

====* 5.1. Dependências do Maven *

Para adicionar os módulos spring-amqp e spring-rabbit ao nosso projeto, adicionamos a dependência spring-boot-starter-amqp ao nosso pom.xml:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
        <version>2.1.6.RELEASE</version>
    </dependency>
</dependencies>

Podemos encontrar a versão mais recente em https://search.maven.org/classic/#search%7Cga%7C1%7C(g%3A%22org.springframework.boot%22%20AND%20a%3A%22spring-boot -starter-amqp% 22) [Maven Central].

====* 5.2 Conexão com o Rabbitmq Broker *

*Usaremos a configuração automática do Spring Boot para criar nossos _ConnectionFactory_, _RabbitTemplate_ e _RabbitAdmin_ beans* . Como resultado, obtemos uma conexão com nosso broker RabbitMQ na porta 5672, usando o nome de usuário e a senha padrão de "guest". Então, apenas anotamos nosso aplicativo com _ @ SpringBootApplication_:
@SpringBootApplication
public class HelloWorldMessageApp {
  //...
}

5.3. Crie nossa fila

*Para criar nossa fila, simplesmente definimos um bean do tipo _Queue _.* _RabbitAdmin_ o encontrará e o vincula à troca padrão com uma chave de roteamento "myQueue":
@Bean
public Queue myQueue() {
    return new Queue("myQueue", false);
}

Definimos a fila como não durável, para que a fila e quaisquer mensagens nela sejam removidas quando o RabbitMQ for parado. Observe, no entanto, que reiniciar nosso aplicativo não terá efeito na fila.

5.4 Envie Nossa Mensagem

Vamos usar o RabbitTemplate para enviar nosso "Olá, mundo!" mensagem:

rabbitTemplate.convertAndSend("myQueue", "Hello, world!");

5.5. Consuma nossa mensagem

Implementaremos um consumidor de mensagem anotando um método com _ @ RabbitListener_:

@RabbitListener(queues = "myQueue")
public void listen(String in) {
    System.out.println("Message read from myQueue : " + in);
}

*6. Executando nosso aplicativo *

Primeiro, começamos o broker RabbitMQ:

docker run -d -p 5672:5672 -p 15672:15672 --name my-rabbit rabbitmq:3-management

Em seguida, executamos o aplicativo de inicialização da primavera executando HelloWorldMessage.java, executando o método _main () _:

mvn spring-boot:run -Dstart-class=com..springamqp.simple.HelloWorldMessageApp

Enquanto o aplicativo estiver sendo executado, veremos que:

  • O aplicativo envia uma mensagem para o intercâmbio padrão com "myQueue" como a chave de roteamento

  • Em seguida, a fila "myQueue" recebe a mensagem *Por fim, o método listen consome a mensagem de "myQueue" e a imprime no console

Também podemos usar a página de gerenciamento do RabbitMQ em http://localhost: 15672 para ver que nossa mensagem foi enviada e consumida.

===* 7. Conclusão*

Neste tutorial, abordamos a arquitetura baseada em mensagens no protocolo AMQP usando o Spring AMQP para comunicação entre aplicativos.

O código fonte completo e todos os trechos de código deste tutorial estão disponíveis em o projeto GitHub.

Related