Microservices com Spring Boot: Arquitetura, Padrões e Boas Práticas

Introdução

A arquitetura de microservices (ou microsserviços) tornou-se um dos paradigmas mais utilizados na engenharia de software moderna, principalmente em sistemas distribuídos e de larga escala.

Ela propõe a divisão de uma aplicação monolítica em múltiplos serviços independentes, autônomos e escaláveis, que se comunicam entre si por meio de APIs bem definidas (geralmente REST ou mensageria).

O Spring Boot, em conjunto com o Spring Cloud, forma o ecossistema Java mais completo e maduro para implementação de microservices. Ele abstrai boa parte da complexidade envolvida em tópicos como descoberta de serviços, configuração centralizada, tolerância a falhas, comunicação assíncrona e observabilidade.

O que são Microservices?

Um microservice é uma unidade de negócio isolada, executada de forma independente, responsável por um conjunto coeso de funcionalidades.

Cada serviço deve:

Comparativo com Monólitos

O Ecossistema Spring para Microservices

O Spring Boot simplifica a criação de aplicações Java baseadas em Spring, eliminando a necessidade de configurações extensas.

Já o Spring Cloud adiciona o suporte completo à infraestrutura de microsserviços distribuídos.

Principais módulos do Spring Cloud

Estrutura de um Projeto de Microservices com Spring

Um ecossistema típico baseado em Spring Boot + Spring Cloud pode conter:

TEXT
Código copiado!
├── config-server
│   └── src/main/java/... (central de configuração)
├── discovery-server (Eureka)
│   └── src/main/java/... (registro de serviços)
├── api-gateway
│   └── src/main/java/... (roteamento de APIs)
├── user-service
│   └── src/main/java/... (serviço de usuários)
├── order-service
│   └── src/main/java/... (serviço de pedidos)
└── common-libs
    └── src/main/java/... (DTOs, exceptions, utils)

Cada serviço é um projeto Spring Boot isolado, versionado e implantado de forma independente.

Exemplo Prático: Criando um Microservice com Spring Boot

Criando o projeto

No Spring InitializrSpring Initializr:

Gerando o projeto user-service.

Exemplo de entidade

JAVA
Código copiado!
@Entity
@Table(name = "tb_users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private UUID id;

    private String name;
    private String email;
}

Repositório e serviço

JAVA
Código copiado!
public interface UserRepository extends JpaRepository<User, UUID> {
    Optional<User> findByEmail(String email);
}

@Service
public class UserService {
    @Autowired
    private UserRepository repository;

    public User save(User user) {
        return repository.save(user);
    }

    public List<User> findAll() {
        return repository.findAll();
    }
}

Controller REST

JAVA
Código copiado!
@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService service;

    public UserController(UserService service) {
        this.service = service;
    }

    @GetMapping
    public ResponseEntity<List<User>> getAll() {
        return ResponseEntity.ok(service.findAll());
    }

    @PostMapping
    public ResponseEntity<User> save(@RequestBody User user) {
        return ResponseEntity.status(HttpStatus.CREATED).body(service.save(user));
    }
}

Comunicação entre Microservices com OpenFeign

JAVA
Código copiado!
@FeignClient(name = "order-service")
public interface OrderClient {

    @GetMapping("/orders/user/{userId}")
    List<OrderResponse> getOrdersByUser(@PathVariable UUID userId);
}

E no application.yml:

YAML
Código copiado!
spring:
  application:
    name: user-service

eureka:
  client:
    service-url:
      defaultZone: <http://localhost:8761/eureka/>

Com isso, o user-service pode consultar dinamicamente o order-service registrado no Eureka Server.

Resiliência e Tolerância a Falhas com Resilience4j

O Spring Cloud oferece integração com o Resilience4j para aplicar padrões como Circuit Breaker, Retry e Rate Limiter.

JAVA
Código copiado!
@CircuitBreaker(name = "orderServiceCB", fallbackMethod = "fallbackOrders")
public List<OrderResponse> getOrders(UUID userId) {
    return orderClient.getOrdersByUser(userId);
}

public List<OrderResponse> fallbackOrders(UUID userId, Throwable ex) {
    return List.of();
}

Observabilidade e Monitoramento

Spring Boot Actuator

Fornece métricas prontas:

TEXT
Código copiado!
/actuator/health
/actuator/metrics
/actuator/prometheus

Sleuth + Zipkin

Permitem rastrear uma requisição entre múltiplos microservices, gerando trace IDs e span IDs que ajudam a entender gargalos e latência.

YAML
Código copiado!
spring:
  zipkin:
    base-url: <http://localhost:9411>
  sleuth:
    sampler:
      probability: 1.0

Comunicação Assíncrona com RabbitMQ ou Kafka

Para reduzir acoplamento e garantir resiliência, muitos sistemas Spring Cloud utilizam mensageria.

Exemplo com Spring AMQP:

JAVA
Código copiado!
@Component
public class UserProducer {

    private final RabbitTemplate template;

    public UserProducer(RabbitTemplate template) {
        this.template = template;
    }

    public void sendUserCreatedEvent(User user) {
        template.convertAndSend("user.exchange", "user.created", user);
    }
}

No application.yml:

YAML
Código copiado!
spring:
  rabbitmq:
    host: localhost
    username: guest
    password: guest

🧩 Padrões Arquiteturais Importantes

Deploy e Infraestrutura

Em ambientes modernos, os microservices são containerizados com Docker e orquestrados por Kubernetes.

Dockerfile exemplo:

DOCKER
Código copiado!
FROM openjdk:21-jdk-slim
WORKDIR /app
COPY target/user-service.jar app.jar
ENTRYPOINT ["java","-jar","app.jar"]

Kubernetes Deployment (YAML):

YAML
Código copiado!
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: rafael/user-service:1.0.0
        ports:
        - containerPort: 8080

Boas Práticas e Recomendações

Conclusão

Desenvolver microservices com Spring Boot e Spring Cloud oferece flexibilidade, escalabilidade e robustez, mas também demanda maturidade arquitetural, automação, e boas práticas de design.

Ao adotar esses padrões — como configuração centralizada, service discovery, gateway, resiliência e observabilidade — é possível construir um ecossistema Java moderno, de alta disponibilidade e preparado para a nuvem.

Dica: comece pequeno. Migre funcionalidades de um monólito gradualmente, valide comunicação, monitore desempenho e evolua o ecossistema aos poucos.

Referências