Interface ve Abstract Class — Rol mü, İskelet mi?

1
public interface PaymentMethod {
2

3
    String code();
4

5
    ChargeResult charge(ChargeRequest request);
6

7
    // Added a year after the first implementations shipped. Abstract, it would have broken
8
    // every team's build; this default is correct for all of them: a person reviews it.
9
    default RefundResult refund(RefundRequest request) {
10
        return RefundResult.manualReview(request, code() + " has no automatic refund");
11
    }
12
}

1
// Shared state and shared steps for methods that settle through the bank's own switch.
2
public abstract class AbstractPaymentMethod implements PaymentMethod {
3

4
    protected final String merchantId;
5
    private final ChargeAttempts attempts;   // idempotency store keyed by request id
6

7
    protected AbstractPaymentMethod(String merchantId, ChargeAttempts attempts) {
8
        this.merchantId = merchantId;
9
        this.attempts = attempts;
10
    }
11

12
    // The template: every subclass gets the duplicate-charge guard for free.
13
    @Override
14
    public final ChargeResult charge(ChargeRequest request) {
15
        return attempts.findResult(request.id())
16
                .orElseGet(() -> attempts.record(request.id(), doCharge(request)));
17
    }
18

19
    protected abstract ChargeResult doCharge(ChargeRequest request);
20
}

1
public final class CardPayment extends AbstractPaymentMethod {
2

3
    private final CardNetworkClient network;
4

5
    public CardPayment(String merchantId, ChargeAttempts attempts, CardNetworkClient network) {
6
        super(merchantId, attempts);
7
        this.network = network;
8
    }
9

10
    @Override
11
    public String code() {
12
        return "CARD";
13
    }
14

15
    @Override
16
    protected ChargeResult doCharge(ChargeRequest request) {
17
        return network.authorizeAndCapture(merchantId, request.cardToken(), request.amount());
18
    }
19

20
    // Cards can refund on their own, so this method replaces the default.
21
    @Override
22
    public RefundResult refund(RefundRequest request) {
23
        return network.refund(merchantId, request.originalChargeId(), request.amount());
24
    }
25
}

1
// Already extends the core-banking client: its one parent is taken.
2
// It could never join AbstractPaymentMethod, but it can take on the role.
3
public final class LegacyTransfer extends CoreBankingClient implements PaymentMethod {
4

5
    public LegacyTransfer(CoreBankingConfig config) {
6
        super(config);
7
    }
8

9
    @Override
10
    public String code() {
11
        return "LEGACY_TRANSFER";
12
    }
13

14
    @Override
15
    public ChargeResult charge(ChargeRequest request) {
16
        return postTransfer(request.debtorIban(), request.creditorIban(), request.amount());
17
    }
18

19
    // No refund() here: the default sends it to manual review, and nothing broke.
20
}

1
@Service
2
class RefundService {
3

4
    private final PaymentMethods methods;        // looks a method up by its code
5
    private final ManualReviewQueue manualQueue;
6

7
    RefundService(PaymentMethods methods, ManualReviewQueue manualQueue) {
8
        this.methods = methods;
9
        this.manualQueue = manualQueue;
10
    }
11

12
    RefundResult refund(RefundRequest request) {
13
        RefundResult result = methods.byCode(request.methodCode()).refund(request);
14
        if (result.needsManualReview()) {
15
            manualQueue.enqueue(request, result.reason());   // back office picks it up
16
        }
17
        return result;
18
    }
19
}