Separando as responsabilidades

Apesar da aplicação estar funcionando isso não significa que temos um bom código criado. O código atual possui diversas responsabilidades, como por exemplo, a validação dos dados, a persistência dos dados e a exibição dos dados. Isso é um problema, pois dificulta a manutenção e a evolução da aplicação. Além de que, quando trabalhamos com código trabalhamos em equipe, ou seja, outras pessoas precisarão entender o código e fazer alterações. Por isso, é importante que o código seja bem organizado e cada parte do código tenha sua responsabilidade bem definida.

A primeira parte é com relação ao Controller criado. Atualmente ele tem muitas responsabilidades. Ele está responsável por manipular a fonte de dados da aplicação - a lista de produtos, receber as requisições e enviar os dados para a visão. Isso é um problema grave.

A primeira modificação importante é que a manipulação da fonte de dados não deve ser realizada pelo controlador. Por enquanto nossa fonte de dados é apenas uma lista, mas em uma aplicação real a fonte de dados pode ser um banco de dados, um arquivo, uma API, etc. Por isso, é importante que a manipulação da fonte de dados seja realizada por uma camada específica para isso. Essa camada é chamada de repositório.

Criando o repositório

O repositório é uma classe que possui a responsabilidade de manipular a fonte de dados da aplicação. Para isso, ele possui métodos para adicionar, remover, atualizar e buscar os dados. Esses métodos são conhecidos pelo acrônimo CRUD de Create, Read, Update e Delete.

Não esqueça: O repositório é o responsável por realizar as operações CRUD na fonte de dados da aplicação.

Para criar o repositório, crie uma nova classe chamada ProductRepository. Aproveite para separar os diferentes tipos de arquivos em suas respectivas pastas. Crie o repositório dentro de uma pasta repository.

Essa classe deve possuir um atributo privado do tipo List<Product> que será a fonte de dados da aplicação. Além disso, a classe deve possuir os métodos CRUD para manipular os objetos dessa lista.

public class ProductRepository {
    
    private List<Product> products = new ArrayList<>();

    public List<Product> findAll() {
        return products;
    }

    public void save(Product product) {
        products.add(product);
    }

    public void update(Product product) {
        Product productToUpdate = findById(product.getId());
        productToUpdate.setName(product.getName());
        productToUpdate.setPrice(product.getPrice());
        productToUpdate.setDescription(product.getDescription());
    }

    public void delete(String id) {
        Product productToDelete = findById(id);
        products.remove(productToDelete);
    }

    public Product findById(String id) {
        for (Product product : products) {
            if (product.getId().equals(id)) {
                return product;
            }
        }
        return null;
    }
    
}

No total foram criados 5 métodos. O método findAll retorna todos os produtos da lista. O método save adiciona um novo produto na lista. O método update atualiza um produto existente na lista. O método delete remove um produto da lista. E o método findById busca um produto pelo seu id. Perceba que toda a manipulação da lista é feita dentro do repositório. O controlador não precisa e nem deve se preocupar com isso.

Utilizando o repositório

Agora que o repositório foi criado, é necessário utilizá-lo no controlador. Para isso, é necessário criar um atributo do tipo ProductRepository no controlador e inicializá-lo no construtor. Além disso, é necessário alterar os métodos do controlador para que eles utilizem o repositório para manipular a fonte de dados.

@Controller
public class ProductController {

    private ProductRepository productRepository = new ProductRepository();

    @GetMapping("/products")
    public String index(Model model) {
        model.addAttribute("products", productRepository.findAll());
        return "list";
    }

    @GetMapping("/products/create")
    public String create(Model model) {
        Product product = new Product();
        model.addAttribute("product", product);
        return "create";
    }

    @PostMapping("/products/store")
    public String store(@Valid Product product, BindingResult result) {
        if (result.hasErrors()) {   return "create";    }
        productRepository.save(product);
        return "redirect:/products";
    }

    @GetMapping("/products/show")
    public String show(Model model, @RequestParam("id") String id){
        Product product = productRepository.findById(id);
        model.addAttribute("product", product);
        return "show";
    }

    @GetMapping("/products/edit")
    public String edit(Model model, @RequestParam("id") String id){
        Product product = productRepository.findById(id);
        model.addAttribute("product", product);
        return "edit";
    }

    @PostMapping("/products/update")
    public String update(Product product){
        productRepository.update(product);
        return "redirect:/products";
    }

    @GetMapping("/products/delete")
    public String delete(@RequestParam("id") String id){
        productRepository.delete(id);
        return "redirect:/products";
    }
    
}

Três grandes modificações foram feitas no controlador. Primeiramente foi criado o atributo productRepository que é inicializado no construtor. Depois, todos os métodos que manipulavam a lista de produtos foram alterados para que utilizem os métodos implementados no repositório. Por fim o método findProductById foi movido para o repositório. Perceba que o controlador ficou mais simples e com menos responsabilidades.

O controlador não deve se preocupar com a manipulação da fonte de dados. Ele deve ser responsável apenas por receber as requisições e enviar os dados para a visão.

Por fim teste a aplicação e certifique-se que ela continua funcionando.