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)
