Java e Spring: construindo aplicações reativas com WebFlux

Criando uma API reativa - Apresentação

Olá! Eu sou Jacqueline Oliveira, engenheira de software e instrutora na Alura.

Audiodescrição: Jacqueline se identifica como uma mulher de pele branca. Possui cabelos loiros e longos. No corpo, usa uma blusa rosa. Ao fundo, um cômodo iluminado em tons de azul, com uma parede lisa e uma estante à direita, na qual há vasos, livros e estátuas.

Bosa-vindas a mais um curso de Spring. Desta vez, nosso foco será em programação reativa usando o Spring WebFlux.

Conhecendo o projeto

Durante o desenvolvimento do projeto, criaremos uma API reativa para o projeto CodeChella, um site de eventos onde haverá vendas de ingressos. Nosso objetivo é que a propagação de mudanças ocorra em tempo real para a clientela a cada venda de ingresso. Assim, a pessoa que está na fila aguardando para comprar seu ingresso saberá em que posição está e se, eventualmente, o ingresso foi esgotado.

A ideia é proporcionar interação em tempo real com requisições assíncronas e não bloqueantes.

O que aprenderemos?

Durante o curso, veremos as dependências necessárias para trabalhar de forma assíncrona. Teremos acesso ao banco de dados para persistência e busca de informações de forma assíncrona.

Também consumiremos uma API de tradução de textos de forma não bloqueante para não prejudicar nossa aplicação. Implementaremos testes assíncronos e utilizaremos a ferramenta Apache AB para comparar o desempenho de uma API reativa com uma API servlet.

Pré-requisitos

É importante ter noções de Java, Programação Orientada a Objetos e Spring. Além disso, é essencial ter concluído os cursos listados como pré-requisitos, pois é necessário saber como construir uma API REST baseada em servlet, por exemplo.

Faremos comparações entre uma API servlet e nossa API reativa. Portanto, é fundamental se atentar aos pré-requisitos. Se você ainda não os concluiu, é recomendável fazer isso para garantir o melhor aproveitamento possível do curso.

Vamos começar!

Criando uma API reativa - Inicializando o projeto

Para iniciar os estudos, vamos conhecer nosso projeto: o CodeChella.

Explorando o projeto

A ideia desse site é cadastrar vários eventos e realizar a venda de ingressos. Existem diferentes setores, como camarote, pista e pista premium, e o foco será na programação reativa.

Esse projeto é um forte candidato para usar programação reativa. Por exemplo, em shows de artistas populares, como a Taylor Swift, os ingressos esgotam em minutos. Nesses casos, ao acessar o site, entramos numa fila, na qual nossa posição é atualizada constantemente.

Isso exemplifica o padrão Observer (observador), onde nos inscrevemos para receber atualizações sobre o status dos ingressos. Do lado do sistema, havia um publicador informando a nossa posição na fila e o estoque de ingressos, propagando essa mudança no fluxo de dados.

A programação reativa é um paradigma orientado a eventos, com operações assíncronas e não bloqueantes, permitindo resiliência, baixa latência e eficiência nas aplicações.

Ao longo do curso, discutiremos quando usar ou não essa técnica.

Conhecendo a documentação do Spring

Nesse curso, exploraremos a documentação do Spring, um framework poderoso que permite construir aplicações reativas. Ele funciona com o Project Reactor e oferece comparativos entre stacks reativas e servlet.

Para aplicações reativas, utilizamos o Netty, Reactive Streams Adapter, Spring Security Reactive, Spring WebFlux e Spring Data Reactive Repositories. Neste curso, trabalharemos com os dois últimos.

Em relação ao Spring Data, utilizaremos o R2DBC, pois estamos utilizando o banco de dados Postgres.

Iniciando o projeto

Vamos iniciar o projeto pelo site start.spring.io, conhecido de quem concluiu os cursos anteriores. Em seu interior, na seção "Project", selecionaremos a opção "Maven" como gerenciador de dependências.

Na seção "Language", selecionaremos a linguagem "Java". Na seção "Project Metadata" (metadados do projeto), escreveremos o seguinte pacote no campo "Package name":

br.com.alura

No campo "Artifact" (artefato), escreveremos o nome da aplicação:

codechella

No campo "Packaging", o empacotamento será "Jar" e no campo "Java", selecionaremos a versão 21, a última LTS no momento da gravação deste vídeo.

Na seção "Dependencies" (dependências), no lado direito da tela, perceberemos as primeiras diferenças ao configurar APIs relativas ou servlet. Clicando no botão "ADD DEPENDENCIES" ("ADICIONAR DEPENDÊNCIAS"), um campo de busca e uma lista de resultados abaixo dela serão exibidos. Ao digitar "reactive", selecionaremos o resultado "Spring Reactive Web".

Clicando novamente no botão anterior, digitaremos e selecionaremos a dependência "Spring Data R2DBC" para trabalhar com bancos de dados relacionais, com suporte a operações assíncronas.

Por fim, incluiremos também as dependências do Postgres, a "PostgreSQL Driver" — que já inclui o JDBC e R2DBC — e "Flyway Migration", para criar tabelas e colunas através de scripts.

Após clicar no botão "GENERATE", na parte inferior da tela, para gerar o projeto, descompactaremos o arquivo codechella.zip e o abriremos no IntelliJ.

Ao executar esse projeto dentro do arquivo CodechellaApplication.java ele abrirá o terminal na parte inferior da IDE, na qual solicitará a configuração do banco de dados.

Conectando a aplicação ao banco

Observação: Neste curso, utilizaremos a versão 15 do PostgreSQL. Contudo, sinta-se à vontade para utilizar outra versão.

Acessando o PgAdmin do PostgreSQL, no explorador lateral esquerdo, clicaremos na pasta raiz "PostgreSQL 15" e selecionaremos "Create > Database" para criar o banco.

Na janela exibida, digitaremos o nome abaixo no campo "Database" e clicaremos no botão "Save" na parte inferior.

codechella

Em seguida, voltando ao IntelliJ, configuraremos a conexão no arquivo application.properties, localizado no caminho de pastas "src > main > java > resources". A partir da linha 3, informaremos que a conexão será feita com R2DBC, usando:

• spring.r2dbc.url, que receberá a URL de conexão ao banco r2dbc:postgresql://localhost/codechella;
• spring.r2dbc.username, que receberá a variável de ambiente ${DB_USER};
• spring.r2dbc.password, que receberá a variável de ambiente ${DB_PASSWORD}.

No caso do vídeo, adicionamos as variáveis de ambiente de pessoa usuária e senha configuradas anteriormente. Você deve adicionar suas próprias variáveis.

application.properties:

spring.application.name=codechella

spring.r2dbc.url=r2dbc:postgresql://localhost/codechella
spring.r2dbc.username=${DB_USER}
spring.r2dbc.password=${DB_PASSWORD}

Executando a aplicação

Após configurar, executaremos a aplicação. A aba de log será aberta na parte inferior do IntelliJ e indicará que o Netty iniciou na porta 8080, confirmando a conexão.

Netty started on port 8080 (http)

Diferente do Tomcat, utilizado em APIs servlet, o Netty suporta operações assíncronas e não bloqueantes. Entre as atividades, incluiremos as diferenças entre ambos.

Acessando o endereço da aplicação no navegador, verificaremos que a porta 8080 está acessível e escutando requisições.

localhost:8080

Próximos passos

Com a primeira etapa concluída, criamos o projeto e definimos a conexão. A seguir, precisamos tratar as migrations para criar a tabela que armazenará eventos de show, teatro e palestra, além de criar o controlador e iniciar as requisições.

Criando uma API reativa - Incluindo as migrations

Continuando o curso, criaremos migrations (migrações) para criar a tabela de eventos e inserir dados nela.

Adicionando a primeira migration

No explorador lateral, dentro da pasta "resources", há outra pasta chamada "db.migration", dentro da qual criaremos os arquivos. Clicaremos nela com o botão direito e selecionaremos "New > File".

Na janela exibida, usaremos a nomenclatura padrão das migrações no campo "Name":

V001__create_table_eventos.sql

Neste nome, o V001 se refere à versão 01 da migration e create_table_eventos corresponde a um nome intuitivo do que queremos realizar com ela. Por fim, a extensão é .sql.

A próxima janela exibida perguntará se queremos adicionar automaticamente no Git. Clicaremos em "Add" para confirmar.

Após isso, a guia do arquivo V001__create_table_eventos.sql será aberta na área do editor. Em seu interior, colaremos um script pronto, disponível abaixo e entre as atividades desta aula.

V001__create_table_eventos.sql:

create table eventos(
    id bigserial not null,
    tipo varchar(30) not null,
    nome varchar(100) not null,
    data date,
    descricao varchar(200) not null,
    
    primary key(id)
);

No código acima, adicionamos o script create table eventos(), com campos definidos: o ID, o tipo do evento (show, palestra, entre outros), o nome do evento, a data e uma descrição.

Teoricamente, uma vez que temos a dependência do Flyway, essa migração deve ser executada normalmente ao executar a aplicação. Vamos executar a aplicação e acessar a aba do log para verificar se a tabela eventos será criada.

Geralmente, quando colocamos um script novo na pasta "DB migration", o log registra que uma migração foi executada com sucesso. No entanto, não houve essa mensagem.

Ao voltar no explorador lateral do pgAdmin, clicar na pasta "CodeChella", selecionar "Refresh" (recarregar) e acessar as pastas "Schemas > Tables" em seu interior, não há nada. Ou seja, a tabela não foi criada.

Isso ocorre porque, diferente de quando usamos o Spring Data JPA, no qual a URL é declarada com jdbc, ao utilizar o arquivo application.properties, declaramos essa URL com r2dbc. Para este caso, em que trabalhamos com o banco de forma reativa, precisamos passar também essa URL para que o Flyway consiga fazer a conexão e criar as tabelas.

Acessando o arquivo application.properties, copiaremos as três linhas de url, username e password e colaremos abaixo delas mesmas, pulando uma linha para criar um intervalo.

Nas linhas coladas, faremos as alterações necessárias:

• Na primeira linha, substituiremos spring.r2dbc.url por spring.flyway.url e a URL de r2dbc:postgresql por jdbc:posgresql;
• Na segunda linha, substituiremos spring.r2dbc.username por spring.flyway.user;
• Na terceira linha, substituiremos spring.r2dbc.password por spring.flyway.password.

application.properties:

spring.application.name=codechella

spring.r2dbc.url=r2dbc:postgresql://localhost/codechella
spring.r2dbc.username=${DB_USER}
spring.r2dbc.password=${DB_PASSWORD}

spring.flyway.url=jdbc:postgresql://localhost/codechella
spring.flyway.user=${DB_USER}
spring.flyway.password=${DB_PASSWORD}

Ao executar esse arquivo novamente, o Flyway deve ser capaz de criar a tabela. Após a execução, o log indica que um esquema foi criado, uma tabela "flyway_schema_history" foi adicionada e uma migração foi aplicada com sucesso.

Successfully validated 1 migration (execution time 00:00.020s)

Creating Schema History table "public"."flyway_schema_history" ...

Ao conferir novamente o explorador lateral do pgAdmin, na pasta "Tables", as tabelas eventos e flyway_schema_history já estão presentes, entre as quais a última armazenará todas as migrações aplicadas nesse banco.

Com essa alteração no application.properties, fizemos com que o Flyway funcionasse corretamente para um projeto reativo.

Adicionando a segunda migration

Voltando ao IntelliJ, pararemos a aplicação e incluiremos uma segunda migração, que servirá para inserir dados na tabela de eventos. No explorador lateral, clicaremos na pasta "db_migration" e selecionaremos novamente "New > File".

Na janela exibida, nomearemos a migração:

V002__INSERT_table_eventos.sql

No interior desse arquivo, colaremos o script da segunda migração, que também será disponibilizado abaixo e entre as atividades da aula.

V002__INSERT_table_eventos.sql:

INSERT INTO eventos (tipo, nome, data, descricao) VALUES
('SHOW', 'Taylor Swift', '2024-02-15', 'Um evento imperdível para todos os amantes da música pop.'),
('TEATRO', 'A Comédia da Vida', '2024-07-20', 'Uma peça teatral emocionante que retrata com humor momentos complexos da vida. Você não pode perder.'),
('CONCERTO', 'Concerto de Verão', '2024-06-10', 'Um concerto ao ar livre com grandes nomes da música clássica.'),
('PALESTRA', 'Palestra sobre Inteligência Artificial', '2024-09-05', 'Uma palestra informativa sobre as últimas tendências e ferramentas de IA.'),
('WORKSHOP', 'Workshop de Fotografia', '2024-11-30', 'Um workshop prático para aprimorar suas habilidades.'),
('SHOW', 'Stand-up Comedy', '2024-03-18', 'Uma noite de muito riso e diversão com os melhores comediantes do Brasil.'),
('CONCERTO', 'O Fantasma da Ópera', '2024-12-25', 'Uma apresentação clássica de ópera.'),
('TEATRO', 'Festival de Teatro', '2025-04-12', 'Um festival com as melhores peças teatrais do ano.'),
('PALESTRA', 'Fórum de Inovação e Empreendedorismo', '2025-10-08', 'Um fórum que reúne os maiores inovadores do país. Presença dos apresentadores do Shark Tank.'),
('WORKSHOP', 'Aulas de Culinária', '2025-05-20', 'Aulas práticas de culinária com chefs renomados.'),
('SHOW', 'Bruno Mars', '2025-05-22', 'De volta ao Brasil, Bruno promete entregar o maior e melhor show de sua carreira na turnê This is Mars.'),
('TEATRO', 'A Comédia da Vida', '2025-07-14', 'Uma peça teatral emocionante que você não pode perder.'),
('SHOW', 'The Weeknd', '2025-11-02', 'Um show eletrizante ao ar livre com muitos efeitos especiais.'),
('WORKSHOP', 'Café com Ideias', '2025-01-25', 'Um evento que ensina técnicas de brainstorming e priorização para alavancar projetos.');

Esse script contém um INSERT de 14 eventos. Ao executá-lo, a tabela será populada.

Após a execução, o log indicará que mais uma migração foi aplicada, desta vez a de INSERT table eventos.

Migrating schema "public" to version "002 - insert table eventos"

Successfully applied 1 migration to schema "public", now at version v002

Voltando ao explorador lateral do pgAdmin, clicaremos com o botão direito na pasta "Tables" e selecionaremos "Query Tool" para abrir essa ferramenta na área principal. Em seu interior, se executarmos select * from eventos, serão exibidos 14 eventos, incluindo shows, teatros, concertos e palestras.

select * from eventos

Retorno:

Conclusão

Com essa segunda etapa concluída, o projeto está iniciado e escutando requisições na porta 8080. Além disso, temos uma tabela de eventos criada e populada.

Próximos passos

Na sequência, criaremos o controlador para explorar as diferenças ao recuperar esses dados no navegador. Vamos analisar o que diferencia um controlador ou repositório reativo de um servlet.

Sobre o curso Java e Spring: construindo aplicações reativas com WebFlux

O curso Java e Spring: construindo aplicações reativas com WebFlux possui 159 minutos de vídeos, em um total de 52 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Criando uma API reativa
• Complementando a implementação
• Gerando stream de eventos
• Consumindo uma API de tradução
• Testes com Webflux