Adapter design patterns

The Adapter Design Pattern is a structural design pattern used to allow incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces, helping legacy or third-party systems integrate smoothly without modifying existing code.

✅ Benefits in the Banking Domain

• 🧩 Interoperability: Easily integrate legacy or third-party systems with your existing banking architecture.
• 🛡️ Encapsulation: You don’t expose the legacy code or modify it directly.
• 🔄 Reusability: Allows reuse of old code without rewriting.
• 🚀 Scalability: Add new adapters as new services/systems are onboarded.

📝 Real-World Scenarios in Banking

Scenario	Description	Adapter Role
Legacy Core Banking Integration	New microservices (e.g., payments, accounts) need to talk to a legacy monolith (SOAP/SDK-based).	Adapter converts REST or gRPC calls to legacy SDK/SOAP formats.
Third-Party Payment Gateway	Integrate different external payment providers (e.g., Razorpay, Paytm, Stripe).	Adapter wraps each provider’s API and exposes a unified interface to the payment microservice.
External KYC Services	Microservice needs to use multiple KYC vendors (Digilocker, Aadhaar, etc.).	Adapter normalizes vendor-specific APIs to a common KYCClient interface.
Credit Scoring Service Integration	Credit evaluation microservice connects to different bureaus (CIBIL, Experian).	Adapter translates credit bureau-specific request/response to internal format.
Report Generation with Legacy Tools	Reporting microservice relies on an old tool (like Jasper or Oracle Reports).	Adapter makes legacy tool usable through a modern service interface.
Notification System	Unified alerting system (SMS, Email, WhatsApp) using different vendors (Twilio, MSG91).	Adapters convert alert request to vendor-specific API formats.
Currency Exchange Service	Microservice interacts with different FX rate providers (Reuters, ForexAPI, etc.).	Adapter provides consistent getExchangeRate() regardless of provider.
Card Network Integration	Microservice connects with Visa, MasterCard, RuPay for card transactions.	Adapter shields the microservice from variations in card network APIs.
Loan Servicing System Migration	New loan microservices access legacy loan servicing systems.	Adapter acts as a translator between modern DTOs and legacy APIs.

🏦 Example in the Banking Domain

✅ Use Case: Integrating a Legacy Payment Gateway with a Modern Banking App

Imagine your banking application uses a standard interface called PaymentProcessor, but an old third-party system provides a class LegacyBankAPI that doesn’t follow this interface.

💻 1. Target Interface (Expected by the banking app)

  public interface PaymentProcessor {
    void processPayment(String account, double amount);
}

🧱 2. Adaptee (Legacy System with a Different Interface)

public class LegacyBankAPI {
    public void makeTransaction(String accNo, double amt) {
        System.out.println("Payment of ₹" + amt + " done to account " + accNo + " via LegacyBankAPI");
    }
}

🔌 3. Adapter (Bridges LegacyBankAPI and PaymentProcessor)

public class LegacyBankAdapter implements PaymentProcessor {

    private LegacyBankAPI legacyAPI;

    public LegacyBankAdapter(LegacyBankAPI legacyAPI) {
        this.legacyAPI = legacyAPI;
    }

    @Override
    public void processPayment(String account, double amount) {
        // Adapting the call
        legacyAPI.makeTransaction(account, amount);
    }
}

🧪 4. Client Code (Modern banking app)

public class BankApp {
    public static void main(String[] args) {
        PaymentProcessor processor = new LegacyBankAdapter(new LegacyBankAPI());
        processor.processPayment("1234567890", 5000.00);
    }
}