Explorando o uso do Spring Boot e Docker para criar microservices escaláveis em Java: um guia prático para desenvolvedores que busca otimizar suas aplicações e integrar novas tecnologias com eficiência

Introdução

Com o crescimento das aplicações digitais, a necessidade de projetos escaláveis se tornou uma prioridade para muitos desenvolvedores. O Spring Boot, um framework que simplifica o desenvolvimento de aplicativos Java, e o Docker, uma ferramenta que permite a criação de contêineres, se combinam perfeitamente para facilitar a criação de microserviços. Neste tutorial, você aprenderá a criar serviços resilientes e facilmente escaláveis usando Spring Boot. Vamos explorar como configurar um ambiente de desenvolvimento, construir um microserviço, testar a aplicação e, por fim, empacotar tudo isso em um contêiner Docker. Se você é um desenvolvedor em busca de expandir suas habilidades e melhorar a escalabilidade de suas aplicações, este guia é para você.

Etapas

1. Configuração do Ambiente de Desenvolvimento

   Para começar, verifique se você tem o JDK (Java Development Kit) e o Maven instalados em sua máquina. Para isso, utilize os comandos `java -version` e `mvn -version`. Caso ainda não tenha essas ferramentas instaladas, procure as instruções oficiais para cada uma. Além disso, assegure-se de ter o Docker instalado para empacotar a aplicação posteriormente.

   commands

   # Verificar o JDK
   java -version
   # Verificar o Maven
   mvn -version
   # Verificar o Docker
   docker --version

2. Criação do Projeto Spring Boot

   Acesse o Spring Initializr (https://start.spring.io) e crie um novo projeto com as seguintes configurações: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão estável, **Packaging**: Jar, **Java**: 11 ou superior. Adicione as dependências ‘Spring Web’, ‘Spring Data JPA’ e ‘H2 Database’. Baixe o projeto gerado e descompacte-o em seu ambiente local.

   pom.xml

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.example</groupId>
     <artifactId>microservice-demo</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <name>microservice-demo</name>
     <description>Demo para microserviços com Spring Boot</description>
     <properties>
       <java.version>11</java.version>
     </properties>
     <dependencies>
       <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-jpa</artifactId>
       </dependency>
       <dependency>
         <groupId>com.h2database</groupId>
         <artifactId>h2</artifactId>
         <scope>runtime</scope>
       </dependency>
       <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
       </dependency>
     </dependencies>
     <build>
       <plugins>
         <plugin>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
       </plugins>
     </build>
   </project>

3. Configuração do Banco de Dados H2

   Edite o arquivo `application.properties` para definir as propriedades de conexão com o banco de dados H2 e habilitar o console web, permitindo a visualização dos dados durante o desenvolvimento.

   application.properties

   spring.h2.console.enabled=true
   spring.datasource.url=jdbc:h2:mem:testdb
   spring.datasource.driverClassName=org.h2.Driver
   spring.datasource.username=sa
   spring.datasource.password=
   spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
   spring.jpa.hibernate.ddl-auto=update

4. Criação da Entidade `Produto`

   Implemente a classe modelo `Produto` que representará os produtos da aplicação. Utilize anotações JPA para mapear a classe a uma tabela do banco de dados.

   Produto.java

   package com.example.microservicedemo.model;
   
   import javax.persistence.*;
   
   @Entity
   @Table(name = "produtos")
   public class Produto {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long id;
   
       @Column(nullable = false)
       private String nome;
   
       @Column(nullable = false)
       private Double preco;
   
       // Getters e Setters
       //... (implementação dos getters e setters)

5. Criação do Repositório `ProdutoRepository`

   Implemente a interface `ProdutoRepository`, que estende `JpaRepository` e fornece métodos de CRUD para gerenciar a entidade `Produto`.

   ProdutoRepository.java

   package com.example.microservicedemo.repository;
   
   import com.example.microservicedemo.model.Produto;
   import org.springframework.data.jpa.repository.JpaRepository;
   import org.springframework.stereotype.Repository;
   
   @Repository
   public interface ProdutoRepository extends JpaRepository<Produto, Long> {
       // Métodos adicionais podem ser definidos aqui
   }

6. Implementação do Serviço `ProdutoService`

   Crie a classe `ProdutoService` que conterá a lógica de negócios e fará uso do `ProdutoRepository` para interagir com o banco de dados.

   ProdutoService.java

   package com.example.microservicedemo.service;
   
   import com.example.microservicedemo.model.Produto;
   import com.example.microservicedemo.repository.ProdutoRepository;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Service;
   
   import java.util.List;
   import java.util.Optional;
   
   @Service
   public class ProdutoService {
       @Autowired
       private ProdutoRepository produtoRepository;
   
       public List<Produto> findAll() {
           return produtoRepository.findAll();
       }
   
       public Optional<Produto> findById(Long id) {
           return produtoRepository.findById(id);
       }
   
       public Produto save(Produto produto) {
           return produtoRepository.save(produto);
       }
   
       public Produto update(Long id, Produto produtoDetails) {
           Produto produto = produtoRepository.findById(id).orElseThrow(() -> new RuntimeException("Produto não encontrado"));
           produto.setNome(produtoDetails.getNome());
           produto.setPreco(produtoDetails.getPreco());
           return produtoRepository.save(produto);
       }
   
       public void deleteById(Long id) {
           produtoRepository.deleteById(id);
       }
   }

7. Implementação do Controlador `ProdutoController`

   Implemente a classe `ProdutoController`, que expõe os endpoints da API e permite a execução de operações CRUD sobre a entidade `Produto`.

   ProdutoController.java

   package com.example.microservicedemo.controller;
   
   import com.example.microservicedemo.model.Produto;
   import com.example.microservicedemo.service.ProdutoService;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.http.ResponseEntity;
   import org.springframework.web.bind.annotation.*;
   
   import java.util.List;
   
   @RestController
   @RequestMapping("/api/produtos")
   public class ProdutoController {
       @Autowired
       private ProdutoService produtoService;
   
       @GetMapping
       public List<Produto> getAllProdutos() {
           return produtoService.findAll();
       }
   
       @GetMapping("/{id}")
       public ResponseEntity<Produto> getProdutoById(@PathVariable Long id) {
           return produtoService.findById(id)
                   .map(ResponseEntity::ok)
                   .orElse(ResponseEntity.notFound().build());
       }
   
       @PostMapping
       public Produto createProduto(@RequestBody Produto produto) {
           return produtoService.save(produto);
       }
   
       @PutMapping("/{id}")
       public ResponseEntity<Produto> updateProduto(@PathVariable Long id, @RequestBody Produto produtoDetails) {
           return ResponseEntity.ok(produtoService.update(id, produtoDetails));
       }
   
       @DeleteMapping("/{id}")
       public ResponseEntity<Void> deleteProduto(@PathVariable Long id) {
           produtoService.deleteById(id);
           return ResponseEntity.noContent().build();
       }
   }

8. Implementação de Testes Unitários

   Desenvolva a classe de testes `ProdutoServiceTest` para validar a lógica da aplicação e garantir que os métodos de CRUD funcionem conforme esperado.

   ProdutoServiceTest.java

   package com.example.microservicedemo.service;
   
   import com.example.microservicedemo.model.Produto;
   import com.example.microservicedemo.repository.ProdutoRepository;
   import org.junit.jupiter.api.BeforeEach;
   import org.junit.jupiter.api.Test;
   import org.mockito.InjectMocks;
   import org.mockito.Mock;
   import org.mockito.MockitoAnnotations;
   
   import java.util.Arrays;
   import java.util.List;
   import java.util.Optional;
   
   import static org.junit.jupiter.api.Assertions.*;
   import static org.mockito.Mockito.*;
   
   public class ProdutoServiceTest {
       @InjectMocks
       private ProdutoService produtoService;
   
       @Mock
       private ProdutoRepository produtoRepository;
   
       @BeforeEach
       public void init() {
           MockitoAnnotations.openMocks(this);
       }
   
       @Test
       public void testFindAll() {
           Produto produto1 = new Produto();
           produto1.setId(1L);
           produto1.setNome("Produto 1");
           produto1.setPreco(10.0);
   
           Produto produto2 = new Produto();
           produto2.setId(2L);
           produto2.setNome("Produto 2");
           produto2.setPreco(20.0);
   
           when(produtoRepository.findAll()).thenReturn(Arrays.asList(produto1, produto2));
   
           List<Produto> produtos = produtoService.findAll();
           assertEquals(2, produtos.size());
           verify(produtoRepository, times(1)).findAll();
       }
   
       // Testes adicionais para métodos como findById, save, update e deleteById
   }

9. Executando a Aplicação e Testes

   Com tudo configurado, utilize o Maven para compilar e executar a aplicação. Depois, você pode usar ferramentas como Postman ou cURL para testar os endpoints da API.

   commands

   # Compilar e executar a aplicação
   mvn spring-boot:run
   # Executar os testes unitários
   mvn test

   curl_examples

   # Listar todos os produtos
   curl -X GET http://localhost:8080/api/produtos
   # Criar um novo produto
   curl -X POST -H "Content-Type: application/json" -d '{"nome":"Novo Produto", "preco":99.99}' http://localhost:8080/api/produtos

10. Empacotando a Aplicação com Docker

    Agora, vamos criar um arquivo `Dockerfile` para empacotar nossa aplicação em um contêiner Docker. Este arquivo irá instruir o Docker sobre como construir a imagem para nossa aplicação Spring Boot.

    Dockerfile

    FROM openjdk:11-jre
    VOLUME /tmp
    COPY target/microservice-demo-0.0.1-SNAPSHOT.jar app.jar
    ENTRYPOINT ["java", "-jar", "app.jar"]

11. Construindo e Executando o Contêiner Docker

    Com o Dockerfile criado, você pode construir a imagem Docker da sua aplicação e executá-la. Use os seguintes comandos para construir e rodar o contêiner.

    commands

    # Construir a imagem Docker
    docker build -t microservice-demo .
    # Executar o contêiner Docker
    docker run -p 8080:8080 microservice-demo

Conclusão

Neste tutorial, você aprendeu a construir um microserviço escalável utilizando Spring Boot, incluindo a configuração do ambiente, implementação das camadas de dados, serviços, controladores e testes unitários. Além disso, você aprendeu a empacotar a aplicação com Docker, facilitando a implantação em qualquer ambiente que suporte contêineres. Com essas habilidades, você está preparado para desenvolver aplicações modernas e escaláveis em Java. Continue explorando novas técnicas e aprimorando seu conhecimento em desenvolvimento de software.

Hashtags

#Java #SpringBoot #Microservices #Docker #Development #RESTAPI