Skip to content

Capitulo 02

Jairo Nascimento Sousa edited this page Sep 6, 2025 · 5 revisions

Incluindo DTO

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:

Criação da Classe de Serviço (EventoService):

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;
}

Criação do DTO (EventoDto):

  • 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, passamos return 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());
 }

Integração do EventoService e DTO

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);
}

Implementação do Método obterTodos() em EventoService:

  • Este método utiliza o repositório para buscar todos os eventos (repositorio.findAll()).
  • O resultado é um Flux<Evento>, que é então mapeado para um Flux<EventoDto> usando um método estático toDto criado no EventoDto`.
@GetMapping //(produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<EventoDto> obterTodos() {
        return servico.obterTodos();
}

Integração no Controlador (EventoController):

  • O controlador foi modificado para injetar o EventoService em vez do EventoRepository.
  • O método obterTodos() no controlador chama o método correspondente no EventoService e retorna um Flux<EventoDto>.
@Autowired
private EventoService servico;

@GetMapping (produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<EventoDto> obterTodos() {
        return servico.obterTodos();
}

Teste com Postman:

  • A aplicação foi testada utilizando o Postman para verificar se a API retorna os eventos corretamente no formato DTO.

Busca por ID

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);
    }
}

Implementando o Método ObterPorID no EventoService

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."
}

Lançando o Erro 404 em casos de evento inexistente

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);
    }
}

Testando o tratamento de erros no Postman

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.

Cadastro e exclusão de dados

Implementando do cadastro de eventos

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);
}

Criando o método cadastrar()

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.

Transformando de DTO em entidade

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);

Implementando a exclusão de eventos

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);

    }
}

Implementando a exclusão de eventos

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);
}

Testando o cadastro e exclusão

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."
}

alterando um evento

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.

Neste capitulo, você aprendeu a:

  • Utilizar @Service para 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.

Clone this wiki locally