image

Acesse bootcamps ilimitados e +650 cursos

50
%OFF
Article image
Demanxier Rodrigues
Demanxier Rodrigues24/09/2024 09:46
Compartilhe

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?

    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

    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

    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)

    Compartilhe
    Comentários (1)
    Anderson Souza
    Anderson Souza - 24/09/2024 10:43

    Parabéns pela sua dedicação em aprimorar suas habilidades em Java! A prática constante e a busca por soluções eficientes são fundamentais para o sucesso de qualquer desenvolvedor. Compartilhar seus projetos e desafios com a comunidade é uma ótima forma de aprender e crescer juntos. Adorei a sua explicação sobre o Spring Framework e o MongoDB! #programação #java #spring #mongodb