TP1 - Configuração de Datasource e Pool de Conexões

Objetivos do TP

Neste TP, você irá:

1. ✅ Configurar um datasource H2 para desenvolvimento
2. ✅ Configurar um datasource PostgreSQL para produção
3. ✅ Otimizar os parâmetros do HikariCP
4. ✅ Monitorar o pool de conexões com o Actuator
5. ✅ Simular uma saturação do pool

Duração estimada: 1 hora

---

Pré-requisitos

• Módulos 1 a 6 concluídos
• IntelliJ IDEA ou VS Code
• PostgreSQL instalado (ou Docker)
• Maven

---

Parte 1: Criação do Projeto

1.1 Criar o Projeto com Spring Initializr

Crie um novo projeto com:

• Artifact: datasource-demo
• Dependências:
  • Spring Web
  • Spring Data JPA
  • H2 Database
  • PostgreSQL Driver
  • Spring Boot Actuator
  • Lombok

1.2 Estrutura do Projeto

datasource-demo/
├── src/main/java/com/example/datasourcedemo/
│   ├── DatasourceDemoApplication.java
│   ├── model/
│   │   └── Product.java
│   ├── repository/
│   │   └── ProductRepository.java
│   ├── service/
│   │   └── ProductService.java
│   └── controller/
│       └── ProductController.java
└── src/main/resources/
    ├── application.properties
    ├── application-dev.properties
    └── application-prod.properties

---

Parte 2: Entidade e Repository

2.1 Criar a Entidade Product

// src/main/java/com/example/datasourcedemo/model/Product.java
package com.example.datasourcedemo.model;

import jakarta.persistence.*;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;

import java.math.BigDecimal;
import java.time.LocalDateTime;

@Entity
@Table(name = "products")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Product {

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

    @Column(nullable = false)
    private String name;

    private String description;

    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;

    @Column(nullable = false)
    private Integer stock;

    @Column(name = "created_at")
    private LocalDateTime createdAt = LocalDateTime.now();
}

2.2 Criar o Repository

// src/main/java/com/example/datasourcedemo/repository/ProductRepository.java
package com.example.datasourcedemo.repository;

import com.example.datasourcedemo.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByStockLessThan(Integer threshold);
}

2.3 Criar o Service

// src/main/java/com/example/datasourcedemo/service/ProductService.java
package com.example.datasourcedemo.service;

import com.example.datasourcedemo.model.Product;
import com.example.datasourcedemo.repository.ProductRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@RequiredArgsConstructor
@Slf4j
public class ProductService {

    private final ProductRepository productRepository;

    public List<Product> getAllProducts() {
        log.info("Recuperando todos os produtos");
        return productRepository.findAll();
    }

    public Product createProduct(Product product) {
        log.info("Criando produto: {}", product.getName());
        return productRepository.save(product);
    }

    public Product getProduct(Long id) {
        return productRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Produto não encontrado: " + id));
    }

    // Método para simular uma requisição lenta
    public List<Product> getAllProductsSlow() throws InterruptedException {
        log.info("Iniciando requisição lenta...");
        Thread.sleep(5000);  // 5 segundos
        log.info("Fim da requisição lenta");
        return productRepository.findAll();
    }
}

2.4 Criar o Controller

// src/main/java/com/example/datasourcedemo/controller/ProductController.java
package com.example.datasourcedemo.controller;

import com.example.datasourcedemo.model.Product;
import com.example.datasourcedemo.service.ProductService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

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

    private final ProductService productService;

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

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

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

    // Endpoint para testar conexões
    @GetMapping("/slow")
    public List<Product> getProductsSlow() throws InterruptedException {
        return productService.getAllProductsSlow();
    }
}

---

Parte 3: Configuração de Desenvolvimento (H2)

3.1 Configuração Básica

# application.properties (configuração comum)

# Perfil ativo por padrão
spring.profiles.active=dev

# Actuator
management.endpoints.web.exposure.include=health,metrics,info
management.endpoint.health.show-details=always

# Logging
logging.level.com.zaxxer.hikari=DEBUG
logging.level.org.hibernate.SQL=DEBUG

3.2 Configuração H2 (Desenvolvimento)

# application-dev.properties

# ===== DATASOURCE H2 =====
spring.datasource.url=jdbc:h2:mem:devdb;DB_CLOSE_DELAY=-1
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# Console H2
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

# ===== JPA =====
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

# ===== HIKARI (Pool de conexões) =====
spring.datasource.hikari.pool-name=DevPool
spring.datasource.hikari.minimum-idle=2
spring.datasource.hikari.maximum-pool-size=5
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=300000
spring.datasource.hikari.max-lifetime=600000

# Detecção de vazamentos (30 segundos)
spring.datasource.hikari.leak-detection-threshold=30000

3.3 Testar

# Iniciar a aplicação
mvn spring-boot:run

# Ou com o perfil explícito
mvn spring-boot:run -Dspring-boot.run.profiles=dev

Verificações:

1. Abrir http://localhost:8080/h2-console
2. JDBC URL: jdbc:h2:mem:devdb
3. Conexão com sa / (vazio)

---

Parte 4: Configuração de Produção (PostgreSQL)

4.1 Iniciar PostgreSQL com Docker

# Criar e iniciar o PostgreSQL
docker run --name postgres-demo \
  -e POSTGRES_USER=demo \
  -e POSTGRES_PASSWORD=demo123 \
  -e POSTGRES_DB=productdb \
  -p 5432:5432 \
  -d postgres:15

4.2 Configuração PostgreSQL

# application-prod.properties

# ===== DATASOURCE POSTGRESQL =====
spring.datasource.url=jdbc:postgresql://localhost:5432/productdb
spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.username=demo
spring.datasource.password=demo123

# Console H2 desativado
spring.h2.console.enabled=false

# ===== JPA =====
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=false
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

# ===== HIKARI (Pool otimizado para produção) =====
spring.datasource.hikari.pool-name=ProdPool
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000

# Validação das conexões
spring.datasource.hikari.connection-test-query=SELECT 1

# Detecção de vazamentos (60 segundos)
spring.datasource.hikari.leak-detection-threshold=60000

4.3 Iniciar em Modo Produção

# Com o perfil prod
mvn spring-boot:run -Dspring-boot.run.profiles=prod

---

Parte 5: Monitoramento com Actuator

5.1 Endpoints HikariCP

Inicie a aplicação e teste estas URLs:

# Saúde global
curl http://localhost:8080/actuator/health

# Métricas HikariCP
curl http://localhost:8080/actuator/metrics/hikaricp.connections

# Conexões ativas
curl http://localhost:8080/actuator/metrics/hikaricp.connections.active

# Conexões inativas
curl http://localhost:8080/actuator/metrics/hikaricp.connections.idle

# Conexões em espera
curl http://localhost:8080/actuator/metrics/hikaricp.connections.pending

# Tempo de aquisição de conexão
curl http://localhost:8080/actuator/metrics/hikaricp.connections.acquire

5.2 Criar um Endpoint de Diagnóstico

// src/main/java/com/example/datasourcedemo/controller/PoolInfoController.java
package com.example.datasourcedemo.controller;

import com.zaxxer.hikari.HikariDataSource;
import com.zaxxer.hikari.HikariPoolMXBean;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/pool")
@RequiredArgsConstructor
public class PoolInfoController {

    private final DataSource dataSource;

    @GetMapping("/info")
    public Map<String, Object> getPoolInfo() {
        HikariDataSource hikariDS = (HikariDataSource) dataSource;
        HikariPoolMXBean poolMXBean = hikariDS.getHikariPoolMXBean();

        Map<String, Object> info = new HashMap<>();
        info.put("poolName", hikariDS.getPoolName());
        info.put("maximumPoolSize", hikariDS.getMaximumPoolSize());
        info.put("minimumIdle", hikariDS.getMinimumIdle());
        info.put("activeConnections", poolMXBean.getActiveConnections());
        info.put("idleConnections", poolMXBean.getIdleConnections());
        info.put("totalConnections", poolMXBean.getTotalConnections());
        info.put("threadsAwaitingConnection", poolMXBean.getThreadsAwaitingConnection());

        return info;
    }
}

Teste:

curl http://localhost:8080/api/pool/info

Resultado esperado:

{
  "poolName": "DevPool",
  "maximumPoolSize": 5,
  "minimumIdle": 2,
  "activeConnections": 0,
  "idleConnections": 2,
  "totalConnections": 2,
  "threadsAwaitingConnection": 0
}

---

Parte 6: Simular uma Saturação do Pool

6.1 Configuração para o Teste

Altere temporariamente o application-dev.properties:

# Pool bem pequeno para testar
spring.datasource.hikari.maximum-pool-size=2
spring.datasource.hikari.connection-timeout=5000  # 5 segundos

6.2 Script de Teste

Crie um script para enviar várias requisições simultâneas:

# test-pool.sh (Linux/Mac)
#!/bin/bash

echo "Enviando 5 requisições simultâneas..."

for i in {1..5}; do
    curl -s http://localhost:8080/api/products/slow &
done

wait
echo "Finalizado!"

Ou com PowerShell (Windows):

# test-pool.ps1
Write-Host "Enviando 5 requisições simultâneas..."

$jobs = @()
for ($i = 1; $i -le 5; $i++) {
    $jobs += Start-Job -ScriptBlock {
        Invoke-RestMethod -Uri "http://localhost:8080/api/products/slow"
    }
}

$jobs | Wait-Job | Receive-Job
Write-Host "Finalizado!"

6.3 Observar os Logs

HikariPool-1 - Pool stats (total=2, active=2, idle=0, waiting=3)
HikariPool-1 - Connection is not available, request timed out after 5001ms.

6.4 Corrigir

# Aumentar o pool
spring.datasource.hikari.maximum-pool-size=10

# Ou aumentar o timeout
spring.datasource.hikari.connection-timeout=60000

---

Parte 7: Dados de Teste

7.1 Criar data.sql

-- src/main/resources/data.sql
INSERT INTO products (name, description, price, stock, created_at) VALUES
('Laptop Pro', 'Notebook de alta performance', 1299.99, 50, CURRENT_TIMESTAMP),
('Mouse Sem Fio', 'Mouse ergonômico Bluetooth', 49.99, 200, CURRENT_TIMESTAMP),
('Teclado Mecânico', 'Teclado gamer RGB', 129.99, 75, CURRENT_TIMESTAMP),
('Monitor 27 polegadas', 'Monitor 4K IPS', 399.99, 30, CURRENT_TIMESTAMP),
('Webcam HD', 'Câmera 1080p com microfone', 79.99, 100, CURRENT_TIMESTAMP);

7.2 Ativar a Inicialização

# application-dev.properties
spring.jpa.defer-datasource-initialization=true
spring.sql.init.mode=always

---

Verificação Final

Checklist

• A aplicação inicia com o perfil dev (H2)
• O console H2 está acessível
• Os endpoints /api/products funcionam
• As métricas do Actuator estão disponíveis
• /api/pool/info retorna as estatísticas do pool
• O teste de saturação mostra os timeouts
• A aplicação inicia com o perfil prod (PostgreSQL)

Testes a Realizar

# 1. Criar um produto
curl -X POST http://localhost:8080/api/products \
  -H "Content-Type: application/json" \
  -d '{"name":"Test","price":99.99,"stock":10}'

# 2. Listar os produtos
curl http://localhost:8080/api/products

# 3. Verificar o pool
curl http://localhost:8080/api/pool/info

# 4. Verificar a saúde
curl http://localhost:8080/actuator/health

---

Resumo

Neste TP, você aprendeu a:

Competência	Descrição
Configuração multi-profile	dev (H2) vs prod (PostgreSQL)
HikariCP	Parâmetros do pool de conexões
Actuator	Monitoramento de métricas
Diagnóstico	Endpoint personalizado para o pool
Testes de carga	Simular saturação

---

🎯 Próximo Passo

Agora que você domina a configuração de datasources, aprenda a gerenciar transações no próximo TP.

➡️ TP7.2: Transações e Rollback

---

⬅️ Voltar ao Módulo 7