Explorando Mercury: como implementar aplicações de mensageria em tempo real utilizando frameworks como Apache Kafka e RabbitMQ para otimizar a comunicação entre microsserviços

Introdução

Neste tutorial, vamos explorar como implementar aplicações de mensageria em tempo real utilizando os frameworks Apache Kafka e RabbitMQ. Ambas as tecnologias desempenham um papel crucial na comunicação entre microsserviços, permitindo que diferentes partes de uma aplicação se comuniquem de forma eficiente e escalável. Ao longo deste artigo, abordaremos a implementação prática dessas soluções em um ambiente Java com Spring Boot. Vamos percorrer desde a configuração inicial até a implementação de testes unitários, garantindo que nossos serviços possam se comunicar de maneira confiável e rápida. Ao final, você entenderá como a mensageria pode otimizar a arquitetura de seus microsserviços e melhorar a performance da sua aplicação.

Etapas

Configuração do Ambiente de Desenvolvimento
Certifique-se de ter o JDK (Java Development Kit) e o Maven instalados em sua máquina. Além disso, você precisará do Apache Kafka e RabbitMQ instalados ou em execução em contêineres Docker. Verifique as versões instaladas usando os comandos ‘java -version’ e ‘mvn -version’. Caso não os tenha instalados, siga as instruções oficiais nos sites das respectivas ferramentas.
commands
```
# Verificar versões instaladas
java -version
mvn -version
```

Criação do Projeto Spring Boot

Utilize o Spring Initializr para gerar um novo projeto Spring Boot com as dependências necessárias. Configure o projeto com as opções: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão estável, **Packaging**: Jar, **Java**: 11 ou superior. Adicione as dependências ‘Spring Web’, ‘Spring for Apache Kafka’, ‘Spring for RabbitMQ’ e ‘Spring Boot DevTools’. Baixe e descompacte o projeto em seu ambiente de trabalho.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>mensageria</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>mensageria</name>
  <description>Aplicação de Mensageria com Kafka e RabbitMQ</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.kafka</groupId>
      <artifactId>spring-kafka</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.amqp</groupId>
      <artifactId>spring-amqp</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

Configuração do Kafka
Crie um arquivo de configuração para o Kafka no projeto. Você pode usar o ‘application.properties’ para definir as propriedades de conexão com o Kafka.
application.properties
```
spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=grupo
spring.kafka.topic.nome=microservices-topic
```
Configuração do RabbitMQ
Similar ao Kafka, você irá configurar as propriedades do RabbitMQ no ‘application.properties’.
application.properties
```
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
```

Implementação do Producer Kafka

Implemente a classe ‘KafkaProducerService’ que será responsável por enviar mensagens para o Kafka.

KafkaProducerService.java

package com.example.mensageria.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerService {
    private final KafkaTemplate<String, String> kafkaTemplate;

    @Autowired
    public KafkaProducerService(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendMessage(String message) {
        kafkaTemplate.send("microservices-topic", message);
    }
}

Implementação do Consumer Kafka

Implemente a classe ‘KafkaConsumerService’ que irá processar as mensagens recebidas do Kafka.

KafkaConsumerService.java

package com.example.mensageria.service;

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumerService {
    @KafkaListener(topics = "microservices-topic", groupId = "grupo")
    public void listen(String message) {
        System.out.println("Mensagem recebida do Kafka: " + message);
    }
}

Implementação do Producer RabbitMQ

Implemente a classe ‘RabbitMQProducerService’ que será responsável por enviar mensagens para o RabbitMQ.

RabbitMQProducerService.java

package com.example.mensageria.service;

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

@Service
public class RabbitMQProducerService {
    private final RabbitTemplate rabbitTemplate;

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

    public void send(String message) {
        rabbitTemplate.convertAndSend("queueName", message);
    }
}

Implementação do Consumer RabbitMQ

Implemente a classe ‘RabbitMQConsumerService’ que irá processar as mensagens recebidas do RabbitMQ.

RabbitMQConsumerService.java

package com.example.mensageria.service;

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

@Service
public class RabbitMQConsumerService {
    @RabbitListener(queues = "queueName")
    public void receive(String message) {
        System.out.println("Mensagem recebida do RabbitMQ: " + message);
    }
}

Criando Controladores para Teste

Implemente controladores para as operações de envio de mensagens tanto para Kafka quanto para RabbitMQ.

MessageController.java

package com.example.mensageria.controller;

import com.example.mensageria.service.KafkaProducerService;
import com.example.mensageria.service.RabbitMQProducerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MessageController {
    private final KafkaProducerService kafkaProducerService;
    private final RabbitMQProducerService rabbitMQProducerService;

    @Autowired
    public MessageController(KafkaProducerService kafkaProducerService, RabbitMQProducerService rabbitMQProducerService) {
        this.kafkaProducerService = kafkaProducerService;
        this.rabbitMQProducerService = rabbitMQProducerService;
    }

    @PostMapping("/send/kafka")
    public void sendKafkaMessage(@RequestParam String message) {
        kafkaProducerService.sendMessage(message);
    }

    @PostMapping("/send/rabbitmq")
    public void sendRabbitMessage(@RequestParam String message) {
        rabbitMQProducerService.send(message);
    }
}

Executando a Aplicação e Testes

Use o Maven para compilar e executar a aplicação. Em seguida, utilize ferramentas como Postman ou cURL para testar os endpoints da API.

commands

# Compilar e executar a aplicação
mvn spring-boot:run
# Enviar uma mensagem para Kafka
curl -X POST 'http://localhost:8080/send/kafka?message=HelloKafka'
# Enviar uma mensagem para RabbitMQ
curl -X POST 'http://localhost:8080/send/rabbitmq?message=HelloRabbitMQ'

Conclusão

Neste tutorial, você aprendeu a implementar aplicações de mensageria em tempo real utilizando Apache Kafka e RabbitMQ com Spring Boot. Através da configuração dos producers e consumers, criamos uma arquitetura robusta para a comunicação entre microsserviços. Além disso, a implementação dos controladores nos permite enviar mensagens para ambas as filas de maneira simples. Esses conceitos são fundamentais para a construção de aplicações escaláveis e que necessitam de comunicação assíncrona. Agora você está preparado para expandir ainda mais suas aplicações com funcionalidades de mensageria.

Hashtags

#ApacheKafka #RabbitMQ #SpringBoot #Mensageria #Microsserviços #DesenvolvimentoDeSoftware

copycoda.com.br