Repository navigation
Capitulo 02
Nesta aula, foi demonstrado como refatorar o código de um projeto Java Spring reativo para melhorar a arquitetura e evitar o acoplamento direto entre o controlador e o repositório de dados.
Inicialmente, o projeto CodeChella foi apresentado, com foco na fila de compra de ingressos. Para melhorar a estrutura do código, foram seguidos os seguintes passos:
Foi criada uma classe de serviço anotada com @Service para desacoplar a lógica de negócios do controlador.
O repositório (EventoRepository) foi injetado nesta classe usando via construtor.
@Service
public class EventoService {
@Autowired
private EventoRepository repositorio;
}- Foi criado um record chamado EventoDto para transferir dados entre a camada de serviço e o controlador, evitando expor diretamente a entidade do banco de dados.
- O DTO contém os mesmos campos que a entidade Evento: id, tipo, nome, data e descricao.
public record EventoDto(Long id,
TipoEvento tipo,
String nome,
LocalDate data,
String descrição) {}- Criado o método estático para chamar no map, usando uma referência de método. Nas chaves, criamos uma
public static EventoDto toDto(Evento evento){}. Nas chaves, passamosreturn new EventoDto(evento.getId(), evento.getTipo(), evento.getNome(), evento.getData(), evento.getDescricao()).
package br.com.alura.codechella;
import java.time.LocalDate;
public record EventoDto(Long id,
TipoEvento tipo,
String nome,
LocalDate data,
String descricao) {
public static EventoDto toDto(Evento evento) {
return new EventoDto(evento.getId(), evento.getTipo(), evento.getNome(),
evento.getData(), evento.getDescricao());
}Nosso método estático será usado no EventoService.java, pois depois que fizemos o findAll() que retorna todos os eventos, faremos um .map() e chamaremos no EventoDto o método toDTO, devolvendo isso para o controlador.
@Service
public class EventoService {
@Autowired
private EventoRepository repositorio;
public Flux<EventoDto> obterTodos() {
return repositorio.findAll()
.map(EventoDto::toDto);
}- Este método utiliza o repositório para buscar todos os eventos (
repositorio.findAll()). - O resultado é um
Flux<Evento>, que é então mapeado para umFlux<EventoDto> usando um método estático toDto criado noEventoDto`.
@GetMapping //(produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<EventoDto> obterTodos() {
return servico.obterTodos();
}- O controlador foi modificado para injetar o
EventoServiceem vez doEventoRepository. - O método
obterTodos()no controlador chama o método correspondente noEventoServicee retorna umFlux<EventoDto>.
@Autowired
private EventoService servico;
@GetMapping (produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<EventoDto> obterTodos() {
return servico.obterTodos();
}- A aplicação foi testada utilizando o Postman para verificar se a API retorna os eventos corretamente no formato
DTO.
Nesta aula, aprendemos a implementar o método ObterPorID no EventoController para buscar um evento específico por ID.
Primeiro, foi demonstrado como os eventos são exibidos no Postman usando a notação produces = MediaType.TEXT_EVENT_STREAM_VALUE para Server-Sent Events. Em seguida, o método ObterPorID foi implementado no EventoController, utilizando a anotação @PathVariable para receber o ID pela URL e o tipo Mono para representar um stream de eventos que pode ter zero ou um evento.
GetMapping("/{id}")
public Mono<EventoDto> obterPorId(@PathVariable Long id) {
return servico.obterPorId(id);
}
}No EventoService.java, faremos algo semelhante ao obterTodos. Faremos um return com repositorio.findById(id)e, em seguida, ummap()paraEventoTO::toDto`.
No EventoService, o método obterPorId foi implementado para buscar o evento no repositório e convertê-lo para EventoDto. Além disso, foi abordada a importância de tratar o caso em que o evento não é encontrado, lançando um erro 404 (Not Found) utilizando o método switchIfEmpty e ResponseStatusException.
public Mono<EventoDto> obterPorId(Long id) {
return repositorio.findById(id)
.map(EventoDto::toDto);
}
}Assim, temos o seguinte retorno:
{
"id": 2,
"tipo": "TEATRO",
"nome": "A Comédia da Vida",
"data": "2024-07-20",
"descricao": "Uma peça teatral emocionante que retrata com humor momentos complexos. da vida. Você não pode perder."
}No EventoService.java, após o findById(id), adicionaremos .switchIfEmpty(), para que, se não houver nada, lançaremos um novo erro de status. Então, nos parênteses, passamos Mono.error(new ResponseStatusException()). Nos parênteses, passamos HttpStatus.NOT_FOUND.
public Mono<EventoDto> obterPorId(Long id) {
return repositorio.findById(id)
.switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND)))
.map(EventoDto::toDto);
}
}Com isso, se passarmos um ID de evento que não existe, retornará o status 404. Ao executar novamente, abrirmos o Postman e fizermos um GET de http://localhost:8080/eventos/200 temos um erro 404 Not Found.
Já, se colocarmos um ID válido, como 2, apresenta o JSON corretamente. Dessa forma, o ObterPorID está funcionando.
Por fim, foi realizado um teste no Postman para verificar o funcionamento do método ObterPorID tanto para um ID existente quanto para um ID inexistente, garantindo que o status 404 seja retornado corretamente neste último caso.
Para realizar o cadastro, no EventoController.java, precisamos adicionar o @PostMapping. Na linha abaixo, passamos public que também devolverá um Mono<EventoDTO>. Chamaremos o método de cadastrar() e precisaremos receber no corpo da requisição o EventoDto com as informações para cadastrar o evento. Então passamos @RequestBody EventoDto dto. Na linha abaixo, passamos o return servico.cadastrar(dto).
@PostMapping
public Mono<EventoDto> cadastrar(@RequestBody EventoDto dto) {
return servico.cadastrar(dto);
}Nisso, a IDE exibe o cadastrar() na cor vermelha, pois ainda não o tema. Para criá-lo, usaremos o atalho, clicamos nele e depois em "Create method 'cadastrar' in EventoService".
Migramos para o arquivo EventoService.java. Em public Mono, na linha abaixo, passamos return repositorio.save(). Porém, não poderemos passar o dto como parâmetro, primeiro precisamos transformá-lo em entidade. Caso contrário, não conseguiremos salvá-lo.
Então, no arquivo EventoDTO.java, criaremos um método semelhante ao que transformava de evento comum para EventoDTO. Porém, agora faremos o inverso, transformando o próprio DTO em entidade.
Escrevemos public Evento toEntity(){}. Nas chaves, passamos Evento evento = new Evento(). Abaixo, vamos setar as propriedades com os dados do dto para não precisar utilizar nenhuma biblioteca de mapper para transformação.
Na linha abaixo, escrevemos evento.setId(this.id), seguido de evento.setNome(this.nome), evento.setTipo(this.tipo), evento.setData(this.Data), evento.setDescricao(this.descricao). Por fim, passamos o return evento.
public Evento toEntity() {
Evento evento = new Evento();
evento.setId(this.id);
evento.setNome(this.nome);
evento.setTipo(this.tipo);
evento.setData(this.data);
evento.setDescricao(this.descricao);
return evento;
}No arquivo EventoService.java, para projetarmos o cadastrar, nos parênteses do retorno, passamos dto.toEntity(). Porém, precisamos devolvê-lo como dto. Então, na linha abaixo passamos .map(EventoDto::toDto).
Essa é uma implementação limpa, basicamente com uma linha de código resolvemos essa questão de transformação em entidade e dto.
public Mono<EventoDto> cadastrar(EventoDto dto) {
return repositorio.save(dto.toEntity())
.map(EventoDto::toDto);Antes de testar, implementaremos a exclusão. No EventoController.java, no fim do código, escrevemos @DeleteMapping() passando "/{id}". Na linha abaixo, escrevemos public Mono<Void> excluir(@PathVariable Long id). Por fim, passamos return servico.excluir(id).
EventoController.java
@DeleteMapping("/{id}")
public Mono<Void> excluir(@PathVariable Long id) {
return servico.excluir(id);
}
}Antes de testar, implementaremos a exclusão. No EventoController.java, no fim do código, escrevemos @DeleteMapping() passando "/{id}". Na linha abaixo, escrevemos public Mono<Void> excluir(@PathVariable Long id). Por fim, passamos return servico.excluir(id).
EventoController.java
DeleteMapping("/{id}")
public Mono<Void> excluir(@PathVariable Long id) {
return servico.excluir(id);
}Criamos o método excluir() em EventoService.java. Em public Mono, nas chaves, passamos return repositorio.findById(id) e na linha abaixo .flatMap(repositorio::delete).
public Mono<Void> excluir(Long id)
return repositorio.findById(id)
.flatMap(repositorio::delete);
}Com isso, o cadastro e a exclusão estão prontos. Testaremos e verificar se estão funcionando. Executamos a aplicação clicando no ícone de "Play" na barra de menu superior. Depois, abrimos o Postman.
Suponhamos que queremos excluir o evento de caminho http://localhost:8080/eventos/2. Para isso, selecionamos o método DELETE e clicamos em "Send". Feito isso, ao mudar o método para GET e clicar em "Send" é exibido que não existe mais o eventos/2, pois foi apagado.
Agora, tentaremos cadastrar um novo evento. Para isso, copiamos os parâmetros de tipo, nome data e descrição. Depois, na barra de menu do centro da tela, clicamos na aba "Body". Clicamos em "raw" e mudamos para JSON. Após, no campo de código, passamos o código abaixo para criarmos o novo evento.
{
"tipo": "SHOW",
nome": "Madonna",
data": "2025-02-15",
descricao": "Um evento imperdível para todos os amantes da música pop."
}Implemente a alteração de um evento de forma assíncrona, seguindo os conceitos vistos nessa aula. Será necessário alterar o controlador e o serviço.
Para que possamos processar uma requisição do tipo PUT, é necessário criarmos em nosso controlador um método com a anotação apropriada, indicando que a localização do evento a ser alterado será por id. Esse método receberá um objeto do tipo EventoDto como parâmetro e devolverá um Mono do mesmo tipo de objeto como retorno.
@PutMapping("/{id}")
public Mono<EventoDto> alterar(@PathVariable Long id, @RequestBody EventoDto dto){
return servico.alterar(id, dto);
}Immplementar o método alterar() na classe EventoService para realizar a alteração dos dados de um evento.
public Mono<EventoDto> alterar(Long id, EventoDto dto) {
return repositorio.findById(id)
.switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND, "Id do evento não encontrado.")))
.flatMap(eventoExistente -> {
eventoExistente.setTipo(dto.tipo());
eventoExistente.setNome(dto.nome());
eventoExistente.setData(dto.data());
eventoExistente.setDescricao(dto.descricao());
return repositorio.save(eventoExistente);
})
.map(EventoDto::toDto);
}Repare que no código acima, fazemos a busca pelo id utilizando o repositório. Caso não seja encontrado, o método switchIfEmpty será responsável por lançar uma exceção, retornando o código 404. Caso seja encontrado, vamos usar o flatMap para setar no evento existente as novas propriedades passadas no corpo da requisição através da variável dto.
- Utilizar
@Servicepara desacoplar lógica de negócios do controlador; - Aplicar injeção de dependência com injeção pelo construtor;
- Encapsular dados com DTO e converter entidades em DTOs;
- Transformar entidades em DTOs usando map do Flux;
- Implementar endpoints GET com @GetMapping e usar @PathVariable para capturar parâmetros de URL;
- Manejar respostas HTTP com Mono.error e ResponseStatusException para tratamento de erro;
- Criar endpoints para cadastro e exclusão de recursos com @PostMapping e @DeleteMapping.
CodeChella
by jnsdev