Kalıtım ve Kompozisyon — Kimin İç Ayrıntısına Bağlısın?

1
public interface Payments {
2

3
    PaymentReceipt pay(Payment payment);
4

5
    List<PaymentReceipt> payAll(List<Payment> batch);
6
}

1
// Talks to the clearing provider's SDK through its public methods only.
2
final class ClearingPayments implements Payments {
3

4
    private final ClearingGateway gateway;   // vendor SDK class, not ours to change
5

6
    ClearingPayments(ClearingGateway gateway) {
7
        this.gateway = gateway;
8
    }
9

10
    @Override
11
    public PaymentReceipt pay(Payment payment) {
12
        return gateway.pay(payment);
13
    }
14

15
    @Override
16
    public List<PaymentReceipt> payAll(List<Payment> batch) {
17
        return gateway.payAll(batch);
18
    }
19
}

1
// Counts each customer's outgoing payments against a daily limit.
2
// A scheduled job clears usedToday at midnight; it is left out here.
3
final class DailyLimitPayments implements Payments {
4

5
    private final Payments inner;
6
    private final BigDecimal dailyLimit;
7
    private final Map<String, BigDecimal> usedToday = new HashMap<>();
8

9
    DailyLimitPayments(Payments inner, BigDecimal dailyLimit) {
10
        this.inner = inner;
11
        this.dailyLimit = dailyLimit;
12
    }
13

14
    @Override
15
    public PaymentReceipt pay(Payment payment) {
16
        reserve(List.of(payment));
17
        try {
18
            return inner.pay(payment);
19
        } catch (RuntimeException ex) {
20
            release(List.of(payment));   // a failed payment must not eat into the limit
21
            throw ex;
22
        }
23
    }
24

25
    @Override
26
    public List<PaymentReceipt> payAll(List<Payment> batch) {
27
        reserve(batch);
28
        try {
29
            // Whatever inner.payAll calls internally never comes back through this class,
30
            // so every payment is counted exactly once.
31
            return inner.payAll(batch);
32
        } catch (RuntimeException ex) {
33
            release(batch);
34
            throw ex;
35
        }
36
    }
37

38
    // All or nothing: the whole batch fits the limit, or nothing is reserved.
39
    private synchronized void reserve(List<Payment> payments) {
40
        Map<String, BigDecimal> after = new HashMap<>();
41
        for (Payment payment : payments) {
42
            after.merge(payment.customerNo(), payment.amount(), BigDecimal::add);
43
        }
44
        after.replaceAll((customerNo, amount) -> amount.add(usedToday.getOrDefault(customerNo, BigDecimal.ZERO)));
45
        for (Map.Entry<String, BigDecimal> entry : after.entrySet()) {
46
            if (entry.getValue().compareTo(dailyLimit) > 0) {
47
                throw new IllegalStateException("daily limit exceeded for customer " + entry.getKey());
48
            }
49
        }
50
        usedToday.putAll(after);
51
    }
52

53
    private synchronized void release(List<Payment> payments) {
54
        for (Payment payment : payments) {
55
            usedToday.merge(payment.customerNo(), payment.amount().negate(), BigDecimal::add);
56
        }
57
    }
58
}

1
@Configuration
2
class PaymentsConfig {
3

4
    // Read inside out: the provider, wrapped by the adapter, wrapped by the limit.
5
    @Bean
6
    Payments payments(ClearingGateway gateway, @Value("${payments.daily-limit-try}") BigDecimal dailyLimit) {
7
        return new DailyLimitPayments(new ClearingPayments(gateway), dailyLimit);
8
    }
9
}

1
// Counter-example: the limit bolted on by extending the vendor's class.
2
public class CountingClearingGateway extends ClearingGateway {
3

4
    private final DailyUsage usage;
5

6
    public CountingClearingGateway(DailyUsage usage) {
7
        this.usage = usage;
8
    }
9

10
    @Override
11
    public PaymentReceipt pay(Payment payment) {
12
        usage.add(payment);
13
        return super.pay(payment);
14
    }
15

16
    @Override
17
    public List<PaymentReceipt> payAll(List<Payment> batch) {
18
        batch.forEach(usage::add);
19
        // The vendor's payAll calls pay() for each item, which is the override above:
20
        // every payment in a batch is counted twice. A new SDK version may change that.
21
        return super.payAll(batch);
22
    }
23
}