O que é RabbitMQ? E Como Começar com esse Broker de Msg?

RabbitMQ é um sistema de mensagens de código aberto altamente confiável, flexível e escalável. Ele atua como um intermediário entre diferentes aplicações, permitindo que elas se comuniquem e transmitam mensagens uns aos outros de maneira eficiente e confiável. Criado originalmente pela Rabbit Technologies Ltd. e agora mantido pela Pivotal Software, o RabbitMQ é amplamente utilizado em sistemas distribuídos e arquiteturas de microservices.

Como Funciona o RabbitMQ?

Em sua essência, o RabbitMQ implementa o padrão de mensagens de fila (message queuing) baseado em um protocolo de mensagens padrão conhecido como Advanced Message Queuing Protocol (AMQP). Ele opera por meio de uma fila de mensagens, onde os produtores enviam mensagens para a fila e os consumidores retiram essas mensagens para processamento.

O sistema utiliza uma variedade de conceitos-chave:

Produtor: É o remetente da mensagem, responsável por enviar os dados para o RabbitMQ.
Consumidor: É o destinatário da mensagem, que recebe as mensagens da fila e as processa conforme necessário.
Fila: Armazena as mensagens enviadas pelos produtores até que os consumidores estejam prontos para recebê-las.
Exchange (Troca): Um componente que recebe mensagens dos produtores e decide a que fila enviar com base em regras definidas.

O fluxo básico de mensagens no RabbitMQ:

O produtor publica uma mensagem em uma Exchange específica, especificando a chave de roteamento (routing key).
A Exchange, baseada na chave de roteamento e nas regras definidas, encaminha a mensagem para a(s) fila(s) correta(s).
Os consumidores estão continuamente verificando as filas em busca de novas mensagens. Quando uma mensagem chega, o RabbitMQ a entrega a um consumidor disponível.
O consumidor processa a mensagem e confirma ao RabbitMQ que a mensagem foi recebida e processada com sucesso (acknowledgment). Nesse momento, o RabbitMQ remove a mensagem da fila.

RabbitMQ Exchange 4 Tipos

Vou tentar resumir ao máximo cada tipo de Exchange, mais no geral os 4 tipos tem suas características:

Direct Exchange:
- Esse tipo de exchange faz a roteamento de mensagens para filas baseado em uma correspondência direta entre a chave de roteamento (routing key) da mensagem e a chave de ligação (binding key) da fila.
- Se a chave de roteamento de uma mensagem corresponder exatamente à chave de ligação da fila, a mensagem será entregue a essa fila.
- É útil quando é necessário um roteamento de mensagens simples e direto.
Fanout Exchange:
- O Fanout Exchange distribui todas as mensagens recebidas para todas as filas que estão ligadas a ele.
- Ignora completamente a chave de roteamento. Quando uma mensagem é publicada em um Fanout Exchange, ela é entregue a todas as filas ligadas a esse exchange, independentemente da chave de roteamento.
- É ideal para cenários em que é necessário que várias filas recebam as mesmas mensagens simultaneamente, como broadcasting.
Topic Exchange:
- O Topic Exchange roteia mensagens para filas com base em padrões de correspondência entre a chave de roteamento da mensagem e a chave de ligação da fila.
- Permite a utilização de padrões (wildcards) para fazer corresponder múltiplas chaves de roteamento.
- As chaves de roteamento são strings delimitadas por pontos, permitindo criar padrões de roteamento flexíveis. Por exemplo, .logs, user.*, #.error.
- É útil quando se necessita de um roteamento mais avançado e flexível, com base em critérios mais complexos.
Headers Exchange:
- O Headers Exchange roteia mensagens com base em múltiplos atributos que são combinados em um cabeçalho (headers) da mensagem.
- Ao contrário dos outros tipos de exchanges, o roteamento ocorre com base nos atributos de cabeçalho (headers) da mensagem, não na chave de roteamento ou na chave de ligação.
- As filas são vinculadas ao exchange especificando um conjunto de argumentos de cabeçalho a serem correspondidos.
- É útil quando o roteamento de mensagens depende de múltiplos atributos complexos ou personalizados.

RabbitMQ com Spring Boot

Para começarmos, precisamos adiciona uma dependência do AMQP que é o protocolo onde o RabbitMQ utiliza, falamos dele no inicio do artigo, bom então vamos adiciona-lo no pom.xml:

<dependencies>
    <!-- Dependências do Spring Boot -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
   <!-- Dependência do RabbitMQ -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
</dependencies>

Agora com a dependência precisamos criar uma classe de configuração no Spring Boot, para definir qual será o nome da fila, nome da exchange e também a routing_key, veremos abaixo como a classe deve ficar:

package br.com.virandoprogramador.config

import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    public static final String QUEUE_NAME = "nome_da_fila";
    public static final String EXCHANGE_NAME = "nome_da_exchange";
    public static final String ROUTING_KEY = "routing_key";

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setRoutingKey(ROUTING_KEY);
        rabbitTemplate.setQueue(QUEUE_NAME);
        rabbitTemplate.setExchange(EXCHANGE_NAME);
        return rabbitTemplate;
    }
}

A classe RabbitMQConfig é uma classe de configuração no contexto do Spring Boot que define a configuração necessária para integrar e utilizar o RabbitMQ na aplicação. Ela contém um método rabbitTemplate() que é anotado com @Bean, indicando que este método será responsável por criar e configurar um RabbitTemplate utilizado para interagir com o RabbitMQ.

Agora vamos criar a classe que vai ser responsável por enviar uma mensagem para o tópico

package br.com.virandoprogramador.listener

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Sender {

    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public Sender(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, RabbitMQConfig.ROUTING_KEY, message);
        System.out.println("Mensagem enviada: " + message);
    }
}

Este método é responsável por enviar mensagens para o RabbitMQ. Ele recebe uma mensagem como parâmetro e utiliza o método convertAndSend() do RabbitTemplate para publicar a mensagem na troca (exchange) especificada (RabbitMQConfig.EXCHANGE_NAME) e com a chave de roteamento especificada (RabbitMQConfig.ROUTING_KEY).

Agora que já temos uma classe que envia mensagem para o tópico, precisamos criar uma outra configuração que seria o serviço que escuta a fila:

package br.com.virandoprogramador.listener

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class Receiver {

    @RabbitListener(queues = RabbitMQConfig.QUEUE_NAME)
    public void receiveMessage(String message) {
        System.out.println("Mensagem recebida: " + message);
    }
}

O método receiveMessage() é anotado com @RabbitListener. Essa anotação indica ao Spring que esse método deve ser acionado sempre que uma mensagem for recebida na fila específica definida na anotação (no caso, RabbitMQConfig.QUEUE_NAME). o nome da sua queue que você configurou.

Por fim não se esqueça de realizar as configurações no seu arquivo Properties, definindo exatamente os parâmetros de conexão com seu RabbitMQ, seja ele instalado localmente ou em um container Docker.

# Configurações de conexão com o RabbitMQ
spring.rabbitmq.host=  seu_host_do_rabbitmq
spring.rabbitmq.port=  sua_porta_do_rabbitmq
spring.rabbitmq.username=  seu_usuario_do_rabbitmq
spring.rabbitmq.password=  sua_senha_do_rabbitmq

Em Resumo sobre este Broker

O RabbitMQ é um poderoso e flexível sistema de mensageria de código aberto, altamente confiável e escalável, que facilita a comunicação assíncrona entre diferentes partes de um sistema distribuído. Ele desempenha um papel bem importante na construção de arquiteturas de aplicativos modernas, permitindo a troca de mensagens entre componentes de forma eficiente e confiável.

Com sua flexibilidade sendo um dos pontos mais chamativos dele, varias tecnologias além do Java tem suporte para utilizar esse sistema de mensageria.

Principais pontos sobre ele:

Arquitetura de Mensageria: O RabbitMQ segue o modelo de mensageria baseado em filas, permitindo que diferentes partes de uma aplicação se comuniquem de maneira assíncrona e desacoplada, o que aumenta a flexibilidade e a escalabilidade do sistema.
Padrões de Troca de Mensagens: Oferece diferentes padrões de troca de mensagens, como filas, trocas (exchanges), chaves de roteamento e bindings, que permitem encaminhar e distribuir mensagens de acordo com regras específicas, atendendo às necessidades de diferentes cenários de aplicativos.
Confiabilidade e Segurança: Garante a confiabilidade no processamento de mensagens, fornecendo mecanismos de confirmação, persistência e durabilidade das mensagens. Além disso, oferece recursos de segurança, como autenticação, autorização e criptografia, protegendo a comunicação entre os componentes.
Integração com Spring Boot: O RabbitMQ é facilmente integrado a aplicativos Spring Boot por meio do Spring AMQP, fornecendo abstrações convenientes para o envio e recebimento de mensagens, permitindo a configuração eficiente de filas, trocas e chaves de roteamento.
Escalabilidade e Desempenho: Sua arquitetura distribuída e orientada a filas permite que seja escalado horizontalmente para lidar com um grande volume de mensagens, garantindo um desempenho confiável mesmo em ambientes complexos.
Flexibilidade e Interoperabilidade: O RabbitMQ suporta vários protocolos de mensageria, como AMQP (Advanced Message Queuing Protocol), MQTT, STOMP, o que o torna altamente flexível e compatível com diferentes tipos de aplicativos e cenários de uso.