Mikroservis Mimarisi İçin Bilinmesi Gereken 25 Tasarım Deseni

// build.gradle: implementation 'io.github.resilience4j:resilience4j-spring-boot3'

@Service
public class InventoryClient {

    private final RestTemplate restTemplate;

    public InventoryClient(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @CircuitBreaker(name = "inventoryService", fallbackMethod = "fallbackStock")
    public StockResponse checkStock(String productId) {
        return restTemplate.getForObject(
            "http://inventory-service/stock/" + productId, StockResponse.class);
    }

    // Fallback imzası eşleşmeli + ekstra Throwable parametresi almalı
    private StockResponse fallbackStock(String productId, Throwable t) {
        return new StockResponse(productId, 0, "UNAVAILABLE");
    }
}

# application.yml
resilience4j.circuitbreaker:
  instances:
    inventoryService:
      sliding-window-size: 10
      failure-rate-threshold: 50
      wait-duration-in-open-state: 5s
      permitted-number-of-calls-in-half-open-state: 3

@Retry(name = "paymentService", fallbackMethod = "fallbackCharge")
public ChargeResponse chargeCard(ChargeRequest request) {
    return paymentClient.charge(request);
}

private ChargeResponse fallbackCharge(ChargeRequest request, Throwable t) {
    return ChargeResponse.failed("Ödeme servisi yeniden denemelerden sonra hala erişilemez durumda");
}

resilience4j.retry:
  instances:
    paymentService:
      max-attempts: 3
      wait-duration: 500ms
      retry-exceptions:
        - java.io.IOException
        - org.springframework.web.client.ResourceAccessException

@Bulkhead(name = "reportingService", type = Bulkhead.Type.THREADPOOL)
public CompletableFuture<Report> generateReport(String orgId) {
    return CompletableFuture.supplyAsync(() -> reportingClient.generate(orgId));
}

resilience4j.thread-pool-bulkhead:
  instances:
    reportingService:
      max-thread-pool-size: 10
      core-thread-pool-size: 5
      queue-capacity: 20

// Orkestrasyon tabanlı saga - basit bir durum makinesi ile
public class OrderSagaOrchestrator {

    public void startSaga(Order order) {
        try {
            paymentService.charge(order.getPaymentInfo());
            inventoryService.reserve(order.getItems());
            shippingService.schedule(order);
            orderService.markCompleted(order.getId());
        } catch (PaymentException e) {
            orderService.markFailed(order.getId(), "Ödeme başarısız");
        } catch (InventoryException e) {
            paymentService.refund(order.getPaymentInfo()); // telafi edici aksiyon
            orderService.markFailed(order.getId(), "Envanter yetersiz");
        } catch (ShippingException e) {
            inventoryService.release(order.getItems());     // telafi edici aksiyon
            paymentService.refund(order.getPaymentInfo());  // telafi edici aksiyon
            orderService.markFailed(order.getId(), "Kargo başarısız");
        }
    }
}

@Configuration
public class GatewayRoutesConfig {

    @Bean
    public RouteLocator routes(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("order-service", r -> r.path("/api/orders/**")
                .filters(f -> f
                    .circuitBreaker(c -> c.setName("orderServiceCB")
                        .setFallbackUri("forward:/fallback/orders"))
                    .requestRateLimiter(rl -> rl.setRateLimiter(redisRateLimiter())))
                .uri("lb://ORDER-SERVICE"))
            .route("payment-service", r -> r.path("/api/payments/**")
                .uri("lb://PAYMENT-SERVICE"))
            .build();
    }

    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(10, 20); // saniyede 10 istek, patlama (burst) 20
    }
}

// Order Service - kendini kaydeder
@SpringBootApplication
@EnableDiscoveryClient
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

// Payment Service - Order Service'i sabit IP yerine mantıksal isimle keşfeder
@Service
public class OrderClient {

    private final RestTemplate restTemplate;

    public OrderClient(@LoadBalanced RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public Order getOrder(String id) {
        return restTemplate.getForObject("http://ORDER-SERVICE/orders/" + id, Order.class);
    }
}

eureka:
  client:
    service-url:
      defaultZone: http://eureka-server:8761/eureka

// Order Service - PostgreSQL
@Entity
@Table(name = "orders")
public class Order {
    @Id @GeneratedValue
    private Long id;
    private String customerId;
    private BigDecimal totalAmount;
    // Order servisi asla Payment veya Inventory veritabanını doğrudan sorgulamaz
}

// order-service için application.yml
spring:
  datasource:
    url: jdbc:postgresql://order-db:5432/orders_db

// inventory-service için application.yml (tamamen farklı bir teknoloji)
spring:
  data:
    mongodb:
      uri: mongodb://inventory-db:27017/inventory_db

// Order Service - bir olay yayınlar
@Service
public class OrderService {

    private final KafkaTemplate<String, OrderCreatedEvent> kafkaTemplate;

    public void createOrder(Order order) {
        orderRepository.save(order);
        OrderCreatedEvent event = new OrderCreatedEvent(order.getId(), order.getItems());
        kafkaTemplate.send("order-events", order.getId().toString(), event);
    }
}

// Payment Service - olayı dinler
@Component
public class OrderCreatedListener {

    @KafkaListener(topics = "order-events", groupId = "payment-service")
    public void handleOrderCreated(OrderCreatedEvent event) {
        paymentService.processPayment(event.getOrderId(), event.getItems());
    }
}

// Inventory Service ve Notification Service AYNI konuya bağımsız olarak abone olur
@KafkaListener(topics = "order-events", groupId = "inventory-service")
public void reserveStock(OrderCreatedEvent event) { /* ... */ }

// YAZMA tarafı - komut modeli
@Service
public class CreateOrderCommandHandler {

    private final OrderWriteRepository writeRepository; // normalize edilmiş yazma veritabanı

    public void handle(CreateOrderCommand command) {
        Order order = new Order(command.getCustomerId(), command.getItems());
        writeRepository.save(order);
        eventPublisher.publish(new OrderCreatedEvent(order));
    }
}

// OKUMA tarafı - ayrı, denormalize edilmiş sorgu modeli, asenkron olarak güncellenir
@Component
public class OrderReadModelUpdater {

    @KafkaListener(topics = "order-events")
    public void on(OrderCreatedEvent event) {
        OrderSummaryView view = new OrderSummaryView(
            event.getOrderId(), event.getCustomerName(), event.getTotal());
        readRepository.save(view); // ör. Elasticsearch veya bir read-replica tablo
    }
}

@RestController
public class OrderQueryController {
    @GetMapping("/orders/{id}/summary")
    public OrderSummaryView getSummary(@PathVariable String id) {
        return readRepository.findById(id); // hızlı, denormalize okuma
    }
}

public class Account {
    private String accountId;
    private BigDecimal balance = BigDecimal.ZERO;
    private final List<Object> uncommittedEvents = new ArrayList<>();

    public void deposit(BigDecimal amount) {
        apply(new MoneyDepositedEvent(accountId, amount));
    }

    public void withdraw(BigDecimal amount) {
        if (balance.compareTo(amount) < 0) throw new InsufficientFundsException();
        apply(new MoneyWithdrawnEvent(accountId, amount));
    }

    private void apply(Object event) {
        mutate(event);
        uncommittedEvents.add(event);
    }

    private void mutate(Object event) {
        if (event instanceof MoneyDepositedEvent e) balance = balance.add(e.amount());
        if (event instanceof MoneyWithdrawnEvent e) balance = balance.subtract(e.amount());
    }

    // Durumu geçmişten yeniden oluştur
    public static Account rehydrate(String id, List<Object> history) {
        Account account = new Account();
        account.accountId = id;
        history.forEach(account::mutate);
        return account;
    }
}

// Bir cephe/gateway, hangi özelliğin taşındığına göre yönlendirme yapar
@RestController
public class StranglerFacadeController {

    private final NewOrderServiceClient newOrderService;
    private final LegacyMonolithClient legacyMonolith;

    @GetMapping("/orders/{id}")
    public ResponseEntity<Order> getOrder(@PathVariable String id) {
        if (featureFlags.isEnabled("orders-migrated-to-microservice")) {
            return ResponseEntity.ok(newOrderService.getOrder(id));
        }
        return ResponseEntity.ok(legacyMonolith.getOrder(id));
    }
}

# Uygulama + sidecar içeren Kubernetes pod'u
apiVersion: v1
kind: Pod
metadata:
  name: order-service-pod
spec:
  containers:
    - name: order-service
      image: order-service:1.0
      ports:
        - containerPort: 8080
    - name: envoy-sidecar
      image: envoyproxy/envoy:v1.28
      ports:
        - containerPort: 9901 # admin/metrikler

// Java uygulamasının mTLS, yeniden deneme veya izleme (tracing) başlıklarından
// haberdar olmasına gerek yok - sidecar (Envoy) trafiği şeffaf şekilde yakalar.
@RestController
public class OrderController {
    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable String id) {
        return orderService.findById(id); // sadece iş mantığı
    }
}

// Uygulama kodu, gerçek dış servislerden habersiz, YEREL bir ambassador proxy'sini çağırır
@Service
public class ExternalServiceClient {

    private final RestTemplate restTemplate;

    public ServiceAResponse callServiceA(Request req) {
        // localhost'taki ambassador'ı çağırır, o da gerçek "External Service 1"e yönlendirir
        // ve yolda retry/circuit-breaking/loglama uygular
        return restTemplate.postForObject("http://localhost:9000/service-a", req, ServiceAResponse.class);
    }

    public ServiceBResponse callServiceB(Request req) {
        return restTemplate.postForObject("http://localhost:9001/service-b", req, ServiceBResponse.class);
    }
}

// Modern uygulamanızın beklediği hedef arayüz
public interface PaymentGateway {
    PaymentResult pay(BigDecimal amount, String currency);
}

// Uyumsuz arayüze sahip eski sistem
public class LegacyPaymentSystem {
    public LegacyResponseCode processPaymentInCents(long amountInCents, String currencyCode) {
        // eski SOAP/legacy çağrısı
        return LegacyResponseCode.OK;
    }
}

// Adapter ikisi arasında köprü kurar
public class LegacyPaymentAdapter implements PaymentGateway {

    private final LegacyPaymentSystem legacySystem;

    @Override
    public PaymentResult pay(BigDecimal amount, String currency) {
        long cents = amount.multiply(BigDecimal.valueOf(100)).longValue();
        LegacyResponseCode code = legacySystem.processPaymentInCents(cents, currency);
        return code == LegacyResponseCode.OK ? PaymentResult.success() : PaymentResult.failure();
    }
}

public interface ProductService {
    Product getProduct(String id);
}

public class RealProductService implements ProductService {
    @Override
    public Product getProduct(String id) {
        return database.findById(id); // maliyetli veritabanı çağrısı
    }
}

public class CachingProductServiceProxy implements ProductService {

    private final RealProductService realService;
    private final Map<String, Product> cache = new ConcurrentHashMap<>();

    public CachingProductServiceProxy(RealProductService realService) {
        this.realService = realService;
    }

    @Override
    public Product getProduct(String id) {
        return cache.computeIfAbsent(id, realService::getProduct);
    }
}

public interface NotificationSender {
    void send(String recipient, String message);
}

public class EmailSender implements NotificationSender { /* ... */ }
public class SmsSender implements NotificationSender { /* ... */ }
public class PushSender implements NotificationSender { /* ... */ }

public class NotificationSenderFactory {
    public static NotificationSender create(NotificationType type) {
        return switch (type) {
            case EMAIL -> new EmailSender();
            case SMS -> new SmsSender();
            case PUSH -> new PushSender();
        };
    }
}

// Kullanım
NotificationSender sender = NotificationSenderFactory.create(NotificationType.SMS);
sender.send("+905551234567", "Siparişiniz kargoya verildi!");

public interface ShippingStrategy {
    BigDecimal calculate(Order order);
}

public class StandardShipping implements ShippingStrategy {
    public BigDecimal calculate(Order order) { return BigDecimal.valueOf(5.99); }
}

public class ExpressShipping implements ShippingStrategy {
    public BigDecimal calculate(Order order) { return BigDecimal.valueOf(15.99); }
}

public class ShippingCalculator {
    private final ShippingStrategy strategy;

    public ShippingCalculator(ShippingStrategy strategy) {
        this.strategy = strategy; // çalışma zamanında enjekte edilir, ör. Spring @Qualifier ile
    }

    public BigDecimal calculateCost(Order order) {
        return strategy.calculate(order);
    }
}

// Olay
public record OrderPlacedEvent(String orderId, BigDecimal total) {}

// Özne yayınlar
@Service
public class OrderService {
    private final ApplicationEventPublisher publisher;

    public void placeOrder(Order order) {
        orderRepository.save(order);
        publisher.publishEvent(new OrderPlacedEvent(order.getId(), order.getTotal()));
    }
}

// Birden fazla gözlemci bağımsız olarak tepki verir
@Component
public class LoyaltyPointsObserver {
    @EventListener
    public void onOrderPlaced(OrderPlacedEvent event) {
        loyaltyService.addPoints(event.orderId(), event.total());
    }
}

@Component
public class AnalyticsObserver {
    @EventListener
    public void onOrderPlaced(OrderPlacedEvent event) {
        analyticsService.track(event);
    }
}

public class ConfigurationManager {

    private static volatile ConfigurationManager instance;
    private final Map<String, String> settings = new ConcurrentHashMap<>();

    private ConfigurationManager() { /* ayarları yükle */ }

    public static ConfigurationManager getInstance() {
        if (instance == null) {
            synchronized (ConfigurationManager.class) {
                if (instance == null) {
                    instance = new ConfigurationManager();
                }
            }
        }
        return instance;
    }
}

// İdiomatik Spring yolu - singleton kapsamı zaten varsayılandır:
@Service // Spring container tarafından yönetilen tek, paylaşılan bir örnek
public class ConfigurationService {
    // ...
}

public final class OrderRequest {
    private final String customerId;
    private final List<OrderItem> items;
    private final String couponCode; // opsiyonel
    private final boolean giftWrap;  // opsiyonel

    private OrderRequest(Builder builder) {
        this.customerId = builder.customerId;
        this.items = builder.items;
        this.couponCode = builder.couponCode;
        this.giftWrap = builder.giftWrap;
    }

    public static class Builder {
        private String customerId;
        private List<OrderItem> items = new ArrayList<>();
        private String couponCode;
        private boolean giftWrap = false;

        public Builder customerId(String customerId) { this.customerId = customerId; return this; }
        public Builder items(List<OrderItem> items) { this.items = items; return this; }
        public Builder couponCode(String couponCode) { this.couponCode = couponCode; return this; }
        public Builder giftWrap(boolean giftWrap) { this.giftWrap = giftWrap; return this; }

        public OrderRequest build() { return new OrderRequest(this); }
    }
}

// Kullanım
OrderRequest request = new OrderRequest.Builder()
    .customerId("cust-123")
    .items(cartItems)
    .couponCode("SAVE10")
    .giftWrap(true)
    .build();

public interface OrderProcessor {
    void process(Order order);
}

public class BasicOrderProcessor implements OrderProcessor {
    @Override
    public void process(Order order) { /* temel işleme mantığı */ }
}

public class LoggingOrderProcessorDecorator implements OrderProcessor {
    private final OrderProcessor delegate;
    public LoggingOrderProcessorDecorator(OrderProcessor delegate) { this.delegate = delegate; }

    @Override
    public void process(Order order) {
        log.info("Sipariş işleniyor {}", order.getId());
        delegate.process(order);
        log.info("Sipariş tamamlandı {}", order.getId());
    }
}

public class ValidatingOrderProcessorDecorator implements OrderProcessor {
    private final OrderProcessor delegate;
    public ValidatingOrderProcessorDecorator(OrderProcessor delegate) { this.delegate = delegate; }

    @Override
    public void process(Order order) {
        if (order.getItems().isEmpty()) throw new IllegalArgumentException("Boş sipariş");
        delegate.process(order);
    }
}

// Dekoratörleri birleştir
OrderProcessor processor = new LoggingOrderProcessorDecorator(
    new ValidatingOrderProcessorDecorator(
        new BasicOrderProcessor()));
processor.process(order);

public interface OrderRepository extends JpaRepository<Order, Long> {
    List<Order> findByCustomerId(String customerId);
    Optional<Order> findByIdAndStatus(Long id, OrderStatus status);
}

@Service
public class OrderService {

    private final OrderRepository orderRepository; // iş mantığı asla doğrudan SQL/JDBC'ye dokunmaz

    public List<Order> getCustomerOrders(String customerId) {
        return orderRepository.findByCustomerId(customerId);
    }
}

public interface NotificationService {
    void notify(String userId, String message);
}

@Service
public class EmailNotificationService implements NotificationService {
    @Override
    public void notify(String userId, String message) { /* e-posta gönder */ }
}

@Service
public class OrderService {

    private final NotificationService notificationService; // enjekte edilir, "new EmailNotificationService()" değil

    // Constructor injection - field injection'a tercih edilir
    public OrderService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void completeOrder(Order order) {
        // ...
        notificationService.notify(order.getCustomerId(), "Sipariş tamamlandı!");
    }
}

@Service
public class OrderService {

    @Transactional
    public void createOrder(Order order) {
        orderRepository.save(order); // 1. iş işlemi (veritabanı güncellemesi)

        OutboxEvent event = new OutboxEvent(
            UUID.randomUUID().toString(),
            "Order",
            order.getId().toString(),
            "OrderCreated",
            toJson(order)
        );
        outboxRepository.save(event); // 2. outbox tablosuna yaz - AYNI transaction, AYNI commit
    }
}

// 3. Ayrı bir poller (veya Debezium CDC) broker'a yayınlar
@Scheduled(fixedDelay = 500)
public void publishOutboxEvents() {
    List<OutboxEvent> pending = outboxRepository.findUnpublished();
    for (OutboxEvent event : pending) {
        kafkaTemplate.send("order-events", event.getPayload());
        outboxRepository.markPublished(event.getId());
    }
}

@RestController
public class PaymentController {

    private final IdempotencyKeyRepository idempotencyRepo;
    private final PaymentService paymentService;

    @PostMapping("/payments")
    public ResponseEntity<PaymentResult> charge(
            @RequestHeader("Idempotency-Key") String idempotencyKey,
            @RequestBody ChargeRequest request) {

        Optional<PaymentResult> existing = idempotencyRepo.findResult(idempotencyKey);
        if (existing.isPresent()) {
            return ResponseEntity.ok(existing.get()); // önceki yanıtı döndür, yeniden işleme
        }

        PaymentResult result = paymentService.charge(request);
        idempotencyRepo.save(idempotencyKey, result);
        return ResponseEntity.ok(result);
    }
}

// Kafka tüketicileri için de aynı prensip (en-az-bir-kez teslimat)
@KafkaListener(topics = "payment-events")
public void handle(PaymentEvent event) {
    if (processedEventRepository.existsById(event.getEventId())) {
        return; // zaten işlendi - atla
    }
    paymentService.process(event);
    processedEventRepository.save(new ProcessedEvent(event.getEventId()));
}