SOLID Principles — How SRP Violation Broke Order Processing

// ─── INTERFACE SEGREGATION ───────────────────────────────────────────────────

// VIOLATION: A fat interface forces PrinterDevice to implement fax and scan
// even if the device is a basic printer that can't do either.
interface MultifunctionDeviceBad {
    void print(String document);
    void scan(String document);   // Basic printers can't scan!
    void fax(String document);    // Basic printers can't fax!
}

// FIX: Segregate into small, focused interfaces.
// Each interface represents ONE capability.
interface Printable {
    void print(String document);
}

interface Scannable {
    void scan(String document);
}

interface Faxable {
    void fax(String phoneNumber, String document);
}

// A basic printer only implements what it actually supports.
class BasicPrinter implements Printable {
    @Override
    public void print(String document) {
        // No forced stub methods, no UnsupportedOperationException hacks
        System.out.println("[BasicPrinter] Printing: " + document);
    }
}

// An enterprise device implements everything it genuinely supports.
class EnterpriseMultifunctionPrinter implements Printable, Scannable, Faxable {
    @Override
    public void print(String document) {
        System.out.println("[Enterprise] Printing: " + document);
    }

    @Override
    public void scan(String document) {
        System.out.println("[Enterprise] Scanning: " + document);
    }

    @Override
    public void fax(String phoneNumber, String document) {
        System.out.println("[Enterprise] Faxing '" + document + "' to " + phoneNumber);
    }
}

// ─── DEPENDENCY INVERSION ─────────────────────────────────────────────────────

// The abstraction — business logic depends on THIS, not on a concrete database class.
interface NotificationSender {
    void send(String recipientEmail, String subject, String body);
}

// LOW-LEVEL detail: a concrete implementation of the abstraction.
// This class knows about SMTP — the business logic class does NOT.
class SmtpEmailSender implements NotificationSender {
    @Override
    public void send(String recipientEmail, String subject, String body) {
        // In real code this would use JavaMail. Here we simulate it.
        System.out.println("[SMTP] Sending email to " + recipientEmail);
        System.out.println("  Subject: " + subject);
        System.out.println("  Body: " + body);
    }
}

// A test double — swapped in during unit tests so we don't need a real mail server.
class FakeNotificationSender implements NotificationSender {
    private String lastRecipient;  // Stored so tests can assert on it

    @Override
    public void send(String recipientEmail, String subject, String body) {
        this.lastRecipient = recipientEmail;
        System.out.println("[TEST STUB] Pretending to send email to " + recipientEmail);
    }

    public String getLastRecipient() { return lastRecipient; }
}

// HIGH-LEVEL business logic: knows nothing about SMTP, HTTP, or any concrete sender.
// The dependency is injected — this class is testable in isolation.
class OrderConfirmationService {
    // Depends on the abstraction, NOT on SmtpEmailSender directly — DIP satisfied.
    private final NotificationSender notificationSender;

    // Dependency injected via constructor — easy to swap for tests
    public OrderConfirmationService(NotificationSender notificationSender) {
        this.notificationSender = notificationSender;
    }

    public void confirmOrder(String customerEmail, String orderId) {
        // Business logic lives here — not delivery mechanism details
        String subject = "Order Confirmed: #" + orderId;
        String body = "Your order #" + orderId + " has been confirmed. Thank you!";
        notificationSender.send(customerEmail, subject, body);
        System.out.println("Order " + orderId + " confirmation processed.");
    }
}

public class InterfaceSegregationDIPExample {
    public static void main(String[] args) {
        System.out.println("=== ISP Demo ===");
        BasicPrinter basicPrinter = new BasicPrinter();
        basicPrinter.print("Q4 Financial Report");  // Works cleanly, no stub methods

        EnterpriseMultifunctionPrinter mfp = new EnterpriseMultifunctionPrinter();
        mfp.print("Contract Draft");
        mfp.scan("Signed Contract");
        mfp.fax("+1-555-0199", "Signed Contract");

        System.out.println();
        System.out.println("=== DIP Demo — Production ===");
        // In production: inject the real SMTP sender
        OrderConfirmationService prodService =
            new OrderConfirmationService(new SmtpEmailSender());
        prodService.confirmOrder("alice@example.com", "ORD-8821");

        System.out.println();
        System.out.println("=== DIP Demo — Unit Test Scenario ===");
        // In tests: inject the fake — no mail server required
        FakeNotificationSender fakeSender = new FakeNotificationSender();
        OrderConfirmationService testService = new OrderConfirmationService(fakeSender);
        testService.confirmOrder("bob@example.com", "ORD-8822");
        System.out.println("Test verified recipient: " + fakeSender.getLastRecipient());
    }
}

// Anti-pattern 2: Preemptive abstraction — interface with single implementation
// Now you have to maintain two files for no benefit.
interface UserService {
    User findUserById(int id);
}

class UserServiceImpl implements UserService {
    @Override
    public User findUserById(int id) {
        // Only one implementation exists — the interface adds zero value.
        return new User(id, "alice");
    }
}

// Better: wait for the second implementation
// When a CachedUserService or ReadReplicaUserService is needed, introduce the interface.
class UserService {
    public User findUserById(int id) {
        return new User(id, "alice");
    }
}

// Anti-pattern 3: DIP bypassed via casting
class OrderService {
    @Autowired
    private UserRepository userRepository;  // interface injected

    public void processOrder() {
        // The interface doesn't have this method — we cast to concrete.
        // This breaks DIP: now OrderService depends on MySQLUserRepository directly.
        ((MySQLUserRepository) userRepository).executeNativeQuery("SELECT ...");
    }
}

// Correct approach: add the method to the interface or create a new abstraction.
interface UserRepository {
    User findById(int id);
    // If native query is needed, expose it via the interface.
    List<Map<String, Object>> executeNativeQuery(String sql);
}

package io.thecodeforge.solid;

import java.math.BigDecimal;

// Sealed interface — OCP: closed for modification, open for extension via permitted subtypes.
// The compiler knows exactly which implementations exist, enabling exhaustive pattern matching.
public sealed interface PaymentMethod permits CreditCard, PayPal, Crypto {
    PaymentResult process(BigDecimal amount);
}

// Records are ideal for DIP — they carry data, have no side effects, and are inherently immutable.
public record PaymentResult(boolean success, String message) {}

public final class CreditCard implements PaymentMethod {
    private final String maskedCardNumber;

    public CreditCard(String maskedCardNumber) {
        this.maskedCardNumber = maskedCardNumber;
    }

    @Override
    public PaymentResult process(BigDecimal amount) {
        System.out.println("Charging card ending in " + maskedCardNumber + ": $" + amount);
        return new PaymentResult(true, "Credit card charged.");
    }
}

public final class PayPal implements PaymentMethod {
    private final String email;

    public PayPal(String email) {
        this.email = email;
    }

    @Override
    public PaymentResult process(BigDecimal amount) {
        System.out.println("PayPal to " + email + ": $" + amount);
        return new PaymentResult(true, "PayPal processed.");
    }
}

public final class Crypto implements PaymentMethod {
    private final String walletAddress;

    public Crypto(String walletAddress) {
        this.walletAddress = walletAddress;
    }

    @Override
    public PaymentResult process(BigDecimal amount) {
        System.out.println("Crypto tx to " + walletAddress + ": $" + amount);
        return new PaymentResult(true, "Crypto broadcast.");
    }
}

// The processor uses pattern matching — no instanceof checks, no manual dispatch.
// This is still OCP-compliant: the sealed interface is closed, but new types can be added
// by adding a new permitted class (only possible if you own the hierarchy).
class PaymentProcessor {
    public void process(PaymentMethod payment, BigDecimal amount) {
        PaymentResult result = switch (payment) {
            case CreditCard cc -> cc.process(amount);
            case PayPal pp -> pp.process(amount);
            case Crypto cr -> cr.process(amount);
        };
        System.out.println("Result: " + result.message());
    }
}

public class SOLIDModernJava {
    public static void main(String[] args) {
        PaymentProcessor processor = new PaymentProcessor();
        processor.process(new CreditCard("4242"), BigDecimal.valueOf(99.99));
        processor.process(new PayPal("alice@example.com"), BigDecimal.valueOf(49.50));
    }
}

package io.thecodeforge.solid.tradeoffs;

// Trade-off example: When to add a DIP abstraction?

// Stage 1: No abstraction — fine for a solo service
class OrderNotificationService {
    public void sendConfirmation(String email, String orderId) {
        // Uses JavaMail directly
        System.out.println("Sending email to " + email + " for order " + orderId);
    }
}

// Stage 2: Second requirement arrives — now abstraction makes sense
class OrderNotificationService {
    private final EmailSender emailSender;

    public OrderNotificationService(EmailSender emailSender) {
        this.emailSender = emailSender;
    }

    public void sendConfirmation(String email, String orderId) {
        emailSender.send(email, "Order Confirmed", "Your order #" + orderId);
    }
}

interface EmailSender {
    void send(String to, String subject, String body);
}

class SmtpEmailSender implements EmailSender {
    @Override
    public void send(String to, String subject, String body) {
        // SMTP logic
    }
}

class MockEmailSender implements EmailSender {
    @Override
    public void send(String to, String subject, String body) {
        // Test debug
    }
}

// The abstraction came when the second implementation was needed, not before.

// io.thecodeforge — cs-fundamentals tutorial

# SRP violation: This class changes for different reasons
class ReportGenerator:
    def generate_report(self, data):
        # Business logic: formatting numbers
        formatted = [{"value": round(d["amount"], 2)} for d in data]
        return formatted

    def export_json(self, report):
        # Serialization logic: outputs JSON
        import json
        return json.dumps(report)

    def send_email(self, report):
        # Infrastructure logic: sends email
        import smtplib
        # ... 20 lines of SMTP config ...
        pass  # Not the point

# Quick test to see the pain:
generator = ReportGenerator()
raw_data = [{"amount": 123.4567}, {"amount": 89.0}]
report = generator.generate_report(raw_data)
print(generator.export_json(report))

// io.thecodeforge — cs-fundamentals tutorial

# BEFORE: Violates OCP — new notification type needs class modification
class NotificationService:
    def send(self, message, channel):
        if channel == "email":
            # ... email logic
            return f"Email sent: {message}"
        elif channel == "sms":
            # ... sms logic
            return f"SMS sent: {message}"
        # else if slack: add another branch (BAD)

# AFTER: OCP-friendly — extend via new classes, never modify existing
from abc import ABC, abstractmethod

class NotificationChannel(ABC):
    @abstractmethod
    def send(self, message: str) -> str:
        pass

class EmailChannel(NotificationChannel):
    def send(self, message: str) -> str:
        return f"Email sent: {message}"

class SMSChannel(NotificationChannel):
    def send(self, message: str) -> str:
        return f"SMS sent: {message}"

# Adding Slack? New class, no changes to existing code
class SlackChannel(NotificationChannel):
    def send(self, message: str) -> str:
        return f"Slack message: {message}"

service = NotificationService()
# Oops, not needed — inject the channel instead
slack = SlackChannel()
print(slack.send("deploy complete"))

// io.thecodeforge — cs-fundamentals tutorial
// Over-applied SOLID: too many interfaces, too much indirection
class Logger(Protocol): pass
class FileLogger(Logger): pass
class CloudLogger(Logger): pass
class LoggerFactory: pass
class LoggerDecorator: pass
# Sometimes a simple function suffices:
def log(msg: str) -> None:
    print(f"{msg}")
✓ Keep it simple until abstraction pays off.