🔧 Produzindo e ouvindo eventos com Spring Boot

Olá, nesse artigo irei mostrar uma pequena parte do mundo de arquitetura orientada a eventos, resumidamente utilizando Apache Kafka e Spring Boot.

Instalação do Apache Kafka

Para começar nosso projeto precisamos de um servidor Kafka rodando em nossa máquina, para isso iremos utilizar o Docker.

1. Baixar imagem do Apache Kafka

docker pull apache/kafka:3.9.0

2. Iniciar um container com a imagem

docker run -p 9092:9092 apache/kafka:3.9.0

Após isso você terá um container rodando na porta 9092

Começar nosso projeto

Para isso iremos criar o projeto no https://start.spring.io/.
Vamos instalar as dependências do Spring Web e Spring for Apache Kafka.

Recomendo utilizar o Offset Explorer para ver os tópicos e partições

Configurar produtor e consumidor em nosso Projeto

Aqui está o pulo do gato, o Spring fornece uma integração simplificada com o Apache Kafka, sem necessidade de realizar diversas configurações, claro que dependendo do cenário que você está será necessário ter algo mais personalizado.
O código abaixo será responsável por criar um tópico e as partições do mesmo:

import org.apache.kafka.clients.admin.NewTopic;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.TopicBuilder;

@Configuration
@EnableKafka
public class KafkaConfig {

    @Bean
    public NewTopic newTopic() {
        return TopicBuilder.name("topico")
                .partitions(1)
                .build();
    }

}

Criamos apenas um tópico com o nome "topico" e que tem apenas uma partições, caso queira criar vários tópicos será necessário criar um bean pra cada tópico.
Após isso já temos nosso tópico rodando e pronto para enviar eventos nele, agora no código abaixo iremos produzir e ouvir os eventos:

package br.com.kafka.kafka.controllers;

import br.com.kafka.kafka.models.Mensagem;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/mensagem")
public class MensagemController {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    @PostMapping
    public void send(@RequestBody Mensagem mensagem) {
        kafkaTemplate.send("topico", mensagem.toString());
    }

    @KafkaListener(groupId = "group-1", topics = "topico")
    public void listener(ConsumerRecord<String, String > event) throws Exception {
        System.out.println(event.value());
    }


}

Com isso já podemos brincar com algo, realizar integrações entre sistemas, lembrando que para manter um broker de eventos é bem custoso, mas em compensação seu sistema terá uma disponibilidade maior e caso ter algum erro o seu usuário final não ficará sabendo.
Basicamente é isso pretendo explorar afundo em outros artigos, como criar configurações personalizadas, adicionar serialização e deserialização de JSON para facilitar o escuta de eventos.