Decomposing a monolith into microservices

package com.bank.antipattern;

// WRONG: Decompose by technical layer.
// Every transfer touches ALL three services.
public class WrongDecomposition {
    // controller-service -> handles HTTP
    // business-service   -> handles logic
    // dao-service         -> handles database
    // Result: every feature change touches all three.
    // This is a distributed monolith.
}

// CORRECT: Decompose by business capability.
public class CorrectDecomposition {
    // payment-service -> owns transfer logic + its own DB
    // account-service -> owns balance + its own DB
    // Each feature lives in ONE service.
}

package com.bank.gateway;

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class StranglerFigRoutes {

    @Bean
    public RouteLocator routes(RouteLocatorBuilder builder) {
        return builder.routes()
            // Phase 2: Payment extracted to new service
            .route("payment-new", r -> r
                .path("/api/v1/payments/**")
                .uri("lb://payment-service"))
            // Everything else still hits the monolith
            .route("monolith-fallback", r -> r
                .path("/api/**")
                .uri("http://monolith:8080"))
            .build();
    }
}

Strangler Fig phases:
Phase 1: /api/** -> monolith
Phase 2: /api/v1/payments/** -> payment-service (new)
         /api/**            -> monolith
Phase 3: /api/v1/accounts/** -> account-service (new)
         /api/**             -> monolith
Phase N: monolith deleted

package com.bank.payment;

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import java.util.logging.Logger;

// Payment Service keeps a local read model of account data
// Updated by consuming account-events from Kafka.
@Component
public class AccountReadModel {

    private static final Logger LOG = Logger.getLogger(AccountReadModel.class.getName());
    private final LocalAccountCacheRepository cacheRepo;

    public AccountReadModel(LocalAccountCacheRepository cacheRepo) {
        this.cacheRepo = cacheRepo;
    }

    @KafkaListener(topics = "account-events", groupId = "payment-service")
    public void onAccountEvent(AccountEvent event) {
        cacheRepo.upsert(event.getAccountId(), event.getHolderName());
        LOG.info("Local read model updated: " + event.getAccountId());
    }
}

Before (monolith):
  SELECT p.*, a.holder_name
  FROM payments p JOIN accounts a ON p.from_account_id = a.id

After (microservices):
  Option 1: Call account-service API (synchronous)
  Option 2: Consume account-events -> local read model (async, preferred)
  NEVER: Direct SELECT against account-service's database.

package com.bank.saga;

import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.logging.Logger;

@Service
public class TransferSaga {

    private static final Logger LOG = Logger.getLogger(TransferSaga.class.getName());
    private final AccountClient accountClient;

    public TransferSaga(AccountClient accountClient) {
        this.accountClient = accountClient;
    }

    public void execute(String fromId, String toId, BigDecimal amount) {
        try {
            accountClient.debit(fromId, amount);  // Step 1: local tx
            accountClient.credit(toId, amount);   // Step 2: local tx
            LOG.info("Transfer saga completed: " + fromId + " -> " + toId);
        } catch (Exception e) {
            accountClient.credit(fromId, amount);  // Compensation
            LOG.warning("Transfer saga compensated: re-credited " + fromId);
        }
    }
}

Before: @Transactional -> debit + credit in one atomic operation
After:  Saga -> debit, then credit, compensate on failure
Trade-off: eventual consistency instead of strong ACID.

Dependency analysis:
  Notification: 0 inbound deps (nothing calls it)
  Fraud:        1 inbound dep (Payment calls it)
  Payment:      2 inbound deps (Gateway, Account)
  Account:      3 inbound deps (Payment, Loan, Fraud)

Extraction order:
  1. Notification (fewest deps, easiest)
  2. Fraud (one caller, clear boundary)
  3. Payment (moderate deps)
  4. Account (most deps, hardest, extract last)

package com.bank.antipattern;

// WRONG: Premature split. Unclear domain, frequent cross-service changes.
public class PrematureSplit {
    // Split before understanding boundaries -> distributed monolith
    // Every feature change requires coordinated deploys
}

// CORRECT: Start as a well-modularized monolith, extract when boundaries are proven.
public class ModularMonolith {
    // Modules communicate through interfaces, not shared state.
    // When a module needs independent deploy -> extract to service.
}