Introdução

Neste tutorial, você aprenderá a criar microserviços utilizando o framework Micronaut, que se destaca por sua eficiência e leveza em aplicações Java. Vamos passar pelo ciclo de desenvolvimento completo, desde a configuração inicial do projeto até a implementação de testes automatizados. Micronaut é altamente otimizado para construção de microserviços, utilizando injeção de dependências a compile-time, o que reduz consideravelmente o tempo de inicialização e o consumo de memória. Este guia é voltado para desenvolvedores que querem explorar práticas modernas no desenvolvimento de software e integrar ferramentas populares de maneira fluida.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o JDK (Java Development Kit) e o SDK do Micronaut instalados em sua máquina. Verifique as versões instaladas com os comandos `java -version` e `mn –version`. Se o Micronaut não estiver instalado, você pode instalar usando o SDKMAN! ou outros métodos disponíveis na documentação oficial do Micronaut.

    commands
    # Verificar versões instaladas
    java -version
    mn --version

  2. Criação do Projeto Micronaut

    Use o comando do Micronaut para gerar um novo projeto com as dependências necessárias. Defina o nome do projeto como `micronaut-demo`. Adicione a dependência ‘micronaut-http-client’ para permitir chamadas HTTP internas e ‘micronaut-data-hibernate-jpa’ para integração com bancos de dados.

    commands
    mn create-app micronaut-demo --features http-client,data-jpa,h2

  3. Configuração do Banco de Dados H2

    Modifique o arquivo `src/main/resources/application.yml` para configurar as propriedades do banco de dados H2 e setar o modo de console web.

    application.yml
    micronaut:
  application:
    name: micronaut-demo
  datasource:
    default:
      driverClassName: org.h2.Driver
      url: jdbc:h2:mem:default;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
      username: sa
      password:
      dialect: H2
      hikari:
        maximum-pool-size: 5

  4. Criação da Entidade `Produto`

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

    Produto.java
    package com.example.micronautdemo.model;

import io.micronaut.data.annotationid;
import io.micronaut.data.model.primaryKey;
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
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public Double getPreco() {
        return preco;
    }

    public void setPreco(Double preco) {
        this.preco = preco;
    }
}

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

    Implemente a interface `ProdutoRepository`, que estende `CrudRepository` do Micronaut Data, permitindo acesso à camada de persistência.

    ProdutoRepository.java
    package com.example.micronautdemo.repository;

import com.example.micronautdemo.model.Produto;
import io.micronaut.data.annotation.Repository;
import io.micronaut.data.repository.CrudRepository;

@Repository
public interface ProdutoRepository extends CrudRepository<Produto, Long> {
    // Métodos personalizados podem ser definidos aqui
}

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

    Crie a classe `ProdutoService`, que contém a lógica de negócios e utiliza o `ProdutoRepository` para interagir com o banco de dados.

    ProdutoService.java
    package com.example.micronautdemo.service;

import com.example.micronautdemo.model.Produto;
import com.example.micronautdemo.repository.ProdutoRepository;
import jakarta.inject.Singleton;
import java.util.List;

@Singleton
public class ProdutoService {
    private final ProdutoRepository produtoRepository;

    public ProdutoService(ProdutoRepository produtoRepository) {
        this.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 void deleteById(Long id) {
        produtoRepository.deleteById(id);
    }
}

  7. Implementação do Controlador `ProdutoController`

    Crie a classe `ProdutoController` para expor os endpoints da API, permitindo operações CRUD.

    ProdutoController.java
    package com.example.micronautdemo.controller;

import com.example.micronautdemo.model.Produto;
import com.example.micronautdemo.service.ProdutoService;
import io.micronaut.http.annotation.*;

import java.util.List;

@Controller("/produtos")
public class ProdutoController {
    private final ProdutoService produtoService;

    public ProdutoController(ProdutoService produtoService) {
        this.produtoService = produtoService;
    }

    @GetMapping
    public List<Produto> getAllProdutos() {
        return produtoService.findAll();
    }

    @GetMapping("/{id}")
    public Optional<Produto> getProdutoById(@PathVariable Long id) {
        return produtoService.findById(id);
    }

    @PostMapping
    public Produto createProduto(@Body Produto produto) {
        return produtoService.save(produto);
    }

    @DeleteMapping("/{id}")
    public void deleteProduto(@PathVariable Long id) {
        produtoService.deleteById(id);
    }
}

  8. Implementação de Testes Unitários

    Crie a classe de testes `ProdutoServiceTest` para validar a lógica de negócios e operações CRUD da aplicação utilizando Micronaut Test.

    ProdutoServiceTest.java
    package com.example.micronautdemo.service;

import com.example.micronautdemo.model.Produto;
import com.example.micronautdemo.repository.ProdutoRepository;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import java.util.Collections;

@MicronautTest
public class ProdutoServiceTest {
    @Inject
    private ProdutoService produtoService;

    @Inject
    private ProdutoRepository produtoRepository;

    @Test
    public void testFindAll() {
        when(produtoRepository.findAll()).thenReturn(Collections.singletonList(new Produto()));
        List<Produto> produtos = produtoService.findAll();
        assertEquals(1, produtos.size());
    }

    // Testes adicionais para os métodos findById, save e deleteById
}

  9. Executando a Aplicação e Testes

    Use o Gradle para compilar e executar a aplicação. Em seguida, utilize ferramentas como Postman ou cURL para testar os endpoints da API.

    commands
    # Compilar e executar a aplicação
    ./gradlew run
    # Executar os testes unitários
    ./gradlew test

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

Conclusão

Neste tutorial, você aprendeu a desenvolver microserviços eficientes utilizando Micronaut, cobrindo todo o processo, desde a configuração do ambiente até a implementação de testes unitários. Através desse guia, você obteve experiência em práticas modernas que promovem a escalabilidade e a performance das suas aplicações Java. Com o Micronaut como seu aliado, você pode explorar ainda mais a criação de microserviços e expandir suas habilidades no desenvolvimento de software.

Hashtags

#Micronaut #Microserviços #Java #DesenvolvimentoDeSoftware #API #TestesUnitários