Implementando uma estratégia de ‘Inform’ em projetos de software: como usar o framework de comunicação assíncrona Apache Kafka para otimizar a troca de dados entre microserviços.

Introdução

A crescente adoção de arquiteturas de microserviços tem levado os desenvolvedores a buscar soluções eficientes para a comunicação entre esses serviços de forma assíncrona. Uma das ferramentas mais populares para este propósito é o Apache Kafka, um sistema de mensagens que facilita a troca de dados em tempo real. Neste tutorial, vamos explorar como implementar uma estratégia de ‘Inform’ utilizando o Kafka em um ambiente Spring Boot. Você aprenderá a configurar o Kafka, criar produtores e consumidores e, finalmente, testar a comunicação entre microserviços. O objetivo é oferecer uma base sólida para integrar serviços de forma eficiente, escalável e resiliente, transformando dados em informações relevantes rapidamente.

Etapas

Configuração do Ambiente de Desenvolvimento
Comece certificando-se de ter o JDK (Java Development Kit) e o Maven instalados na sua máquina. Além disso, para trabalhar com o Kafka, o Apache Kafka e o ZooKeeper precisam estar configurados. Você pode usar o Docker ou instalar o Kafka diretamente no seu sistema. Para este tutorial, optaremos pela configuração manual do Kafka.
commands
```
# Verifique se o Java e Maven estão instalados
java -version
mvn -version
# Baixe e instale o Apache Kafka
# Siga as instruções de configuração no site oficial do Kafka
```

Criação do Projeto Spring Boot

Utilize o Spring Initializr para gerar um novo projeto Spring Boot. Certifique-se de adicionar as dependências para o Kafka e o Spring Web. As configurações iniciais incluem: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão estável, **Packaging**: Jar, **Java**: 11 ou superior. Acesse o site do Spring Initializr e configure seu projeto conforme necessário.

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.kafka</groupId>
  <artifactId>kafka-inform</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>kafka-inform</name>
  <description>Projeto Spring Boot com Apache Kafka</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.kafka</groupId>
      <artifactId>spring-kafka</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 no `application.properties`

Edite o arquivo `application.properties` para configurar as propriedades do Kafka, incluindo informações sobre o broker. Isso é essencial para que nossa aplicação consiga se comunicar com o Kafka.

application.properties

spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=my-group
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

Criação do Produtor Kafka

Implemente um produtor Kafka que será responsável por enviar as mensagens. Crie uma classe chamada `KafkaProducerService` para encapsular a lógica de produção de mensagens.

KafkaProducerService.java

package com.example.kafka.service;

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

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

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

Criação do Consumidor Kafka

Agora, crie uma classe chamada `KafkaConsumerService` para implementar um consumidor que irá ouvir as mensagens publicadas no Kafka. Também, adicione a anotação `@KafkaListener` para escutar o tópico apropriado.

KafkaConsumerService.java

package com.example.kafka.service;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumerService {

    @KafkaListener(topics = "example-topic", groupId = "my-group")
    public void listen(ConsumerRecord<String, String> record) {
        System.out.printf("Received Message: %s%n", record.value());
    }
}

Criação do Controlador para Testar o Produtor

Implemente um controlador chamado `KafkaController` que expõe um endpoint para enviar mensagens através do produtor. Isso facilitará o teste da produção de mensagens no Kafka.

KafkaController.java

package com.example.kafka.controller;

import com.example.kafka.service.KafkaProducerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/kafka")
public class KafkaController {

    @Autowired
    private KafkaProducerService kafkaProducerService;

    @PostMapping("/publish/{message}")
    public void publishMessage(@PathVariable String message) {
        kafkaProducerService.sendMessage("example-topic", message);
    }
}

Implementação de Testes Unitários

Crie testes unitários para o `KafkaProducerService` utilizando Mockito. Isso garantirá que sua lógica de produção de mensagens funcione corretamente.

KafkaProducerServiceTest.java

package com.example.kafka.service;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

public class KafkaProducerServiceTest {

    @InjectMocks
    private KafkaProducerService kafkaProducerService;

    @Mock
    private KafkaTemplate<String, String> kafkaTemplate;

    @BeforeEach
    public void init() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testSendMessage() {
        String topic = "example-topic";
        String message = "Hello, Kafka!";
        kafkaProducerService.sendMessage(topic, message);
        verify(kafkaTemplate).send(topic, message);
    }
}

Executando a Aplicação e Testes
Compile e execute a aplicação com o Maven e utilize ferramentas como Postman ou cURL para testar a publicação de mensagens no Kafka. Verifique se as mensagens estão sendo recebidas pelo consumidor.
commands
```
# Compilar e executar a aplicação
mvn spring-boot:run
# Usar cURL para publicar uma mensagem
curl -X POST http://localhost:8080/kafka/publish/'Hello Kafka!'
```

Conclusão

Neste tutorial, você aprendeu como implementar uma estratégia de ‘Inform’ utilizando o Apache Kafka em um projeto Spring Boot. Desde a configuração do ambiente e do Kafka até a criação de produtores e consumidores, cobrimos todos os aspectos necessários para otimizar a troca de dados entre microserviços. Com a capacidade de enviar e ouvir mensagens, seu sistema ganha em escalabilidade e eficiência. Agora, você pode expandir essa implementação para atender às suas necessidades específicas e escalar sua aplicação.

Hashtags

#Java #SpringBoot #ApacheKafka #Microserviços #DesenvolvimentoDeSoftware

copycoda.com.br