image

Acesse bootcamps ilimitados e +650 cursos

50
%OFF
Article image
Lilian Rodrigues
Lilian Rodrigues10/02/2025 15:47
Compartilhe

🚀 1. Configuração Inicial do Projeto Spring Boot

  • #Java
  • #Cloud
  • #POO
  1. Criação do Projeto Spring Boot Use o Spring Initializr para gerar o projeto. Se preferir usar o terminal ou IDE, pode gerar um projeto com as dependências:
  • Spring Web
  • Spring Data JPA
  • H2 Database (para exemplo rápido) ou qualquer banco de dados relacional
  • Lombok
  1. Estrutura do Projeto: O projeto Spring Boot já cria a estrutura básica, mas vejamos um exemplo de como ela pode ser organizada.

🏗️ 2. Estrutura do Projeto

  • src
  • main
  • java
  • com.example.demo
  • controller (Controladores de API)
  • model (Modelos de dados)
  • repository (Repositórios JPA)
  • service (Serviços de lógica de negócio)
  • DemoApplication.java (Classe principal)

📊 3. Exemplo de Modelo (Model)

Aqui, usaremos o Lombok para reduzir o código boilerplate e JPA para mapear a classe ao banco de dados.

package com.example.demo.model;
import lombok.Data;
import javax.persistence.*;

@Data
@Entity
public class Product {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;
  private Double price;
  private Integer quantity;
}

📁 4. Repositório JPA

O repositório será responsável por acessar os dados no banco de dados.

package com.example.demo.repository;
import com.example.demo.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

🧑‍💻 5. Serviço (Service)

O serviço contém a lógica de negócio. Ele interage com o repositório.

package com.example.demo.service;
import com.example.demo.model.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ProductService {

  @Autowired
  private ProductRepository productRepository;

  public List<Product> getAllProducts() {
      return productRepository.findAll();
  }

  public Product getProductById(Long id) {
      return productRepository.findById(id).orElse(null);
  }

  public Product createProduct(Product product) {
      return productRepository.save(product);
  }

  public Product updateProduct(Long id, Product product) {
      product.setId(id);
      return productRepository.save(product);
  }

  public void deleteProduct(Long id) {
      productRepository.deleteById(id);
  }
}

🛠️ 6. Controlador (Controller)

O controlador expõe as endpoints da API REST.

package com.example.demo.controller;

import com.example.demo.model.Product;
import com.example.demo.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/products")
public class ProductController {

  @Autowired
  private ProductService productService;

  @GetMapping
  public List<Product> getAllProducts() {
      return productService.getAllProducts();
  }

  @GetMapping("/{id}")
  public Product getProductById(@PathVariable Long id) {
      return productService.getProductById(id);
  }

  @PostMapping
  public Product createProduct(@RequestBody Product product) {
      return productService.createProduct(product);
  }

  @PutMapping("/{id}")
  public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
      return productService.updateProduct(id, product);
  }

  @DeleteMapping("/{id}")
  public void deleteProduct(@PathVariable Long id) {
      productService.deleteProduct(id);
  }
}

🧪 7. Testes e Verificação

Você pode agora testar a API utilizando ferramentas como Postman ou cURL.

  • GET /api/products: Retorna todos os produtos.
  • GET /api/products/{id}: Retorna um produto pelo ID.
  • POST /api/products: Cria um novo produto.
  • PUT /api/products/{id}: Atualiza um produto.
  • DELETE /api/products/{id}: Deleta um produto.

🔐 8. Expansão para Segurança e Autenticação

A API pode ser facilmente expandida para incluir segurança. Aqui estão algumas possibilidades:

  • Autenticação JWT (JSON Web Token) para proteger as rotas.
  • Spring Security para configurar roles e permissões de acesso.

🚀 Exemplo de Segurança com JWT:

  1. Adicione a dependência do Spring Security no pom.xml:
xml

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>
  1. Crie a configuração de segurança, integrando JWT com Spring Security.

☁️ 9. Deploy em Cloud

  • AWS (Amazon Web Services), Google Cloud ou Heroku são plataformas populares para deploy.
  • Docker: Contêineres podem ser usados para empacotar a aplicação para deploy em qualquer ambiente (Cloud ou Local).

🚀 Deploy no Heroku (Exemplo):

  1. Adicione um Procfile no diretório raiz com o seguinte conteúdo:
bash

web: java -jar target/demo-0.0.1-SNAPSHOT.jar
  1. Crie um arquivo application.properties com a configuração do banco de dados remoto, caso necessário.
  2. Com o Heroku CLI:
  • Faça login: heroku login
  • Crie um novo aplicativo: heroku create
  • Suba o código: git push heroku main

🧑‍💻 Conclusão:

Com Spring Boot, JPA e Lombok, você tem uma base sólida para construir uma API RESTful com funcionalidades CRUD (Criar, Ler, Atualizar, Deletar). Você pode facilmente expandir essa base para incluir autenticação, segurança, deploy em Cloud, e muito mais. Com o uso de ferramentas como JWT, Spring Security, e Docker, seu sistema pode se tornar robusto e escalável para ambientes de produção.

Compartilhe
Comentários (2)
Lilian Rodrigues
Lilian Rodrigues - 10/02/2025 18:59

Olá Dio Community!

Muito obrigada pelo feedback! ❤️ Fico feliz que tenha gostado do artigo!

Para quem deseja otimizar o desempenho de uma API Spring Boot e garantir escalabilidade em ambientes de alta demanda, algumas melhores práticas são essenciais:

🚀 Otimizações de Desempenho

Reduzir consultas desnecessárias ao banco

  • Use projeções DTOs para retornar apenas os dados necessários.
  • Prefira findById() ao invés de findAll(), se precisar de um único registro.
  • Utilize Lazy Loading e Eager Fetching corretamente no JPA.

Configurar Cache

  • Implemente Spring Cache (com Redis ou Ehcache) para reduzir carga no banco.
  • Cacheie dados estáticos e requisições frequentes.

Paralelizar tarefas pesadas

  • Utilize Spring Async para processar tarefas em segundo plano.
  • Para grandes volumes de dados, implemente Spring Batch.

Otimizar JSON Serialization

  • Prefira Jackson's @JsonView ou @JsonIgnoreProperties para evitar serializar dados desnecessários.
  • Configure spring.jackson.serialization.FAIL_ON_EMPTY_BEANS=false para evitar exceções.

Habilitar GZIP Compression

  • Reduz o tamanho da resposta HTTP, melhorando o tempo de resposta.
properties
CopiarEditar
server.compression.enabled=true
server.compression.mime-types=application/json,application/xml

🌍 Escalabilidade para Alta Demanda

Configurar Pool de Conexões

  • Use HikariCP (default do Spring Boot) e ajuste corretamente:
properties
CopiarEditar
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5

Rate Limiting e Circuit Breaker

  • Evita sobrecarga e protege contra quedas de serviços externos.
  • Utilize Spring Cloud Gateway + Resilience4j para limitar requisições:
java
CopiarEditar
@RateLimiter(name = "default", fallbackMethod = "fallbackMethod")

Implementar Load Balancer

  • Se tiver múltiplas instâncias, use NGINX, Kubernetes ou Spring Cloud LoadBalancer para distribuir requisições.

Monitoramento e Logging

  • Utilize Actuator + Prometheus + Grafana para monitorar métricas.
  • Configure logs estruturados com ELK Stack (Elasticsearch, Logstash, Kibana).

😊 Essas práticas tornam a API mais rápida, eficiente e escalável! 🚀

DIO Community
DIO Community - 10/02/2025 17:39

Lilian, seu artigo é um roteiro prático e bem estruturado para quem deseja iniciar um projeto Spring Boot, cobrindo desde a configuração inicial até a implementação de uma API RESTful completa. A forma como você organiza a estrutura do projeto, utilizando boas práticas como arquitetura em camadas (Model, Repository, Service e Controller), demonstra uma abordagem profissional para desenvolvimento backend. O uso do Spring Data JPA e Lombok para reduzir código boilerplate também é um ótimo destaque, tornando o desenvolvimento mais produtivo e limpo.

Outro ponto essencial é a expansão para segurança e autenticação com JWT e Spring Security, algo indispensável para aplicações em produção. A menção ao deploy na cloud utilizando Docker e Heroku reforça a importância da escalabilidade e facilita a transição para ambientes reais.

Na DIO, incentivamos o aprendizado prático e aplicado, e esse guia é um excelente ponto de partida para quem deseja construir APIs robustas com Java. Para quem quer dar um passo além, quais seriam as melhores práticas para otimizar o desempenho de uma API Spring Boot e garantir escalabilidade em ambientes de alta demanda?