TP2 - Transações e Rollback

Objetivos do TP

Neste TP, você irá:

1. ✅ Criar um sistema de transferência de dinheiro com transações
2. ✅ Observar o comportamento dos rollbacks
3. ✅ Testar os diferentes níveis de propagação
4. ✅ Entender a armadilha da auto-invocação (self-invocation)
5. ✅ Utilizar transações somente leitura

Duração estimada: 1h30

---

Contexto

Você está desenvolvendo um aplicativo bancário simplificado. Uma transferência de dinheiro deve:

• Debitar a conta de origem
• Creditar a conta de destino
• Registrar a operação em um log de auditoria

Regra de ouro: Se uma etapa falhar, TUDO deve ser desfeito!

---

Parte 1: Setup do Projeto

1.1 Reaproveitar o Projeto TP7.1

Continue com o projeto datasource-demo do TP7.1, ou crie um novo projeto com as mesmas dependências.

1.2 Estrutura

src/main/java/com/example/bank/
├── model/
│   ├── Account.java
│   └── TransactionLog.java
├── repository/
│   ├── AccountRepository.java
│   └── TransactionLogRepository.java
├── service/
│   ├── AccountService.java
│   ├── TransferService.java
│   └── AuditService.java
├── controller/
│   └── TransferController.java
└── exception/
    └── InsufficientFundsException.java

---

Parte 2: As Entidades

2.1 Account (Conta Bancária)

// src/main/java/com/example/bank/model/Account.java
package com.example.bank.model;

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

import java.math.BigDecimal;

@Entity
@Table(name = "accounts")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Account {

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

    @Column(unique = true, nullable = false)
    private String accountNumber;

    @Column(nullable = false)
    private String ownerName;

    @Column(nullable = false, precision = 15, scale = 2)
    private BigDecimal balance;

    public Account(String accountNumber, String ownerName, BigDecimal balance) {
        this.accountNumber = accountNumber;
        this.ownerName = ownerName;
        this.balance = balance;
    }

    public void debit(BigDecimal amount) {
        if (this.balance.compareTo(amount) < 0) {
            throw new IllegalStateException("Saldo insuficiente");
        }
        this.balance = this.balance.subtract(amount);
    }

    public void credit(BigDecimal amount) {
        this.balance = this.balance.add(amount);
    }
}

2.2 TransactionLog (Log de Auditoria)

// src/main/java/com/example/bank/model/TransactionLog.java
package com.example.bank.model;

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

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

@Entity
@Table(name = "transaction_logs")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class TransactionLog {

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

    @Column(nullable = false)
    private String fromAccount;

    @Column(nullable = false)
    private String toAccount;

    @Column(nullable = false, precision = 15, scale = 2)
    private BigDecimal amount;

    @Column(nullable = false)
    private String status;  // SUCCESS, FAILED

    private String errorMessage;

    @Column(nullable = false)
    private LocalDateTime timestamp = LocalDateTime.now();

    public TransactionLog(String from, String to, BigDecimal amount, String status) {
        this.fromAccount = from;
        this.toAccount = to;
        this.amount = amount;
        this.status = status;
        this.timestamp = LocalDateTime.now();
    }
}

2.3 Exceção Personalizada

// src/main/java/com/example/bank/exception/InsufficientFundsException.java
package com.example.bank.exception;

public class InsufficientFundsException extends RuntimeException {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

---

Parte 3: Os Repositories

// AccountRepository.java
package com.example.bank.repository;

import com.example.bank.model.Account;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.Optional;

@Repository
public interface AccountRepository extends JpaRepository<Account, Long> {
    Optional<Account> findByAccountNumber(String accountNumber);
}

// TransactionLogRepository.java
package com.example.bank.repository;

import com.example.bank.model.TransactionLog;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface TransactionLogRepository extends JpaRepository<TransactionLog, Long> {
    List<TransactionLog> findByFromAccountOrToAccount(String from, String to);
}

---

Parte 4: Os Services

4.1 AccountService

// src/main/java/com/example/bank/service/AccountService.java
package com.example.bank.service;

import com.example.bank.exception.InsufficientFundsException;
import com.example.bank.model.Account;
import com.example.bank.repository.AccountRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.List;

@Service
@RequiredArgsConstructor
@Slf4j
public class AccountService {

    private final AccountRepository accountRepository;

    @Transactional(readOnly = true)
    public List<Account> getAllAccounts() {
        return accountRepository.findAll();
    }

    @Transactional(readOnly = true)
    public Account getAccount(String accountNumber) {
        return accountRepository.findByAccountNumber(accountNumber)
                .orElseThrow(() -> new RuntimeException("Conta não encontrada: " + accountNumber));
    }

    @Transactional
    public void debit(String accountNumber, BigDecimal amount) {
        log.info("Débito de {} na conta {}", amount, accountNumber);
        Account account = getAccount(accountNumber);
        
        if (account.getBalance().compareTo(amount) < 0) {
            throw new InsufficientFundsException(
                "Saldo insuficiente. Disponível: " + account.getBalance() + ", Solicitado: " + amount
            );
        }
        
        account.debit(amount);
        accountRepository.save(account);
        log.info("Débito realizado. Novo saldo: {}", account.getBalance());
    }

    @Transactional
    public void credit(String accountNumber, BigDecimal amount) {
        log.info("Crédito de {} na conta {}", amount, accountNumber);
        Account account = getAccount(accountNumber);
        account.credit(amount);
        accountRepository.save(account);
        log.info("Crédito realizado. Novo saldo: {}", account.getBalance());
    }

    @Transactional
    public Account createAccount(String accountNumber, String ownerName, BigDecimal initialBalance) {
        Account account = new Account(accountNumber, ownerName, initialBalance);
        return accountRepository.save(account);
    }
}

4.2 AuditService (Com REQUIRES_NEW)

// src/main/java/com/example/bank/service/AuditService.java
package com.example.bank.service;

import com.example.bank.model.TransactionLog;
import com.example.bank.repository.TransactionLogRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.List;

@Service
@RequiredArgsConstructor
@Slf4j
public class AuditService {

    private final TransactionLogRepository logRepository;

    /**
     * Log em uma NOVA transação.
     * Mesmo que a transação principal falhe, o log é mantido!
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logTransaction(String from, String to, BigDecimal amount, 
                               String status, String errorMessage) {
        log.info("Registrando transação: {} -> {} ({}€) - Status: {}", 
                from, to, amount, status);
        
        TransactionLog txLog = new TransactionLog(from, to, amount, status);
        txLog.setErrorMessage(errorMessage);
        logRepository.save(txLog);
        
        log.info("Log de transação salvo com ID: {}", txLog.getId());
    }

    @Transactional(readOnly = true)
    public List<TransactionLog> getLogsForAccount(String accountNumber) {
        return logRepository.findByFromAccountOrToAccount(accountNumber, accountNumber);
    }

    @Transactional(readOnly = true)
    public List<TransactionLog> getAllLogs() {
        return logRepository.findAll();
    }
}

4.3 TransferService (O Serviço Principal)

// src/main/java/com/example/bank/service/TransferService.java
package com.example.bank.service;

import com.example.bank.exception.InsufficientFundsException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;

@Service
@RequiredArgsConstructor
@Slf4j
public class TransferService {

    private final AccountService accountService;
    private final AuditService auditService;

    /**
     * Transferência de dinheiro COM transação.
     * Se uma etapa falhar, tudo é desfeito (exceto o log de auditoria).
     */
    @Transactional
    public void transfer(String fromAccount, String toAccount, BigDecimal amount) {
        log.info("=== Início da transferência: {} -> {} ({}€) ===", fromAccount, toAccount, amount);
        
        try {
            // Etapa 1: Debitar a conta de origem
            accountService.debit(fromAccount, amount);
            
            // Simular um erro (descomente para testar o rollback)
            // if (amount.compareTo(new BigDecimal("100")) > 0) {
            //     throw new RuntimeException("Erro simulado!");
            // }
            
            // Etapa 2: Creditar a conta de destino
            accountService.credit(toAccount, amount);
            
            // Etapa 3: Registrar o sucesso (REQUIRES_NEW = transação separada)
            auditService.logTransaction(fromAccount, toAccount, amount, "SUCCESS", null);
            
            log.info("=== Transferência realizada com sucesso! ===");
            
        } catch (InsufficientFundsException e) {
            // Registrar a falha (mesmo se a transação principal for rollback)
            auditService.logTransaction(fromAccount, toAccount, amount, "FAILED", e.getMessage());
            throw e;
            
        } catch (Exception e) {
            // Registrar a falha
            auditService.logTransaction(fromAccount, toAccount, amount, "FAILED", e.getMessage());
            throw new RuntimeException("Erro durante a transferência: " + e.getMessage(), e);
        }
    }

    /**
     * Versão SEM transação (para demonstração).
     * NÃO UTILIZAR EM PRODUÇÃO!
     */
    public void transferNoTransaction(String fromAccount, String toAccount, BigDecimal amount) {
        log.warn("⚠️ Transferência SEM transação - PERIGOSO!");
        
        // Debitar
        accountService.debit(fromAccount, amount);
        
        // Simular um erro após o débito
        throw new RuntimeException("Erro após o débito!");
        
        // O crédito nunca será executado
        // accountService.credit(toAccount, amount);
    }
}

---

Parte 5: Controller e Dados de Teste

5.1 TransferController

// src/main/java/com/example/bank/controller/TransferController.java
package com.example.bank.controller;

import com.example.bank.model.Account;
import com.example.bank.model.TransactionLog;
import com.example.bank.service.AccountService;
import com.example.bank.service.AuditService;
import com.example.bank.service.TransferService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/bank")
@RequiredArgsConstructor
public class TransferController {

    private final AccountService accountService;
    private final TransferService transferService;
    private final AuditService auditService;

    // === CONTAS ===

    @GetMapping("/accounts")
    public List<Account> getAllAccounts() {
        return accountService.getAllAccounts();
    }

    @GetMapping("/accounts/{accountNumber}")
    public Account getAccount(@PathVariable String accountNumber) {
        return accountService.getAccount(accountNumber);
    }

    // === TRANSFERÊNCIAS ===

    @PostMapping("/transfer")
    public ResponseEntity<String> transfer(@RequestBody Map<String, Object> request) {
        String from = (String) request.get("from");
        String to = (String) request.get("to");
        BigDecimal amount = new BigDecimal(request.get("amount").toString());

        transferService.transfer(from, to, amount);
        return ResponseEntity.ok("Transferência realizada com sucesso!");
    }

    @PostMapping("/transfer-no-tx")
    public ResponseEntity<String> transferNoTransaction(@RequestBody Map<String, Object> request) {
        String from = (String) request.get("from");
        String to = (String) request.get("to");
        BigDecimal amount = new BigDecimal(request.get("amount").toString());

        transferService.transferNoTransaction(from, to, amount);
        return ResponseEntity.ok("Transferência realizada com sucesso!");
    }

    // === AUDITORIA ===

    @GetMapping("/logs")
    public List<TransactionLog> getAllLogs() {
        return auditService.getAllLogs();
    }

    @GetMapping("/logs/{accountNumber}")
    public List<TransactionLog> getAccountLogs(@PathVariable String accountNumber) {
        return auditService.getLogsForAccount(accountNumber);
    }
}

5.2 Dados Iniciais

-- src/main/resources/data.sql
INSERT INTO accounts (account_number, owner_name, balance) VALUES
('ACC001', 'Alice Martin', 1000.00),
('ACC002', 'Bob Dupont', 500.00),
('ACC003', 'Charlie Bernard', 2500.00);

5.3 Configuração

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

---

Parte 6: Testes Práticos

6.1 Teste 1: Transferência Bem-Sucedida

# Verificar os saldos iniciais
curl http://localhost:8080/api/bank/accounts

# Transferência de 200€ de ACC001 para ACC002
curl -X POST http://localhost:8080/api/bank/transfer \
  -H "Content-Type: application/json" \
  -d '{"from":"ACC001", "to":"ACC002", "amount":200}'

# Verificar os novos saldos
curl http://localhost:8080/api/bank/accounts

# Verificar os logs
curl http://localhost:8080/api/bank/logs

Resultado esperado:

• ACC001: 1000 → 800€
• ACC002: 500 → 700€
• Log com status "SUCCESS"

6.2 Teste 2: Saldo Insuficiente (Rollback)

# Tentar uma transferência de 2000€ (ACC001 só tem 800€)
curl -X POST http://localhost:8080/api/bank/transfer \
  -H "Content-Type: application/json" \
  -d '{"from":"ACC001", "to":"ACC002", "amount":2000}'

# Verificar que os saldos NÃO mudaram
curl http://localhost:8080/api/bank/accounts

# Verificar que o log de falha está presente!
curl http://localhost:8080/api/bank/logs

Resultado esperado:

• ACC001: permanece 800€ (sem alteração)
• ACC002: permanece 700€ (sem alteração)
• Log com status "FAILED" e mensagem de erro

6.3 Teste 3: Sem Transação (PERIGOSO)

# Reinicie o aplicativo para resetar os dados

# Tente a transferência sem transação
curl -X POST http://localhost:8080/api/bank/transfer-no-tx \
  -H "Content-Type: application/json" \
  -d '{"from":"ACC001", "to":"ACC002", "amount":200}'

# Verificar os saldos
curl http://localhost:8080/api/bank/accounts

Resultado esperado (BUG!):

• ACC001: 1000 → 800€ (debitado!)
• ACC002: permanece 500€ (nunca creditado!)
• 200€ desapareceram! 💀

---

Parte 7: Entendendo o REQUIRES_NEW

7.1 Por que o Log de Auditoria é Mantido?

Veja este diagrama:

7.2 Exercício: Modificar o Comportamento

1. Em AuditService, troque REQUIRES_NEW por REQUIRED
2. Refaça o teste 2 (saldo insuficiente)
3. Observe: o log não é mais criado em caso de falha!

// Tente isto temporariamente:
@Transactional(propagation = Propagation.REQUIRED)  // Em vez de REQUIRES_NEW
public void logTransaction(...) { }

---

Parte 8: A Armadilha da Self-Invocation

8.1 O Problema

Adicione este método em TransferService:

// Método com a armadilha da self-invocation
public void transferWithLogging(String from, String to, BigDecimal amount) {
    log.info("Chamada externa...");
    
    // ⚠️ ARMADILHA: Chamada direta = sem proxy = sem transação!
    this.transfer(from, to, amount);  // @Transactional ignorado!
}

8.2 A Solução

@Service
@RequiredArgsConstructor
@Slf4j
public class TransferService {

    private final AccountService accountService;
    private final AuditService auditService;
    
    // Injeção de si mesmo para passar pelo proxy
    @Autowired
    private TransferService self;

    public void transferWithLogging(String from, String to, BigDecimal amount) {
        log.info("Chamada externa...");
        
        // ✅ Passa pelo proxy = transação ativa!
        self.transfer(from, to, amount);
    }
    
    @Transactional
    public void transfer(String from, String to, BigDecimal amount) {
        // ... código existente
    }
}

---

Parte 9: Transação ReadOnly

9.1 Verificar a Otimização

Adicione logging em AccountService:

@Transactional(readOnly = true)
public List<Account> getAllAccounts() {
    log.info("Transaction readOnly = true");
    List<Account> accounts = accountRepository.findAll();
    
    // Isto NÃO será persistido pois readOnly = true
    accounts.forEach(a -> a.setBalance(BigDecimal.ZERO));
    
    return accounts;
}

Teste:

curl http://localhost:8080/api/bank/accounts
# Os saldos exibidos são 0...

curl http://localhost:8080/api/bank/accounts
# Mas os saldos reais permanecem inalterados!

---

Resumo

O que Você Aprendeu

Conceito	Exemplo
@Transactional	Garante atomicidade
Rollback	Desfaz tudo em caso de erro
REQUIRES_NEW	Transação independente
readOnly	Otimização para leituras
Self-invocation	Armadilha do proxy Spring

Regras de Ouro

1. Sempre use @Transactional em operações de escrita
2. Use REQUIRES_NEW para logs de auditoria
3. Evite self-invocation
4. Use readOnly = true para leituras
5. Nunca engula exceções

---

🎯 Próximo Passo

➡️ TP7.3: Migração com Flyway

---

⬅️ Voltar ao Módulo 7