Patterns — Cheat Sheet

Strangler Fig Pattern

# Spring Cloud Gateway — strangler routing config
# Phase 1: everything goes to monolith
spring:
  cloud:
    gateway:
      routes:
        - id: monolith
          uri: http://monolith-service
          predicates: [Path=/**]

# Phase 2: order endpoints → new order-service, rest → monolith
spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: http://order-service
          predicates: [Path=/api/orders/**, /api/order-items/**]
          order: 1

        - id: monolith-fallback
          uri: http://monolith-service
          predicates: [Path=/**]
          order: 100    # lower precedence

Idempotency in APIs

@Component
public class IdempotencyInterceptor implements HandlerInterceptor {

    private final StringRedisTemplate redis;

    @Override
    public boolean preHandle(HttpServletRequest req,
                             HttpServletResponse res, Object handler) throws Exception {
        String key = req.getHeader("Idempotency-Key");
        if (key == null) return true;           // key optional for GET

        String cached = redis.opsForValue().get("idem:" + key);
        if (cached != null) {
            res.setStatus(200);
            res.setContentType("application/json");
            res.getWriter().write(cached);
            return false;                       // short-circuit, reply cached
        }
        return true;
    }

    // Call this from controller advice after response committed
    public void cacheResponse(String key, String responseBody) {
        redis.opsForValue().set("idem:" + key, responseBody,
                Duration.ofHours(24));
    }
}

Feature Flags in Microservices

// application.yml — feature flags as properties
features:
  new-checkout-flow: true
  experimental-pricing: false
  max-order-size-check: true

// Configuration properties class
@ConfigurationProperties(prefix = "features")
@Component
public class FeatureFlags {
    private boolean newCheckoutFlow;
    private boolean experimentalPricing;
    private boolean maxOrderSizeCheck;
    // getters/setters or use @ConstructorBinding record
}

// Usage in service
@Service
public class CheckoutService {

    private final FeatureFlags flags;

    public CheckoutResult checkout(Cart cart, User user) {
        if (flags.isNewCheckoutFlow()) {
            return newCheckoutFlowService.process(cart, user);
        }
        return legacyCheckoutService.process(cart, user);
    }
}

// Toggle without redeployment via K8s ConfigMap reload
# kubectl patch configmap app-config
# --patch '{"data":{"features.new-checkout-flow":"true"}}'
# (requires spring.config.import=kubernetes: + @RefreshScope or restart)

Backward Compatibility & Contract Testing

// Consumer side — define contract in a consumer test
@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "inventory-service")
public class InventoryClientContractTest {

    @Pact(consumer = "order-service")
    public RequestResponsePact stockLookupPact(PactDslWithProvider builder) {
        return builder
            .given("product 101 exists with stock 50")
            .uponReceiving("a request for product stock")
                .path("/stock/101")
                .method("GET")
            .willRespondWith()
                .status(200)
                .body(new PactDslJsonBody()
                    .integerType("productId", 101)    // type-only matching (flexible)
                    .integerType("quantity", 50)
                    .stringType("unit", "units"))
            .toPact();
    }

    @Test
    @PactTestFor(pactMethod = "stockLookupPact")
    public void testStockLookup(MockServer mockServer) {
        InventoryClient client = new InventoryClient(mockServer.getUrl());
        StockResponse response = client.getStock(101L);
        assertThat(response.getQuantity()).isGreaterThanOrEqualTo(0);
        // Pact generates a contract JSON file — publish to Pact Broker
    }
}

Graceful Shutdown

# application.properties
server.shutdown=graceful
spring.lifecycle.timeout-per-shutdown-phase=20s   # wait up to 20s for in-flight HTTP requests

# --- Kubernetes Deployment YAML ---
spec:
  containers:
    - name: order-service
      lifecycle:
        preStop:
          exec:
            command: ["sh", "-c", "sleep 5"]    # wait 5s after deregister before SIGTERM
  terminationGracePeriodSeconds: 30              # total time before SIGKILL
  # Timeline:
  # t=0:  SIGTERM sent + preStop hook runs (5s sleep)
  # t=5:  Spring receives SIGTERM → stops accepting new requests
  # t=25: Drain window closes (20s)
  # t=30: SIGKILL if process still running

Microservices Anti-Patterns

// ANTI-PATTERN: Shared Database — OrderService and InventoryService
// both access the same "shop" database directly

// OrderService
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    // queries shop.orders table
}

// InventoryService — WRONG: directly queries shop.orders to check order status
@Repository
public interface OrderQueryRepository extends JpaRepository<Order, Long> {
    // BAD: InventoryService depends on OrderService's database schema
    @Query("SELECT o FROM Order o WHERE o.status = 'PLACED'")
    List<Order> findPlacedOrders();
}

// SOLUTION: Each service owns its data; cross-service data via API or events
// OrderService exposes: GET /orders?status=PLACED
// InventoryService calls OrderService's API (or subscribes to order-placed events)

// Or better: InventoryService maintains its own read model
// populated by consuming "order-placed" Kafka events
@KafkaListener(topics = "order-placed")
public void onOrderPlaced(OrderPlacedEvent event) {
    // InventoryService maintains its own copy of relevant order data
    pendingOrderRepository.save(new PendingOrder(event.getOrderId(), event.getItems()));
}