Repository navigation
Capitulo 03
Uso de Server-Sent Events (SSE) com WebFlux para lidar com a necessidade de atualizações em tempo real em aplicações reativas.
O SSE permite que o servidor envie atualizações automaticamente para o cliente por meio de uma conexão HTTP, sendo útil para dashboards, notificações e feeds de redes sociais.
Na prática, demonstra como implementar o SSE em uma API para transmitir eventos por categoria. Vamos criar um endpoint que retorna um Flux de eventos filtrados por tipo, com um atraso de alguns segundos para simular atualizações em tempo real.
Vamos tratar a situação mencionada anteriormente: quando temos um evento muito grande, como a compra de ingressos que esgotam rapidamente, precisamos de uma fila para manutenção e propagação das alterações de forma instantânea, em tempo real.
Um dos recursos que o WebFlux fornece para isso é o SSE (Server-Sent Events). Introduzimos um pouco o assunto ao utilizar a seguinte anotação:
@GetMapping // (produces = MediaType.TEXT_EVENT_STREAM_VALUE)A ideia é que o stream faça as atualizações. O SSE permite que nosso servidor envie atualizações automáticas através de uma conexão HTTP, de forma que aconteçam em tempo real, para aplicações que precisam dessa atualização exata na interface do usuário, como dashboards, notificações, feeds de redes sociais, e no nosso caso, para atualizar a disponibilidade de ingressos em tempo real.
O SSE é unilateral. Uma vez que o cliente se conecta ao servidor, apenas o servidor envia atualizações. Se o cliente precisar enviar dados de volta, ele fará outra conexão HTTP.
Vamos verificar isso na prática. Retiraremos a anotação do GetMapping e criaremos outra.
O exemplo que usaremos nesta aula será dos exemplos, para transmitir eventos por uma determinada categoria. Se selecionarmos apenas shows, ele deve trazer todos os shows, e ao cadastrar um novo, ele deve ser incluído.
No arquivo EventoController, vamos criar um novo GetMapping:
@GetMapping(value = "/categoria/{tipo}", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<EventoDto> obterPorTipo(@PathVariable String tipo) {
return servico.obterPorTipo(tipo);
}No método obterPorTipo, utilizamos PathVariable para converter o tipo para maiúsculas, e retornamos um Flux dos eventos que o serviço fornecer. Chamamos servico.obterPorTipo e passamos o tipo. Se o método não existir, a IDE pode criá-lo na EventoService.
No arquivo EventoService, devolvemos o tipo de evento baseado em um Enum. Utilizamos TipoEvento.valueOf(tipo.toUpperCase()) para converter o tipo e buscar o evento correspondente. Retornamos repositório.findByTipo(tipoevento) e mapeamos para ToDTO.
public Flux<EventoDto> obterPorTipo(String tipo) {
TipoEvento tipoEvento = TipoEvento.valueOf(tipo.toUpperCase());
return repositorio.findByTipo(tipoEvento)
.map(EventoDto::toDto);
}No repositório, criamos um método que devolve um Flux de evento:
public interface EventoRepository extends ReactiveCrudRepository<Evento, Long> {
Flux<Evento> findByTipo(TipoEvento tipoEvento);
}Em seguida, na controller, alteramos para devolver o Flux de eventos em forma de stream. No método obterPorTipo, ao invés de devolver diretamente servico.obterPorTipo, fazemos Flux.from(servico.obterPorTipo(tipo)). E vamos pedir um delay de alguns segundos para que possamos ver o servidor fazendo esse envio de eventos segundo a segundo, colocaremos 4 segundos:
@GetMapping(value = "/categoria/{tipo}", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<EventoDto> obterPorTipo(@PathVariable String tipo) {
return Flux.from(servico.obterPorTipo(tipo)
.delayElements(Duration.ofSeconds(4));
}Executamos a aplicação e verificamos no Postman. Ao solicitar GET http://localhost:8080/eventos, todos os eventos são mostrados. Ao solicitar GET http://localhost:8080/eventos/categoria/show, apenas os shows são exibidos.
Cadastramos um novo show e verificamos se ele é recuperado:
POST http://localhost:8080/eventos/
{
"tipo": "SHOW",
"nome": "Kiss",
"data": "2025-05-01",
"descricao": "Um evento para pessoas que curtem rock e amam a maior banda de todos os tempos"
}
Observamos que o SSE está enviando, mas não propagando mudanças, pois o novo show que cadastramos não apareceu.
Foi possível verificar que o SSE está enviando os eventos, mas não está propagando as mudanças em tempo real, ou seja, novos eventos cadastrados não são exibidos automaticamente. Esse problema será abordado a seguir.
Server-Sent Events (SSE) é uma tecnologia que permite que um servidor envie atualizações automáticas para um cliente via uma única conexão HTTP. É útil para aplicações que precisam de atualizações contínuas do servidor, como notificações em tempo real, feeds de dados ao vivo ou atualizações de estado de aplicativos.
Funcionamento Conexão unidirecional: Diferente do WebSocket, que é bidirecional, o SSE é unidirecional. O servidor pode enviar dados para o cliente, mas o cliente não pode enviar dados de volta pela mesma conexão.
Conexão persistente: O cliente abre uma conexão HTTP com o servidor, que permanece aberta, permitindo que o servidor envie eventos sempre que novos dados estiverem disponíveis.
Formato de dados: Os dados são enviados como texto simples, com eventos separados por duas novas linhas. Cada evento pode conter um ou mais campos de dados.
Confira um exemplo de implementação com o Spring WebFlux:
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import java.time.Duration;
import java.util.stream.Stream;
@RestController
public class SseController {
@GetMapping(path = "/sse", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamEvents() {
return Flux.fromStream(Stream.generate(() -> "Evento: " + System.currentTimeMillis()))
.delayElements(Duration.ofSeconds(1));
}
}Nesse código, criamos um controlador para lidar com as requisições SSE. Estamos criando um Flux que gera eventos a cada segundo. Cada evento é uma string contendo um timestamp atual.
Existem diversas maneiras de consumir SSE, vamos exemplificar de duas formas:
1 - Diretamente pelo html, usando a API EventSource para receber os eventos:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>SSE Example</title>
</head>
<body>
<div id="events"></div>
<script>
const eventSource = new EventSource('/sse');
eventSource.onmessage = function(event) {
const newElement = document.createElement("div");
newElement.textContent = event.data;
document.getElementById("events").appendChild(newElement);
};
</script>
</body>
</html>2 - Também através de outra aplicação, utilizando o WebClient:
public void consumirSSE() {
WebClient client = WebClient.create("http://localhost:8080/sse");
ParameterizedTypeReference<ServerSentEvent<String>> type
= new ParameterizedTypeReference<ServerSentEvent<String>>() {};
Flux<ServerSentEvent<String>> eventStream = client.get()
.retrieve()
.bodyToFlux(type);
eventStream.subscribe(
content -> logger.info("Time: {} - event: name[{}], id [{}], content[{}] ",
LocalTime.now(), content.event(), content.id(), content.data()),
error -> logger.error("Error receiving SSE: {}", error),
() -> logger.info("Completed!!!"));
}-
Benefícios:
Simplicidade de implementação. Suporte nativo nos navegadores modernos. Escalável para muitos clientes (comparado com WebSockets em alguns casos).
-
Limitações:
É unidirecional, pois apenas o servidor pode enviar dados. Tem suporte limitado em navegadores antigos. Pode ser menos eficiente que WebSockets para casos de uso bidirecional. Server-Sent Event é uma ótima escolha para aplicações que necessitam de um fluxo contínuo de dados do servidor para o cliente, com uma implementação simples e eficiente usando Spring WebFlux.
Agora vamos aprender como propagar as mudanças em tempo real em nossa aplicação reativa utilizando o Sink do projeto Reactor.
Primeiro, foi demonstrado como criar um Sink para unificar os novos eventos cadastrados à fonte de dados que enviamos para o cliente. Em seguida, alteramos o método GET para mesclar os eventos existentes com os eventos do Sink, garantindo que as atualizações em tempo real sejam incluídas no fluxo de dados.
Além disso, modificamos o método POST para enviar os eventos recém-cadastrados para o eventoSink, garantindo que todos os clientes conectados recebam as atualizações em tempo real.
Por fim, realizamos um teste prático para verificar se a propagação das mudanças estava funcionando corretamente, cadastrando um novo show e verificando se ele era exibido automaticamente no GET.
Uma vez que percebemos que os eventos não estão propagando suas mudanças — conseguimos exibir todos os shows, mas o que acabamos de criar não foi propagado para visualização em tempo real — Precisamos alterar o código para que isso aconteça.
Para isso, utilizaremos um tipo de componente chamado Sink, que será um ponto de entrada para enviar o novo evento cadastrado e unificá-lo à fonte de dados que estamos enviando para o cliente.
Na prática, utilizaremos o seguinte: no construtor, criaremos um construtor para a controller. Vamos remover o @AutoWired do EventoService, declará-lo como final e incluir um novo atributo, private final Sinks, que é do projeto reactor, que fará um Sink de muitos, no nosso caso, um Flux de EventoDTO. Chamaremos isso de EventoSink.
private final EventoService servico;
private final Sinks.Many<EventoDto> eventoSink;Criamos o construtor,selecionaremos apenas a opção "servico:EventoService", pois o Sink vamos declarar na inicialização.
Em seguida, vamos inserir o this.
private final EventoService servico;
private final Sinks.Many<EventoDto> eventoSink;
public EventoController(EventoService servico) {
this.servico = servico;
this.eventoSink = Sinks.many().multicast().onBackpressureBuffer();
}Vejamos o que significa esse Sinks.many().multicast().onBackpressureBuffer(). Isso significa que sincronizaremos vários novos eventos para o cliente. Quando usamos a palavra multicast, estamos dizendo que ele fará um broadcast, enviando para todos os clientes conectados. Se várias pessoas estiverem conectadas ao servidor, ele enviará a mesma propagação de mudanças para todos, o que é necessário no caso da fila de ingressos. Por exemplo, informar às pessoas "Você está na posição tal", "Agora só restam 50 ingressos". O multicast significa que enviará para todos os novos clientes conectados.
O onBackpressureBuffer() é um conceito fundamental na programação reativa, lidando com a capacidade dos clientes de consumir dados e do servidor de enviá-los.
Muitas vezes, o poder de envio do servidor é maior do que o poder de consumo do cliente. Com o WebFlux, conseguimos controlar na programação reativa como isso acontecerá de forma equilibrada, evitando sobrecarga.
Ao declarar o
Sinkdessa maneira, prevenimos que um consumidor receba mais eventos do que consegue consumir, evitando sobrecarga.
Com isso declarado, precisamos alterar nosso método de obtenção por tipo e, ao gravar, quando cadastrarmos um novo evento, devemos enviá-lo também para o fluxo. Faremos uma alteração no getMapping da categoria e no método POST.
Para o getMapping, ele continuará com a mesma declaração, mas em vez de flux.from, faremos um flux.merge, misturando o que já era enviado com o evento Sink que estiver no fluxo, com as informações enviadas em tempo real.
No merge, teremos dois parâmetros: o primeiro permanecerá como obterPorTipo e o segundo será eventoSink.asFlux(). O delay continuará com 4 segundos.
@GetMapping(value = "/categoria/{tipo}", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<EventoDto> obterPorTipo(@PathVariable String tipo) {
return Flux.merge(servico.obterPorTipo(tipo), eventoSink.asFlux())
.delayElements(Duration.ofSeconds(4));
}O segundo passo, uma vez que o GET já junta as duas coisas, é no cadastro no PostMapping. Precisamos pedir para que ele envie o evento cadastrado também para o evento Sink.
Se estiver sendo enviado para algum cliente, o que cadastramos também será enviado, fazendo um merge dos eventos buscados no banco e o recém-cadastrado. Isso é exatamente o que queremos. Se estivermos buscando uma lista de shows e alguém cadastrar um show, queremos que o novo show apareça também.
Usaremos o doOnSuccess. Se o cadastro foi feito com sucesso, ele vai enviar esse evento para o eventoSink.
@PostMapping
public Mono<EventoDto> cadastrar(@RequestBody EventoDto dto) {
return servico.cadastrar(dto)
.doOnSuccess(e -> eventoSink.tryEmitNext(e));
}-
Com essas alterações, teoricamente, já atenderemos ao que precisamos.
-
Antes de executar a aplicação, no Postman, vamos inserir um novo POST de show.
{
"tipo": "SHOW",
"nome": "Red Hot Chilli Peppers",
"data": "2025-05-02",
"descricao": "Um evento para pessoas que curtem rock"
}Faremos o GET e tentaremos um POST no show do Red Hot Chilli Peppers enquanto estivermos obtendo o GET de show. Se implementado corretamente, ele também transmitirá o show recém-cadastrado.
Executaremos a aplicação e faremos o teste.
No Postman, faremos a requisição, limparemos as mensagens e executaremos novamente. Na categoria show, ele começará a enviar, e cadastraremos o show do Red Hot Chilli Peppers.
Diferentemente da implementação anterior, onde a conexão abria e fechava, aqui ela se manteve.
Agora, ele está enviando automaticamente, no instante em que cadastramos um novo show.
{
"id":17,
"tipo":"SHOW",
"nome":"Red Hot Chilli Peppers",
"data":"2025-05-02",
"descricao":"Um evento para pessoas que curtem rock"
}Conseguimos fazer a propagação da mudança: cadastramos no banco e imediatamente o GET trouxe.
Essa técnica tem muitas vantagens. Com SSE, temos uma conexão persistente, usando uma conexão HTTP que não precisa abrir e fechar, podendo ficar ativa. Ela permite que o servidor mande atualizações constantemente.
O formato de dados é simples, como uma linha de texto, rápido e sem problemas para envio. Há o benefício de reconexão automática, com a maioria dos navegadores suportando SSE. Quando há perda de conexão, ele tenta reconectar automaticamente. Fizemos isso de forma simples usando WebFlux.
O Spring é um framework poderoso, oferecendo recursos para criar aplicações poderosas de forma simples. Usamos anotações, mas poderíamos ter feito com programação funcional também.
Como vimos ao longo dessa aula, event streaming (transmissão de eventos) é uma abordagem de processamento de dados em que eventos são capturados e transmitidos em tempo real à medida que ocorrem. Isso permite que as aplicações respondam instantaneamente a esses eventos, tornando-as mais reativas e escaláveis.
No contexto de uma aplicação Spring, o event streaming pode ser implementado usando várias tecnologias, como Apache Kafka, RabbitMQ e Spring WebFlux para streams HTTP.
O event streaming envolve a captura de eventos (ações ou ocorrências significativas) em tempo real e a transmissão desses eventos a consumidores interessados. Um evento pode ser qualquer coisa, desde uma transação financeira até uma mudança no estado de um objeto.
- Processamento em tempo real: Quando há necessidade de processar dados em tempo real. Por exemplo, monitoramento de sensores IoT, rastreamento de transações financeiras, notificações ao vivo, atualizações de status e análise de logs em tempo real.
- Desacoplamento de serviços: Event streaming permite que diferentes componentes do sistema sejam desenvolvidos e escalados independentemente.
- Escalabilidade e resiliência: Tecnologias de streaming como Kafka são projetadas para lidar com grandes volumes de dados e alta taxa de transferência.
- Microsserviços: Amplamente utilizado nesse tipo de arquitetura, em que diferentes serviços podem se comunicar através de eventos, permitindo uma arquitetura mais flexível e resiliente.
- Auditoria e rastreamento: Eventos são naturalmente uma forma de log que pode ser reproduzida para auditorias.
-
Apache Kafka: Kafka é um dos sistemas de event streaming mais populares atualmente. Altamente escalável e durável, usado para construir pipelines de dados em tempo real e aplicações de streaming.
-
RabbitMQ: É um broker de mensagens que também pode ser usado para event streaming. É conhecido pela sua flexibilidade e suporte a diferentes padrões de mensagens.
-
Spring WebFlux: Para cenários mais leves em que o streaming de eventos HTTP é suficiente. Ideal para aplicações web reativas que precisam de atualizações em tempo real.
Agora vamos implentar o controle de ingressos vendidos, para que acompanhássemos a cada venda o total ainda disponível de um determinado ingresso.
Para controlar os ingressos vendidos, antes de mais nada, precisaremos ter as tabelas criadas no banco para registrar os tipos de ingresso por evento e as vendas de cada tipo de ingresso.
Para a criação da tabela ingressos, vamos criar na pasta resources\db.migration um arquivo denominado V003__create_table_ingressos.sql com o seguinte script:
create table ingressos(
id bigserial not null,
evento_id bigint not null,
tipo varchar(30) not null,
valor decimal(10, 2) not null,
total int not null,
primary key(id)
);Na tabela acima, o evento_id corresponde ao id do evento cadastrado (show, palestra etc.) e o tipo corresponderá ao tipo de ingresso (único, pista, pista premium).
Vamos criar também um arquivo para inserir alguns dados como padrão, para não haver a necessidade ficar criar vários pelo Postman. Criei um arquivo com nome V004__insert_table_ingressos.sql com os seguintes dados:
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (14, 'UNICO', 380.42, 454);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (1, 'PISTA_PREMIUM', 590.52, 368);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (16, 'PISTA', 710.14, 281);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (12, 'CAMAROTE', 127.06, 207);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (13, 'PISTA', 643.95, 68);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (8, 'PISTA', 455.43, 14);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (8, 'CADEIRA', 401.74, 168);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (15, 'PISTA', 315.99, 412);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (16, 'CAMAROTE', 986.49, 194);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (7, 'CAMAROTE', 587.31, 9);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (12, 'CAMAROTE', 276.85, 396);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (11, 'UNICO', 328.67, 219);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (14, 'CAMAROTE', 675.01, 248);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (7, 'CAMAROTE', 631.72, 311);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (14, 'CADEIRA', 679.37, 347);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (9, 'UNICO', 65.85, 335);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (5, 'CADEIRA', 121.11, 78);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (7, 'PISTA', 835.21, 477);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (15, 'CAMAROTE', 582.24, 456);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (8, 'CAMAROTE', 501.32, 419);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (15, 'PISTA_PREMIUM', 871.45, 407);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (8, 'CADEIRA', 512.47, 271);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (9, 'CADEIRA', 759.21, 469);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (11, 'UNICO', 540.71, 164);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (12, 'CADEIRA', 287.23, 387);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (1, 'PISTA', 339.06, 156);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (4, 'UNICO', 730.31, 379);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (12, 'CADEIRA', 268.64, 333);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (9, 'UNICO', 914.42, 113);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (6, 'CADEIRA', 135.55, 299);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (1, 'UNICO', 442.77, 19);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (3, 'CAMAROTE', 621.71, 136);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (2, 'UNICO', 833.92, 159);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (2, 'UNICO', 517.14, 214);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (15, 'CADEIRA', 460.12, 260);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (10, 'PISTA_PREMIUM', 267.73, 11);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (8, 'CAMAROTE', 160.72, 351);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (2, 'UNICO', 657.53, 347);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (15, 'UNICO', 431.54, 84);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (14, 'CAMAROTE', 51.33, 426);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (12, 'UNICO', 113.43, 59);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (12, 'PISTA', 853.31, 58);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (9, 'UNICO', 96.38, 45);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (6, 'PISTA', 618.81, 429);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (15, 'PISTA_PREMIUM', 723.75, 194);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (11, 'UNICO', 413.26, 217);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (10, 'CAMAROTE', 801.24, 361);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (13, 'CAMAROTE', 877.71, 23);
INSERT INTO ingressos (evento_id, tipo, valor, total) VALUES (14, 'PISTA_PREMIUM', 79.97, 407);Por fim, vamos criar a migration para a criação da tabela de vendas, que registra os ingressos vendidos. Nomeei-a como V005__create_table_vendas.sql com a seguinte definição:
create table vendas(
id bigserial not null,
ingresso_id bigint not null,
total int not null,
primary key(id)
);Depois de executar a aplicação de verificar que as tabelas foram criadas corretamente, é necessário começar a alterar o código.
A primeira classe criada foi a TipoIngresso, que representa os vários tipos de ingresso para cada evento. Criei-a como enum:
public enum TipoIngresso {
UNICO,
PISTA,
PISTA_PREMIUM,
CADEIRA,
CAMAROTE
}Depois criei a classe Ingresso que representará a tabela ingressos no banco de dados:
@Table("ingressos")
public class Ingresso {
@Id
private Long id;
private Long eventoId;
private TipoIngresso tipo;
private Double valor;
private int total;
//getters e setters
}Como boa prática, imediatamente criei a IngressoDto com os métodos toEntity e toDto para fazer as transformações necessárias:
public record IngressoDto(Long id,
Long eventoId,
TipoIngresso tipo,
Double valor,
int total) {
public static IngressoDto toDto(Ingresso ingresso) {
return new IngressoDto(ingresso.getId(), ingresso.getEventoId(),
ingresso.getTipo(), ingresso.getValor(), ingresso.getTotal());
}
public Ingresso toEntity() {
Ingresso ingresso = new Ingresso();
ingresso.setId(this.id);
ingresso.setEventoId(this.eventoId);
ingresso.setTipo(this.tipo);
ingresso.setValor(this.valor);
ingresso.setTotal(this.total);
return ingresso;
}
}Vamos criar as classes IngressoRepository, IngressoService e IngressoController, com os códigos conforme abaixo, por sinal, muito similares aos de eventos.
public interface IngressoRepository extends ReactiveCrudRepository<Ingresso, Long> {
}@Service
public class IngressoService {
@Autowired
private IngressoRepository repositorio;
public Flux<IngressoDto> obterTodos() {
return repositorio.findAll()
.map(IngressoDto::toDto);
}
public Mono<IngressoDto> obterPorId(Long id) {
return repositorio.findById(id)
.switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND)))
.map(IngressoDto::toDto);
}
public Mono<IngressoDto> cadastrar(IngressoDto dto) {
return repositorio.save(dto.toEntity())
.map(IngressoDto::toDto);
}
public Mono<Void> excluir(Long id) {
return repositorio.findById(id)
.flatMap(repositorio::delete);
}
public Mono<IngressoDto> alterar(Long id, IngressoDto dto) {
return repositorio.findById(id)
.switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND, "Id do evento não encontrado.")))
.flatMap(ingresso -> {
ingresso.setEventoId(dto.eventoId());
ingresso.setTipo(dto.tipo());
ingresso.setValor(dto.valor());
ingresso.setTotal(dto.total());
return repositorio.save(ingresso);
})
.map(IngressoDto::toDto);
}
}@RestController
@RequestMapping("/ingressos")
public class IngressoController {
private final IngressoService servico;
private final Sinks.Many<IngressoDto> ingressoSink;
public IngressoController(IngressoService servico) {
this.servico = servico;
this.ingressoSink = Sinks.many().multicast().onBackpressureBuffer();
}
@GetMapping
public Flux<IngressoDto> obterTodos() {
return servico.obterTodos();
}
@GetMapping("/{id}")
public Mono<IngressoDto> obterPorId(@PathVariable Long id) {
return servico.obterPorId(id);
}
@PostMapping
public Mono<IngressoDto> cadastrar(@RequestBody IngressoDto dto) {
return servico.cadastrar(dto);
}
@DeleteMapping("/{id}")
public Mono<Void> excluir(@PathVariable Long id) {
return servico.excluir(id);
}
@PutMapping("/{id}")
public Mono<IngressoDto> alterar(@PathVariable Long id, @RequestBody IngressoDto dto){
return servico.alterar(id, dto);
}
}O código criado até o momento representa um CRUD completo e assíncrono para os ingressos, porém ainda não atende ao requisito de realizarmos a venda e fazermos o abatimento do número de ingressos disponíveis. Para realizar esse recurso, não precisaremos de tantas classes quanto ingressos. Vou detalhar a seguir.
Podemos ter uma classe chamada Venda que representará a tabela do banco:
@Table("vendas")
public class Venda {
@Id
private Long id;
private Long ingressoId;
private int total;
//getters e setters
}Também vamos precisar do repositório para gravar os dados da venda:
public interface VendaRepository extends ReactiveCrudRepository<Venda, Long> {
}Agora chegou o momento de modelar como gostaríamos de fazer essa venda dos ingressos e depois ver a quantidade disponível. Para isso, vamos pensar primeiramente no controlador, que receberá as requisições. Podemos ter dois métodos.
O primeiro é para realizar a compra, através do endpoint /ingressos/compra:
@PostMapping("/compra")
public Mono<IngressoDto> comprar(@RequestBody CompraDto dto) {
return servico.comprar(dto)
.doOnSuccess(i -> ingressoSink.tryEmitNext(i));
}A ideia é que a cada nova compra, o número de ingressos seja decrementado e mostrado em algum endpoint onde estejamos utilizando SSE, por isso usamos o ingressoSink.tryEmitNext, para avisar ao sink que tivemos alterações. Para representar essa compra, vamos criar o CompraDto com o código abaixo:
public record CompraDto(Long ingressoId,
int total) {
}Com essa implementação, a forma de realizar a compra utilizando o Postman é da seguinte forma:

O segundo método a ser criado no controlador de ingressos é para visualizar os ingressos disponíveis em tempo real:
@GetMapping(value = "/{id}/disponivel", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<IngressoDto> totalDisponivel(@PathVariable Long id) {
return Flux.merge(servico.obterPorId(id), ingressoSink.asFlux())
.delayElements(Duration.ofSeconds(4));
}Dessa forma, a cada nova compra, esse endpoint irá mostrar os totais atualizados, veja o exemplo abaixo. Primeiro criamos a conexão com esse endpoint:

Imediatamente após fazer uma compra de 9 ingressos com o id 1, ele vai mostrar o número atualizado, veja o campo total:

Vamos criar dois métodos criados no controlador, mas é necessário incluir na classe IngressoService o método criar:
@Transactional
public Mono<IngressoDto> comprar(CompraDto dto) {
return repositorio.findById(dto.ingressoId())
.flatMap(ingresso -> {
Venda venda = new Venda();
venda.setIngressoId(ingresso.getId());
venda.setTotal(dto.total());
return vendaRepository.save(venda).then(Mono.defer(() -> {
ingresso.setTotal(ingresso.getTotal() - dto.total());
return repositorio.save(ingresso);
}));
}).map(IngressoDto::toDto);
}Vamos entender exatamente o que está acontecendo no método comprar:
1 - Anotação @Transactional: Indica que o método deve ser executado dentro de uma transação. Se alguma operação dentro do método falhar, todas as mudanças feitas no banco de dados serão revertidas (rollback). Aqui usamos essa anotação pois só iremos decrementar o número de ingressos depois de efetivamente salvar a venda no banco de dados.
2 - Método comprar: Recebe um objeto CompraDto como parâmetro, que contém informações necessárias para realizar a compra de um ingresso, como o ingressoId e o total de ingressos a serem comprados.
3 - Busca pelo ingresso (repositorio.findById(dto.ingressoId())): O método findById do repositório é chamado para buscar o ingresso que corresponde ao ingressoId fornecido no CompraDto. Este método retorna um Mono<Ingresso>, que é uma classe reativa que representa um único objeto Ingresso ou nenhum (caso não seja encontrado).
4 - Uso do flatMap para processamento assíncrono: O flatMap é utilizado para transformar o Mono<Ingresso> em outro Mono que executa as operações de venda e atualização do ingresso. Se o ingresso for encontrado, o código dentro do flatMap será executado.
5 - Criação de um objeto Venda: Dentro do flatMap, um novo objeto Venda é criado. O método setIngressoId define o ID do ingresso associado à venda. O método setTotal define a quantidade total de ingressos que estão sendo comprados.
6 - Gravação da venda (vendaRepository.save(venda)): A venda é salva no banco de dados usando o método save do vendaRepository. Importante fazer a injeção de dependência do repositório de vendas na classe IngressoService, através das linhas abaixo:
@Autowired
private VendaRepository vendaRepository;A operação vendaRepository.save(venda) é assíncrona e retorna um Mono<Venda>. A continuação do fluxo depende da conclusão desta operação, por isso utilizamos um encadeamento com o método then.
7 - Encadeamento com then e Mono.defer: Após salvar a venda, o método then é usado para indicar que outra operação será realizada. O Mono.defer é utilizado para criar um novo Mono que será executado apenas quando o Mono<Venda> anterior for concluído. Dentro do Mono.defer, o total de ingressos disponíveis (ingresso.getTotal()) é atualizado subtraindo o número de ingressos comprados (dto.total()). Em seguida, o ingresso atualizado é salvo novamente no banco de dados através do método save do repositório.
8 - Conversão para IngressoDto (map(IngressoDto::toDto)): Após salvar o ingresso atualizado, o método map é utilizado para converter o objeto Ingresso retornado pelo Mono em um IngressoDto. Conforme visto anteriormente, IngressoDto::toDto é um método de conversão estático que transforma um objeto Ingresso em um IngressoDto, que é a forma final que será retornada ao cliente (nesse caso o controlador de ingressos, que chamou esse método).
Repare que aqui estamos fazendo uma implementação simples, para fins de prática dos conceitos abordados. Não estamos validando se o total de ingressos disponíveis é maior que o total de ingressos comprados, bem como outras validações que seriam necessárias. Há várias possibilidades de melhorias, que podem ser implementadas futuramente.
Abordamos os principais pontos sobre a utilização de Server-Sent Events (SSE) com o Spring WebFlux, como:
-
Configurar um endpoint no Spring com MediaType.
TEXT_EVENT_STREAM_VALUEpara produzir um stream de eventos reativos; -
Implementar método para filtrar eventos por categoria usando PathVariable dinâmico;
-
Utilizar repositório reativo para buscar eventos por tipo e garantir conversão de string para enum;
-
Criar método para transformar entidades em DTOs e aplicar mapeamento reativo;
-
Utilizar componente Sync do projeto Reactor para propagar mudanças em tempo real;
-
Configurar Synk de tipo Many para gerenciar múltiplas conexões e controlar fluxo de dados;
-
Modificar controlador com
Flux.merge()e implementar propagação de novos eventos usandoonSuccess()doMono.SSE é útil para aplicações que precisam de atualizações em tempo real, como dashboards, notificações e feeds de redes sociais.
CodeChella
by jnsdev