Skip to content

Capitulo 01

Jairo Nascimento Sousa edited this page Sep 2, 2025 · 1 revision

A programação reativa

É um paradigma de programação que trata fluxos de dados e a propagação de mudanças. Em vez de executar instruções sequenciais, ela foca em reagir a eventos ou mudanças de estado. De acordo com o Manifesto Reativo, uma aplicação reativa deve ser: resiliente, elástica, responsiva e orientada à mensagem.

Alguns conceitos fundamentais da programação reativa incluem:**

  • Fluxos de dados (stream): sequências de eventos ou valores que são observados e manipulados ao longo do tempo, suportando diversos operadores para se chegar a um resultado. Por exemplo: cliques do usuário, mensagens de uma fila ou alterações em uma base de dados.

  • Observáveis (observable): fontes de dados que podem ser observadas. Eles emitem eventos que os observadores podem escutar e reagir.

  • Observadores (observer): entidades que escutam eventos emitidos pelos observáveis e executam ações em resposta a esses eventos.

  • Operadores: funções que permitem transformar, combinar e filtrar fluxos de dados. Por exemplo: map, filter, merge e concat.

  • Backpressure: maneira de lidar com fluxos de dados que produzem eventos mais rapidamente do que podem ser consumidos. Técnicas de backpressure ajudam a evitar sobrecarga e perda de dados.

A programação reativa é especialmente útil em aplicativos que precisam lidar com muitos eventos ou requerem alta escalabilidade e desempenho, como sistemas de tempo real, aplicações web interativas e processamento de dados assíncrono.

O Spring Framework oferece um excelente conjunto de recursos para trabalhar com programação reativa, principalmente através do projeto Spring WebFlux, como vemos a seguir:

Spring WebFlux

O Spring WebFlux é o módulo do Spring Framework projetado para criar aplicações reativas. Ele oferece suporte a dois modelos de programação:

  • Anotação (Annotation-based): similar ao modelo tradicional do Spring MVC, usando anotações como @Controller, @RestController e @RequestMapping.

  • Funcional (Functional): usando handlers e routers, em que os endpoints são definidos de forma programática.

Reactor

O Reactor é uma biblioteca reativa baseada no padrão Reactive Streams, que serve como base para o Spring WebFlux. Ela fornece dois tipos principais de publicadores:

  • Mono: representa um único valor assíncrono ou vazio.
  • Flux: representa uma sequência de 0 a N valores assíncronos.

Controladores reativos

No Spring WebFlux, você pode definir controladores usando anotações, assim como no Spring MVC, mas retornando os tipos Mono e Flux, citados anteriormente.

WebClient

O WebClient é uma alternativa reativa ao RestTemplate e é usado para fazer chamadas HTTP assíncronas.

Data access com Spring Data R2DBC e Spring Data MongoDB

Para acesso reativo a bancos de dados, o Spring oferece suporte através de projetos como o Spring Data R2DBC, para bancos de dados relacionais, e Spring Data MongoDB, para MongoDB, proporcionando repositórios reativos.

Suporte a SSE (Server-Sent Events) e WebSockets

O Spring WebFlux facilita a criação de aplicações que usam SSE e WebSockets para comunicação bidirecional e em tempo real.

Testes Reativos

Para testes, o Spring fornece suporte para testar fluxos reativos com WebTestClient e StepVerifier.

Para saber mais: diferenças entre Tomcat e Netty

Ao iniciar a aplicação, foi possível perceber que, em vez de visualizarmos o conhecido log: "Tomcat started on port 8080 (http)", ao incluir a dependência do Spring Reactive Web passou a aparecer o log "Netty started on port 8080 (http)". Mas afinal o que é o Netty e qual a sua diferença para o Tomcat?

Tomcat e Netty são servidores de aplicação usados para lidar com requisições e respostas HTTP, mas eles são projetados com diferentes filosofias e objetivos. Leia abaixo as diferenças em detalhes.

Apache Tomcat

1. Arquitetura e modelo de threads

Modelo baseado em threads: Tomcat usa um modelo baseado em threads em que cada requisição é tratada por uma thread separada. Isto pode levar a problemas de escalabilidade quando há um grande número de requisições simultâneas, já que o gerenciamento de threads pode se tornar custoso.

Bloqueio I/O: Tomcat tradicionalmente utiliza I/O bloqueante, em que cada operação de I/O (como leitura de dados do cliente) bloqueia a thread até que a operação seja concluída.

2. Compatibilidade

Java EE (Jakarta EE): Tomcat é um servidor de container de servlet que suporta especificações Java EE (agora Jakarta EE), como Servlets, JSP e WebSockets. Ele é amplamente usado para hospedar aplicações Java tradicionais.

Frameworks Suportados: Ele é frequentemente usado com frameworks como Spring MVC.

3. Configuração e uso

Facilidade de uso: Tomcat é conhecido por sua facilidade de configuração e uso, especialmente para desenvolvedores Java, graças à sua instalação descomplicada, integração nativa com o ecossistema Java e interface intuitiva para gerenciamento de aplicações.

Arquivos de configuração: Utiliza arquivos de configuração XML, como server.xml e web.xml.

Netty

1. Arquitetura e modelo de threads

Modelo assíncrono e não bloqueante: Netty é um framework de rede assíncrono e não bloqueante, projetado para alta escalabilidade. Ele usa um modelo de I/O não bloqueante, em que operações de I/O não bloqueiam a thread que as executa, permitindo que a mesma thread gerencie múltiplas conexões simultâneas de forma eficiente.

Event loop: Utiliza um modelo de loop de eventos (event loop) em que um pequeno número de threads (geralmente igual ao número de núcleos da CPU) processa todas as conexões. Cada thread no event loop processa eventos de múltiplas conexões, melhorando a eficiência e a escalabilidade.

2. Flexibilidade e desempenho

Desempenho alto: Netty é projetado para ser altamente performático e eficiente em termos de recursos, sendo adequado para aplicações que requerem alta taxa de transferência e baixa latência.

Protocolos de rede: Suporta uma ampla gama de protocolos de rede além de HTTP, como TCP, UDP, WebSocket etc.

3. Compatibilidade

Frameworks suportados: Netty não é limitado a Java EE e pode ser usado como base para frameworks reativos e não bloqueantes, como Spring WebFlux e Akka.

Aplicações personalizadas: Netty é altamente configurável e é ideal para a construção de servidores de aplicação personalizados e específicos, em que você tem controle sobre o pipeline de processamento de dados.

4. Complexidade

Maior flexibilidade, maior complexidade: Devido à sua flexibilidade e poder, Netty pode ser mais complexo de configurar e usar em comparação com Tomcat. Requer um entendimento mais profundo de conceitos de programação assíncrona e de rede.

Resumindo

Tomcat é ideal para aplicações Java EE tradicionais com uma abordagem de I/O bloqueante e um modelo de threads simples. É fácil de configurar e usar, mas pode enfrentar problemas de escalabilidade em situações de alta carga.

Netty é melhor para aplicações que requerem alta escalabilidade e desempenho com um modelo de I/O não bloqueante e assíncrono. Apesar de ser mais complexo, é altamente flexível e eficiente, suportando uma variedade de protocolos de rede e casos de uso.

Para saber mais: usando o PostgreSQL com Docker

É possível criar a API e continuar o nosso projeto sem que você precise instalar o banco de dados PostgreSQL, utilizando o Docker para isso. O primeiro passo, é fazer o download e instalação a partir do site oficial do Docker.

Depois de instalado, quando estiver em execução corretamente, abra um terminal e execute o seguinte comando para iniciar um container do PostgreSQL:

docker run --name container-postgresql -e POSTGRES_DB=codechella -e POSTGRES_USER=usuario -e POSTGRES_PASSWORD=senha -p 5432:5432 -d postgres

Este comando faz o seguinte:

--name container-postgresql: Dá um nome ao container. -e POSTGRES_DB=codechella: Define o nome do banco de dados. -e POSTGRES_USER=usuario: Define o nome do usuário. -e POSTGRES_PASSWORD=senha: Define a senha do usuário. -p 5432:5432: Mapeia a porta 5432 do host para a porta 5432 do container. -d postgres: Especifica a imagem do PostgreSQL a ser utilizada.

Feito isso, é necessário alterar a configuração do Spring Boot para se conectar corretamente ao PostgreSQL que está sendo executado a partir do container. No seu projeto Spring Boot, abra o arquivo src/main/resources/application.properties e ajuste as seguintes configurações:

spring.r2dbc.url=r2dbc:postgresql://localhost:5432/codechella
spring.r2dbc.username=usuario
spring.r2dbc.password=senha

spring.flyway.url=jdbc:postgresql://localhost:5432/codechella
spring.flyway.user=usuario
spring.flyway.password=senha

Feito isso, basta executar a aplicação e verificar que os dados foram persistidos corretamente. Lembrando que no comando acima não estamos mapeando o volume, ou seja, ao destruir o container, os dados não serão persistidos. Caso deseje que os dados sejam persistidos é necessário que seja adicionada ao comando acima a flag que mapeia o volume:

docker run --name container-postgresql -e POSTGRES_DB=codechella -e POSTGRES_USER=usuario -e POSTGRES_PASSWORD=senha -p 5432:5432 -v dados-postgres:/var/lib/postgresql/data -d postgres

Também há a possibilidade de criar um arquivo docker-compose.yml para já executar o banco e a aplicação, isso é recomendado quando a aplicação já está completamente pronta, pois você precisará criar a imagem da sua aplicação. Para criar essa imagem, deve-se construir o arquivo jar, geralmente através do comando mvn clean package, quando estamos utilizando o Maven. Abaixo está um exemplo do arquivo Docker Compose para essa aplicação. Ele utiliza uma imagem de uma aplicação feita por mim, já hospedada no Docker Hub:

version: '3.4'

services:
  postgres:
    image: postgres
    container_name: container-postgresql
    environment:
      POSTGRES_DB: codechella
      POSTGRES_USER: usuario
      POSTGRES_PASSWORD: senha
    ports:
      - "5432:5432"

  codechella-webflux:
    image: docker.io/jacquelineoliveira/codechella-webflux:latest
    build:
      context: .
      dockerfile: ./Dockerfile
    depends_on:
      - postgres  
    ports:
      - 8080:8080    
    volumes:
      - .:/app
    environment:
      SPRING_R2DBC_URL: r2dbc:postgresql://postgres:5432/codechella
      SPRING_R2DBC_USERNAME: usuario
      SPRING_R2DBC_PASSWORD: senha
      SPRING_FLYWAY_URL: jdbc:postgresql://postgres:5432/codechella
      SPRING_FLYWAY_USER: usuario
      SPRING_FLYWAY_PASSWORD: senha 

O que aprendemos?

Nesta aula, você aprendeu: O paradigma da programação reativa e o padrão Observer; A utilização do framework Spring para implementação de aplicações reativas; Configuração de um projeto reativo com Spring Webflux e Spring Data R2DBC; Configuração da conexão com banco de dados PostgreSQL usando R2DBC; Utilização do Flyway para migrações de banco de dados em projetos reativos; Implementação de entidades e repositórios reativos no Spring; Construção de um controlador reativo e mapeamento de endpoints; Configuração e verificação de um endpoint GET para retorno de stream de eventos reativos.