Documentando o aprendizado

Como Analista de Sistemas, venho buscando aprimorar minhas habilidades no desenvolvimento de aplicações utilizando a linguagem Java. Atualmente, minha principal função é oferecer suporte a customizações já existentes, solucionando problemas que surgem devido a erros na aplicação, atualizações no sistema, mudanças no escopo ou novas demandas de funcionalidades. Minha abordagem envolve a análise do código existente, identificação dos problemas e desenvolvimento de soluções adequadas.

Com o objetivo de melhorar continuamente minhas habilidades e criar uma base sólida para o desenvolvimento de projetos mais complexos no futuro, estou documentando os passos e práticas que sigo durante esse processo. Este registro servirá como uma referência para eu continuar minha trajetória. Através dessa documentação, busco consolidar meus aprendizados e contribuir para o desenvolvimento de novos sistemas de maneira mais ágil e organizada.

O que é Java e por que utilizá-lo?

Java é uma linguagem de programação amplamente utilizada devido à sua robustez, segurança e portabilidade. Um dos seus maiores atrativos é o fato de ser multiplataforma, ou seja, o código escrito em Java pode ser executado em diferentes sistemas operacionais (Windows, Linux, MacOS) sem a necessidade de modificações, graças à Java Virtual Machine (JVM).

Seus principais conceitos, como orientação a objetos, tornam o Java uma linguagem ideal para a construção de sistemas modulares e de fácil manutenção. Isso é especialmente importante para quem trabalha com sistemas corporativos, como é o meu caso, onde a escalabilidade e a capacidade de adaptação são essenciais.

O que é o Spring Framework?

O Spring Framework é uma plataforma abrangente para o desenvolvimento de aplicações Java, especialmente focada em tornar o processo de construção de software mais eficiente e menos complexo. Ele oferece suporte para a Inversão de Controle (IoC) e Injeção de Dependências, facilitando o gerenciamento de componentes da aplicação. Outra vantagem do Spring é o Spring Boot, que automatiza a configuração da aplicação, permitindo que os desenvolvedores foquem nas funcionalidades principais, sem precisar gastar muito tempo com configurações básicas.

Com o Spring, podemos criar APIs RESTful de maneira rápida, integrando facilmente o sistema a diferentes bancos de dados, como o MongoDB no caso do projeto que irei descrever a seguir.

Desenvolvimento do Sistema “Anota Ai”

O sistema Anota Ai foi desenvolvido com o objetivo de gerenciar o catálogo de produtos de um mercado, utilizando Java com o Spring Framework e MongoDB como banco de dados. Esse projeto foi organizado em camadas (Modelo-Visão-Controlador, ou MVC) para garantir a separação de responsabilidades e facilitar a manutenção e evolução do sistema.

1. Definição do Domínio do Sistema

A primeira etapa no desenvolvimento do Anota Ai foi definir as entidades principais do sistema. No caso, os produtos e as categorias que organizam esses produtos. Cada entidade possui atributos que descrevem suas características, como nome, descrição e preço para os produtos, e título e descrição para as categorias.

2. Classes de Domínio

As classes de domínio são a representação das entidades do sistema. Elas contêm os atributos e comportamentos necessários para manipular esses dados. Para o sistema Anota Ai, criei as classes `Product` e `Category`, que representam, respectivamente, os produtos e categorias.

Aqui está um exemplo da classe `Product`, que contém os atributos principais de um produto:

public class Product {
private String id;
private String title;
private String description;
private String ownerId;
private Integer price;
private String category;

public Product(ProductDTO data) {
  this.title = data.title();
  this.description = data.descripton();
  this.ownerId = data.ownerId();
  this.price = data.price();
  this.category = data.categoryId();
}
@Override
public String toString() {
  JSONObject json = new JSONObject();
  json.put("id", id);
  json.put("title", title);
  json.put("description", description);
  json.put("ownerId", ownerId);
  json.put("category", category);
  return json.toString();
}
}

As classes de domínio são criadas para serem simples e focadas no armazenamento de dados, permitindo que as demais camadas manipulem esses objetos.

3. Camada de Serviço

A camada de serviço é onde reside a lógica de negócios. No Anota Ai, implementei as classes `ProductService` e `CategoryService` para gerenciar operações como inserir, atualizar, listar e excluir produtos e categorias.

Por exemplo, o método `insert` no `ProductService` verifica se a categoria associada ao produto existe, antes de salvar o novo produto no banco de dados:

public class ProductService {
private final CategoryService categoryService;
private final ProductRepository repository;

public Product insert(ProductDTO productData) {
this.categoryService.getById(productData.categoryId())
.orElseThrow(CategoryNotFoundException::new);
  
  Product newProduct = new Product(productData);
   this.repository.save(newProduct);
  return newProduct;
}
}

Essa camada garante que a lógica de verificação e atualização dos dados siga as regras definidas para o sistema.

4. Camada de Persistência

A camada de persistência é responsável por armazenar e recuperar dados do banco de dados. No caso deste projeto, utilizei o Spring Data MongoDB para facilitar a comunicação com o banco de dados MongoDB.

Os repositórios, como o `ProductRepository`, são responsáveis por interagir diretamente com o banco de dados. Aqui está a interface do repositório de produtos:

public interface ProductRepository extends MongoRepository<Product, String> {
}

Essa interface permite realizar operações como salvar, buscar, atualizar e deletar produtos no banco de dados, sem precisar escrever código SQL manualmente.

5. Camada de Controle

A última camada é a camada de controle, que expõe os endpoints da API REST para permitir que clientes (como o frontend ou outra aplicação) interajam com o sistema. No caso do Anota Ai, criei o `ProductController`, que define os endpoints para operações de CRUD (Criar, Ler, Atualizar e Deletar) sobre os produtos.

Aqui está um exemplo de como a API lida com a criação de um novo produto:

@RestController
@RequestMapping("/api/product")
public class ProductController {
private final ProductService service;

@PostMapping
public ResponseEntity<Product> insert(@RequestBody ProductDTO productData) {
  Product newProduct = this.service.insert(productData);
  return ResponseEntity.ok().body(newProduct);
}
}

Esse endpoint recebe uma requisição HTTP POST com os dados do produto no corpo da requisição, chama o método `insert` no `ProductService`, e retorna o novo produto criado.

Passo a Passo:

A seguir, explico o passo a passo para criar um sistema semelhante ao Anota Ai, com base no padrão MVC e utilizando Java com Spring Framework e MongoDB.

1. Criação do Projeto:

Inicie o projeto usando o Spring Initializr, configurando as dependências necessárias como Spring Web para criar APIs REST e Spring Data MongoDB para integração com o banco de dados.

2. Definir o Domínio do Sistema:

Identifique as entidades principais que o sistema irá gerenciar. No Anota Ai, por exemplo, os produtos e categorias foram as entidades escolhidas.

3. Criar as Classes de Domínio:

Defina classes que representem as entidades. Crie também DTOs (Data Transfer Objects) para transferir dados entre as camadas, tornando o código mais seguro e organizado.

4. Implementar a Camada de Serviço:

Desenvolva a lógica de negócios. Para cada entidade, crie uma classe de serviço que lidere operações como inserir, atualizar, listar e deletar. Certifique-se de incluir verificações para validar as informações.

5. Configurar a Persistência:

Crie repositórios para acessar o banco de dados. Com o Spring Data MongoDB, basta estender a interface `MongoRepository` para realizar operações de CRUD.

6. Criar a Camada de Controle:

Defina endpoints para expor a API REST, permitindo que clientes interajam com o sistema. Utilize controladores para gerenciar as requisições e respostas.

Por meio da documentação das etapas e práticas seguidas, busco não apenas melhorar minhas próprias habilidades, mas também criar um guia de referência para a construção de novos sistemas. Esse processo de aprendizado contínuo, focado em desenvolver soluções eficientes e organizadas, servirá como base para a criação de projetos futuros, de maior complexidade e escopo.

Portanto, a abordagem apresentada não só facilita a replicação de soluções para outros sistemas, como também reforça a importância de se adotar uma arquitetura bem estruturada, que simplifique a manutenção e permita a fácil expansão das funcionalidades. Com isso, tanto iniciantes quanto desenvolvedores experientes podem aproveitar essas práticas para criar soluções que sejam escaláveis, eficientes e seguras.

Repositório: Demanxier/Anota_AI (github.com)