[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":91,"_72":92,"_35":93},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":16,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71},"id",22,"title","Breaking Dependencies","slug","clean-code-part-21-breaking-dependencies","excerpt","Identify and break tangled dependencies in legacy code to enable testing and incremental improvement without full rewrites.","# Advanced Clean Code Patterns Part 21: Breaking Dependencies\n\nLegacy code often has tangled dependencies that make testing and modification difficult. This article covers techniques to identify and break these dependencies safely, enabling incremental improvement.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Goal | Make code testable by isolating dependencies |\n| Key Technique | Extract and inject dependencies |\n| Safety Net | Characterization tests before changes |\n| Outcome | Testable code, easier modifications |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Identifying problematic dependencies** (static, global, hidden)\n- **Dependency breaking techniques** (extract, parameterize, wrap)\n- **Safe refactoring order** for untested code\n- **Dealing with singletons** and global state\n- **Interface extraction** for seams\n\n---\n\n## Production Story: The Untestable Monster\n\nA 2000-line service class was impossible to test:\n\n```java\n// ❌ The untestable monster\npublic class OrderProcessor {\n\n public void processOrder(long orderId) {\n // Hidden dependency #1: Database via singleton\n Order order = Database.getInstance().findOrder(orderId);\n\n // Hidden dependency #2: Static utility\n if (!OrderValidator.isValid(order)) {\n throw new InvalidOrderException();\n }\n\n // Hidden dependency #3: Another singleton\n InventoryService.getInstance().reserve(order.getItems());\n\n // Hidden dependency #4: Direct instantiation\n PaymentGateway gateway = new StripePaymentGateway();\n gateway.charge(order.getTotal());\n\n // Hidden dependency #5: Global state\n GlobalConfig config = GlobalConfig.get();\n if (config.isEmailEnabled()) {\n // Hidden dependency #6: Static call\n EmailSender.send(order.getEmail(), \"Order confirmed\");\n }\n }\n}\n```\n\n**Problems:**\n- Can't test without real database\n- Can't test without real Stripe\n- Can't disable emails in tests\n- Can't verify what was sent/saved\n\n---\n\n## Mental Model: Dependency Breaking\n\n```text\n┌─────────────────────────────────────────────────────────────────┐\n│ DEPENDENCY BREAKING WORKFLOW │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ 1. IDENTIFY │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ • Singletons (getInstance, static state) │ │\n│ │ • Static method calls │ │\n│ │ • Direct instantiation (new ConcreteClass()) │ │\n│ │ • Global configuration │ │\n│ │ • Environment/system calls │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ ↓ │\n│ 2. EXTRACT │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ • Extract interface for dependency │ │\n│ │ • Extract factory method for instantiation │ │\n│ │ • Wrap static calls in instance method │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ ↓ │\n│ 3. INJECT │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ • Add constructor parameter │ │\n│ │ • Add setter (if constructor not possible) │ │\n│ │ • Keep default for backward compatibility │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ ↓ │\n│ 4. TEST │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ • Inject mock in tests │ │\n│ │ • Production uses real implementation │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Technique 1: Extract and Override Factory Method\n\n```java\n// Before: Direct instantiation\npublic class OrderProcessor {\n public void process(Order order) {\n PaymentGateway gateway = new StripePaymentGateway(); // Can't mock!\n gateway.charge(order.getTotal());\n }\n}\n\n// After: Extract factory method\npublic class OrderProcessor {\n public void process(Order order) {\n PaymentGateway gateway = createPaymentGateway(); // Now overridable\n gateway.charge(order.getTotal());\n }\n\n protected PaymentGateway createPaymentGateway() {\n return new StripePaymentGateway(); // Default behavior preserved\n }\n}\n\n// Test with override\npublic class TestableOrderProcessor extends OrderProcessor {\n private final PaymentGateway mockGateway;\n\n public TestableOrderProcessor(PaymentGateway mockGateway) {\n this.mockGateway = mockGateway;\n }\n\n @Override\n protected PaymentGateway createPaymentGateway() {\n return mockGateway;\n }\n}\n\n// Usage in test\n@Test\nvoid process_chargesCorrectAmount() {\n PaymentGateway mockGateway = mock(PaymentGateway.class);\n OrderProcessor processor = new TestableOrderProcessor(mockGateway);\n\n processor.process(orderWith(100.0));\n\n verify(mockGateway).charge(new BigDecimal(\"100.00\"));\n}\n```\n\n---\n\n### Technique 2: Parameterize Constructor\n\n```java\n// Before: Hidden singleton dependency\npublic class OrderService {\n public Order findOrder(long id) {\n return Database.getInstance().findOrder(id); // Singleton!\n }\n}\n\n// Step 1: Add constructor parameter with default\npublic class OrderService {\n private final OrderRepository repository;\n\n // New constructor for DI\n public OrderService(OrderRepository repository) {\n this.repository = repository;\n }\n\n // Default constructor preserves backward compatibility\n public OrderService() {\n this(new DatabaseOrderRepository()); // Wraps singleton\n }\n\n public Order findOrder(long id) {\n return repository.findOrder(id); // Use injected dependency\n }\n}\n\n// Step 2: Create wrapper for singleton\npublic class DatabaseOrderRepository implements OrderRepository {\n @Override\n public Order findOrder(long id) {\n return Database.getInstance().findOrder(id);\n }\n}\n\n// Step 3: Test with mock\n@Test\nvoid findOrder_delegatesToRepository() {\n OrderRepository mockRepo = mock(OrderRepository.class);\n OrderService service = new OrderService(mockRepo);\n when(mockRepo.findOrder(1L)).thenReturn(testOrder);\n\n Order result = service.findOrder(1L);\n\n assertEquals(testOrder, result);\n}\n```\n\n---\n\n### Technique 3: Wrap Static Calls\n\n```java\n// Before: Static utility call\npublic class ReportGenerator {\n public Report generate(ReportRequest request) {\n // Static call - can't mock!\n String timestamp = DateUtils.formatTimestamp(LocalDateTime.now());\n // ...\n }\n}\n\n// After: Wrap in instance method\npublic class ReportGenerator {\n public Report generate(ReportRequest request) {\n String timestamp = formatTimestamp(LocalDateTime.now()); // Overridable\n // ...\n }\n\n protected String formatTimestamp(LocalDateTime dateTime) {\n return DateUtils.formatTimestamp(dateTime); // Wraps static call\n }\n}\n\n// Or better: Extract to injectable service\npublic class ReportGenerator {\n private final Clock clock;\n private final DateFormatter formatter;\n\n public ReportGenerator(Clock clock, DateFormatter formatter) {\n this.clock = clock;\n this.formatter = formatter;\n }\n\n public Report generate(ReportRequest request) {\n String timestamp = formatter.format(clock.now());\n // ...\n }\n}\n\n// Test with controlled clock\n@Test\nvoid generate_usesCurrentTimestamp() {\n Clock fixedClock = Clock.fixed(Instant.parse(\"2024-01-15T10:00:00Z\"), ZoneId.UTC);\n ReportGenerator generator = new ReportGenerator(fixedClock, new DateFormatter());\n\n Report report = generator.generate(request);\n\n assertTrue(report.getHeader().contains(\"2024-01-15\"));\n}\n```\n\n---\n\n### Technique 4: Break Singleton Dependencies\n\n```java\n// Before: Singleton everywhere\npublic class OrderProcessor {\n public void process(Order order) {\n Config config = Config.getInstance();\n Database db = Database.getInstance();\n EmailService email = EmailService.getInstance();\n // ...\n }\n}\n\n// Step 1: Introduce interfaces\npublic interface ConfigProvider {\n String get(String key);\n boolean isEnabled(String feature);\n}\n\npublic interface OrderRepository {\n Order findById(long id);\n void save(Order order);\n}\n\npublic interface NotificationService {\n void sendOrderConfirmation(Order order);\n}\n\n// Step 2: Create adapter implementations\npublic class SingletonConfigAdapter implements ConfigProvider {\n @Override\n public String get(String key) {\n return Config.getInstance().get(key);\n }\n\n @Override\n public boolean isEnabled(String feature) {\n return Config.getInstance().isEnabled(feature);\n }\n}\n\n// Step 3: Inject dependencies\npublic class OrderProcessor {\n private final ConfigProvider config;\n private final OrderRepository repository;\n private final NotificationService notifications;\n\n // Constructor injection\n public OrderProcessor(ConfigProvider config,\n OrderRepository repository,\n NotificationService notifications) {\n this.config = config;\n this.repository = repository;\n this.notifications = notifications;\n }\n\n // Backward-compatible default constructor\n public OrderProcessor() {\n this(new SingletonConfigAdapter(),\n new SingletonDatabaseAdapter(),\n new SingletonEmailAdapter());\n }\n\n public void process(Order order) {\n if (config.isEnabled(\"fraud_check\")) {\n // ...\n }\n repository.save(order);\n notifications.sendOrderConfirmation(order);\n }\n}\n```\n\n---\n\n### Technique 5: Extract Interface\n\n```java\n// Before: Concrete dependency\npublic class PaymentService {\n public void processPayment(Order order) {\n StripeGateway stripe = new StripeGateway(apiKey);\n stripe.charge(order.getTotal(), order.getCardToken());\n }\n}\n\n// Step 1: Extract interface from concrete class\npublic interface PaymentGateway {\n void charge(BigDecimal amount, String token);\n void refund(String transactionId, BigDecimal amount);\n}\n\npublic class StripeGateway implements PaymentGateway {\n // Existing implementation unchanged\n}\n\n// Step 2: Inject interface\npublic class PaymentService {\n private final PaymentGateway gateway;\n\n public PaymentService(PaymentGateway gateway) {\n this.gateway = gateway;\n }\n\n public void processPayment(Order order) {\n gateway.charge(order.getTotal(), order.getCardToken());\n }\n}\n\n// Step 3: Create test double\npublic class FakePaymentGateway implements PaymentGateway {\n private final List charges = new ArrayList<>();\n\n @Override\n public void charge(BigDecimal amount, String token) {\n charges.add(new ChargeRecord(amount, token));\n }\n\n @Override\n public void refund(String transactionId, BigDecimal amount) {\n // Track refunds\n }\n\n // Test helpers\n public List getCharges() {\n return List.copyOf(charges);\n }\n}\n\n// Test\n@Test\nvoid processPayment_chargesCorrectAmount() {\n FakePaymentGateway fakeGateway = new FakePaymentGateway();\n PaymentService service = new PaymentService(fakeGateway);\n\n service.processPayment(orderWith(150.00));\n\n assertEquals(1, fakeGateway.getCharges().size());\n assertEquals(new BigDecimal(\"150.00\"), fakeGateway.getCharges().get(0).amount());\n}\n```\n\n---\n\n### Technique 6: Adapt Parameter\n\n```java\n// Before: Method depends on complex parameter\npublic class ReportService {\n public Report generate(HttpServletRequest request) {\n String userId = request.getParameter(\"userId\");\n String startDate = request.getParameter(\"startDate\");\n String endDate = request.getParameter(\"endDate\");\n // ... uses request throughout\n }\n}\n\n// After: Extract what you need into simple type\npublic class ReportService {\n\n // New method with simple parameters\n public Report generate(ReportRequest params) {\n String userId = params.getUserId();\n String startDate = params.getStartDate();\n String endDate = params.getEndDate();\n // ...\n }\n\n // Adapter for backward compatibility\n public Report generate(HttpServletRequest request) {\n return generate(ReportRequest.fromHttpRequest(request));\n }\n}\n\npublic record ReportRequest(String userId, String startDate, String endDate) {\n public static ReportRequest fromHttpRequest(HttpServletRequest request) {\n return new ReportRequest(\n request.getParameter(\"userId\"),\n request.getParameter(\"startDate\"),\n request.getParameter(\"endDate\")\n );\n }\n}\n\n// Test without HTTP\n@Test\nvoid generate_createsReportForDateRange() {\n ReportRequest request = new ReportRequest(\"user123\", \"2024-01-01\", \"2024-01-31\");\n\n Report report = service.generate(request);\n\n assertEquals(\"user123\", report.getUserId());\n}\n```\n\n---\n\n### Technique 7: Preserve Signatures\n\n```java\n// Safe refactoring: preserve all existing method signatures\n\n// Original\npublic class OrderService {\n public void createOrder(Map orderData) {\n // 200 lines of code\n }\n}\n\n// Step 1: Extract new method, delegate from old\npublic class OrderService {\n\n // Original signature preserved - existing callers unaffected\n public void createOrder(Map orderData) {\n CreateOrderRequest request = mapToRequest(orderData);\n createOrder(request); // Delegate to new method\n }\n\n // New, testable method\n public void createOrder(CreateOrderRequest request) {\n // New implementation\n }\n\n private CreateOrderRequest mapToRequest(Map data) {\n return new CreateOrderRequest(\n (String) data.get(\"customerId\"),\n (List) data.get(\"items\")\n );\n }\n}\n\n// Both calling patterns work:\n// Old code: service.createOrder(map);\n// New code: service.createOrder(new CreateOrderRequest(...));\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Breaking Too Many Dependencies at Once\n\n```text\n❌ \"Let me refactor all 10 dependencies in this class\"\n - High risk of introducing bugs\n - Hard to identify source of problems\n - Tests don't tell you which change broke things\n\n✅ One dependency at a time\n - Break one dependency\n - Add tests\n - Verify behavior preserved\n - Commit\n - Repeat\n```\n\n### Mistake 2: Forgetting Backward Compatibility\n\n```java\n// ❌ Removed default constructor - breaks existing code\npublic class OrderService {\n public OrderService(OrderRepository repo) { // Only constructor\n this.repo = repo;\n }\n}\n\n// ✅ Preserve backward compatibility\npublic class OrderService {\n public OrderService(OrderRepository repo) {\n this.repo = repo;\n }\n\n public OrderService() { // Default for existing callers\n this(new DefaultOrderRepository());\n }\n}\n```\n\n---\n\n## 🐛 Debug This: The Invisible Seam\n\nA developer refactored legacy code to break dependencies, but the tests still can't mock the dependency. \"I extracted a factory method like the book says, but I still can't override it in tests!\"\n\n```java\n// The \"refactored\" code\npublic class NotificationService {\n\n public void notifyCustomer(Order order) {\n EmailClient client = createEmailClient(); // Factory method!\n\n String subject = \"Order #\" + order.getId() + \" Confirmed\";\n String body = buildEmailBody(order);\n\n client.send(order.getCustomerEmail(), subject, body);\n\n // Also send SMS for express orders\n if (order.isExpress()) {\n SmsClient sms = createSmsClient(); // Another factory method!\n sms.send(order.getCustomerPhone(), \"Express order confirmed!\");\n }\n }\n\n private EmailClient createEmailClient() {\n return new SmtpEmailClient(\n Config.get(\"smtp.host\"),\n Config.get(\"smtp.port\")\n );\n }\n\n private SmsClient createSmsClient() {\n return new TwilioSmsClient(\n Config.get(\"twilio.sid\"),\n Config.get(\"twilio.token\")\n );\n }\n\n private String buildEmailBody(Order order) {\n // ... build email content\n return \"Your order is confirmed\";\n }\n}\n\n// The test attempt\npublic class NotificationServiceTest {\n\n @Test\n void notifyCustomer_sendsEmail() {\n // How to mock createEmailClient()? Can't override it!\n NotificationService service = new NotificationService();\n\n Order order = createTestOrder();\n service.notifyCustomer(order); // This sends real email!\n\n // Can't verify anything...\n }\n}\n```\n\n**The factory methods were extracted, but the tests still can't mock them. What went wrong?**\n\n---\n\n**✅ Solution:**\n\nTwo critical mistakes:\n\n**Problem 1: Factory methods are `private`**\n\n```java\nprivate EmailClient createEmailClient() { // PRIVATE - can't override!\n```\n\nPrivate methods cannot be overridden by subclasses. The factory method pattern only works if the method can be overridden in a test subclass.\n\n**Problem 2: Config is still a hidden dependency**\n\n```java\nConfig.get(\"smtp.host\") // Static call inside factory - still hard to test!\n```\n\nEven if you could override the factory method, the Config singleton is still called.\n\n**Correct implementation:**\n\n```java\npublic class NotificationService {\n\n private final EmailClient emailClient;\n private final SmsClient smsClient;\n\n // Constructor injection - best approach\n public NotificationService(EmailClient emailClient, SmsClient smsClient) {\n this.emailClient = emailClient;\n this.smsClient = smsClient;\n }\n\n // Default constructor for backward compatibility\n public NotificationService() {\n this(createDefaultEmailClient(), createDefaultSmsClient());\n }\n\n public void notifyCustomer(Order order) {\n String subject = \"Order #\" + order.getId() + \" Confirmed\";\n String body = buildEmailBody(order);\n\n emailClient.send(order.getCustomerEmail(), subject, body);\n\n if (order.isExpress()) {\n smsClient.send(order.getCustomerPhone(), \"Express order confirmed!\");\n }\n }\n\n // Factory methods for default constructor only\n private static EmailClient createDefaultEmailClient() {\n return new SmtpEmailClient(\n Config.get(\"smtp.host\"),\n Config.get(\"smtp.port\")\n );\n }\n\n private static SmsClient createDefaultSmsClient() {\n return new TwilioSmsClient(\n Config.get(\"twilio.sid\"),\n Config.get(\"twilio.token\")\n );\n }\n}\n\n// Alternative: Use protected factory methods (subclass seam)\npublic class NotificationService {\n\n public void notifyCustomer(Order order) {\n EmailClient client = createEmailClient(); // Can override!\n // ...\n }\n\n protected EmailClient createEmailClient() { // PROTECTED!\n return new SmtpEmailClient(Config.get(\"smtp.host\"), Config.get(\"smtp.port\"));\n }\n\n protected SmsClient createSmsClient() { // PROTECTED!\n return new TwilioSmsClient(Config.get(\"twilio.sid\"), Config.get(\"twilio.token\"));\n }\n}\n\n// Test with override\nclass TestableNotificationService extends NotificationService {\n private final EmailClient mockEmail;\n private final SmsClient mockSms;\n\n TestableNotificationService(EmailClient mockEmail, SmsClient mockSms) {\n this.mockEmail = mockEmail;\n this.mockSms = mockSms;\n }\n\n @Override\n protected EmailClient createEmailClient() {\n return mockEmail; // Return mock!\n }\n\n @Override\n protected SmsClient createSmsClient() {\n return mockSms; // Return mock!\n }\n}\n```\n\n**The lesson:** Factory methods must be `protected` (not `private`) to enable the subclass seam pattern. Better yet, use constructor injection with a default constructor for backward compatibility.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Extract Factory Method\n⭐ Difficulty: Easy | ⏱️ Time: 10 minutes\n\n**Task:** Extract a factory method to make this class testable.\n\n```java\npublic class ReportExporter {\n public void export(Report report, String format) {\n if (\"pdf\".equals(format)) {\n PdfWriter writer = new PdfWriter(\"/tmp/report.pdf\"); // Direct instantiation!\n writer.write(report.getContent());\n writer.close();\n } else if (\"excel\".equals(format)) {\n ExcelWriter writer = new ExcelWriter(\"/tmp/report.xlsx\"); // Direct instantiation!\n writer.write(report.getData());\n writer.close();\n }\n }\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class ReportExporter {\n\n public void export(Report report, String format) {\n if (\"pdf\".equals(format)) {\n try (PdfWriter writer = createPdfWriter(\"/tmp/report.pdf\")) {\n writer.write(report.getContent());\n }\n } else if (\"excel\".equals(format)) {\n try (ExcelWriter writer = createExcelWriter(\"/tmp/report.xlsx\")) {\n writer.write(report.getData());\n }\n }\n }\n\n protected PdfWriter createPdfWriter(String path) {\n return new PdfWriter(path);\n }\n\n protected ExcelWriter createExcelWriter(String path) {\n return new ExcelWriter(path);\n }\n}\n\n// Test subclass\nclass TestableReportExporter extends ReportExporter {\n PdfWriter lastPdfWriter;\n ExcelWriter lastExcelWriter;\n String lastPdfPath;\n String lastExcelPath;\n\n @Override\n protected PdfWriter createPdfWriter(String path) {\n lastPdfPath = path;\n lastPdfWriter = mock(PdfWriter.class);\n return lastPdfWriter;\n }\n\n @Override\n protected ExcelWriter createExcelWriter(String path) {\n lastExcelPath = path;\n lastExcelWriter = mock(ExcelWriter.class);\n return lastExcelWriter;\n }\n}\n\n// Test\n@Test\nvoid export_pdf_writesPdfContent() {\n TestableReportExporter exporter = new TestableReportExporter();\n Report report = new Report(\"Test content\", List.of());\n\n exporter.export(report, \"pdf\");\n\n verify(exporter.lastPdfWriter).write(\"Test content\");\n assertEquals(\"/tmp/report.pdf\", exporter.lastPdfPath);\n}\n```\n\n---\n\n### Exercise 2: Parameterize Constructor\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Break the singleton dependency using constructor parameterization while maintaining backward compatibility.\n\n```java\npublic class InventoryChecker {\n public boolean isAvailable(String productId, int quantity) {\n // Singleton dependency!\n InventoryDatabase db = InventoryDatabase.getInstance();\n int available = db.getQuantity(productId);\n return available >= quantity;\n }\n\n public void reserve(String productId, int quantity) {\n // Same singleton!\n InventoryDatabase db = InventoryDatabase.getInstance();\n db.decrementQuantity(productId, quantity);\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Step 1: Define interface\npublic interface InventoryRepository {\n int getQuantity(String productId);\n void decrementQuantity(String productId, int amount);\n}\n\n// Step 2: Create adapter for singleton\npublic class SingletonInventoryAdapter implements InventoryRepository {\n @Override\n public int getQuantity(String productId) {\n return InventoryDatabase.getInstance().getQuantity(productId);\n }\n\n @Override\n public void decrementQuantity(String productId, int amount) {\n InventoryDatabase.getInstance().decrementQuantity(productId, amount);\n }\n}\n\n// Step 3: Parameterize constructor\npublic class InventoryChecker {\n private final InventoryRepository repository;\n\n // New constructor for DI\n public InventoryChecker(InventoryRepository repository) {\n this.repository = repository;\n }\n\n // Default constructor for backward compatibility\n public InventoryChecker() {\n this(new SingletonInventoryAdapter());\n }\n\n public boolean isAvailable(String productId, int quantity) {\n int available = repository.getQuantity(productId);\n return available >= quantity;\n }\n\n public void reserve(String productId, int quantity) {\n repository.decrementQuantity(productId, quantity);\n }\n}\n\n// Test with mock\n@Test\nvoid isAvailable_returnsTrueWhenSufficientStock() {\n InventoryRepository mockRepo = mock(InventoryRepository.class);\n when(mockRepo.getQuantity(\"PROD-1\")).thenReturn(10);\n\n InventoryChecker checker = new InventoryChecker(mockRepo);\n\n assertTrue(checker.isAvailable(\"PROD-1\", 5));\n assertFalse(checker.isAvailable(\"PROD-1\", 15));\n}\n\n@Test\nvoid reserve_decrementsInventory() {\n InventoryRepository mockRepo = mock(InventoryRepository.class);\n InventoryChecker checker = new InventoryChecker(mockRepo);\n\n checker.reserve(\"PROD-1\", 3);\n\n verify(mockRepo).decrementQuantity(\"PROD-1\", 3);\n}\n```\n\n---\n\n### Exercise 3: Wrap Static Calls\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Make this class testable by wrapping the static calls.\n\n```java\npublic class AuditLogger {\n public void logAction(String userId, String action) {\n // Static calls everywhere!\n String timestamp = DateUtils.formatNow();\n String hostname = SystemInfo.getHostname();\n String environment = Environment.current();\n\n String logEntry = String.format(\"[%s] [%s] [%s] User %s: %s\",\n timestamp, hostname, environment, userId, action);\n\n FileUtils.appendToFile(\"/var/log/audit.log\", logEntry);\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Option 1: Wrap in protected methods\npublic class AuditLogger {\n\n public void logAction(String userId, String action) {\n String timestamp = getCurrentTimestamp();\n String hostname = getHostname();\n String environment = getEnvironment();\n\n String logEntry = String.format(\"[%s] [%s] [%s] User %s: %s\",\n timestamp, hostname, environment, userId, action);\n\n writeToLog(logEntry);\n }\n\n protected String getCurrentTimestamp() {\n return DateUtils.formatNow();\n }\n\n protected String getHostname() {\n return SystemInfo.getHostname();\n }\n\n protected String getEnvironment() {\n return Environment.current();\n }\n\n protected void writeToLog(String entry) {\n FileUtils.appendToFile(\"/var/log/audit.log\", entry);\n }\n}\n\n// Option 2: Extract to injectable dependencies (better)\npublic class AuditLogger {\n private final Clock clock;\n private final SystemInfoProvider systemInfo;\n private final LogWriter logWriter;\n\n public AuditLogger(Clock clock, SystemInfoProvider systemInfo, LogWriter logWriter) {\n this.clock = clock;\n this.systemInfo = systemInfo;\n this.logWriter = logWriter;\n }\n\n public AuditLogger() {\n this(new SystemClock(), new DefaultSystemInfo(), new FileLogWriter());\n }\n\n public void logAction(String userId, String action) {\n String timestamp = clock.formatNow();\n String hostname = systemInfo.getHostname();\n String environment = systemInfo.getEnvironment();\n\n String logEntry = String.format(\"[%s] [%s] [%s] User %s: %s\",\n timestamp, hostname, environment, userId, action);\n\n logWriter.write(logEntry);\n }\n}\n\n// Test with mocks\n@Test\nvoid logAction_formatsCorrectly() {\n Clock fixedClock = mock(Clock.class);\n when(fixedClock.formatNow()).thenReturn(\"2024-01-15 10:00:00\");\n\n SystemInfoProvider mockSystemInfo = mock(SystemInfoProvider.class);\n when(mockSystemInfo.getHostname()).thenReturn(\"server-1\");\n when(mockSystemInfo.getEnvironment()).thenReturn(\"prod\");\n\n LogWriter mockWriter = mock(LogWriter.class);\n\n AuditLogger logger = new AuditLogger(fixedClock, mockSystemInfo, mockWriter);\n\n logger.logAction(\"user123\", \"LOGIN\");\n\n verify(mockWriter).write(\"[2024-01-15 10:00:00] [server-1] [prod] User user123: LOGIN\");\n}\n```\n\n---\n\n### Exercise 4: Extract Interface\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Extract an interface from this concrete class and refactor the dependent code.\n\n```java\n// Concrete class with many methods\npublic class StripePaymentProcessor {\n private final String apiKey;\n\n public StripePaymentProcessor(String apiKey) {\n this.apiKey = apiKey;\n }\n\n public String charge(BigDecimal amount, String cardToken) {\n // Stripe API call\n return \"ch_\" + UUID.randomUUID().toString();\n }\n\n public void refund(String chargeId, BigDecimal amount) {\n // Stripe API call for refund\n }\n\n public String createCustomer(String email, String cardToken) {\n // Create Stripe customer\n return \"cus_\" + UUID.randomUUID().toString();\n }\n\n public boolean validateCard(String cardToken) {\n // Validate card with Stripe\n return true;\n }\n}\n\n// Dependent class\npublic class CheckoutService {\n public OrderResult checkout(Cart cart, String cardToken) {\n StripePaymentProcessor processor = new StripePaymentProcessor(API_KEY);\n\n if (!processor.validateCard(cardToken)) {\n return OrderResult.failed(\"Invalid card\");\n }\n\n String chargeId = processor.charge(cart.getTotal(), cardToken);\n return OrderResult.success(chargeId);\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Step 1: Extract interface (only methods needed by CheckoutService)\npublic interface PaymentProcessor {\n String charge(BigDecimal amount, String cardToken);\n boolean validateCard(String cardToken);\n}\n\n// Step 2: Implement interface in concrete class\npublic class StripePaymentProcessor implements PaymentProcessor {\n private final String apiKey;\n\n public StripePaymentProcessor(String apiKey) {\n this.apiKey = apiKey;\n }\n\n @Override\n public String charge(BigDecimal amount, String cardToken) {\n // Stripe API call\n return \"ch_\" + UUID.randomUUID().toString();\n }\n\n @Override\n public boolean validateCard(String cardToken) {\n // Validate card with Stripe\n return true;\n }\n\n // Additional methods not in interface (still available)\n public void refund(String chargeId, BigDecimal amount) {\n // Stripe API call for refund\n }\n\n public String createCustomer(String email, String cardToken) {\n return \"cus_\" + UUID.randomUUID().toString();\n }\n}\n\n// Step 3: Inject interface in dependent class\npublic class CheckoutService {\n private final PaymentProcessor paymentProcessor;\n\n public CheckoutService(PaymentProcessor paymentProcessor) {\n this.paymentProcessor = paymentProcessor;\n }\n\n // Backward compatible constructor\n public CheckoutService() {\n this(new StripePaymentProcessor(System.getenv(\"STRIPE_API_KEY\")));\n }\n\n public OrderResult checkout(Cart cart, String cardToken) {\n if (!paymentProcessor.validateCard(cardToken)) {\n return OrderResult.failed(\"Invalid card\");\n }\n\n String chargeId = paymentProcessor.charge(cart.getTotal(), cardToken);\n return OrderResult.success(chargeId);\n }\n}\n\n// Step 4: Create test implementation\npublic class FakePaymentProcessor implements PaymentProcessor {\n private boolean cardValid = true;\n private String chargeResult = \"ch_test123\";\n private List charges = new ArrayList<>();\n\n @Override\n public String charge(BigDecimal amount, String cardToken) {\n charges.add(new ChargeRecord(amount, cardToken, chargeResult));\n return chargeResult;\n }\n\n @Override\n public boolean validateCard(String cardToken) {\n return cardValid;\n }\n\n // Test configuration methods\n public void setCardValid(boolean valid) { this.cardValid = valid; }\n public void setChargeResult(String result) { this.chargeResult = result; }\n public List getCharges() { return List.copyOf(charges); }\n\n public record ChargeRecord(BigDecimal amount, String token, String chargeId) {}\n}\n\n// Tests\n@Test\nvoid checkout_validCard_chargesAndReturnsSuccess() {\n FakePaymentProcessor fakeProcessor = new FakePaymentProcessor();\n CheckoutService service = new CheckoutService(fakeProcessor);\n Cart cart = new Cart(new BigDecimal(\"99.99\"));\n\n OrderResult result = service.checkout(cart, \"tok_test\");\n\n assertTrue(result.isSuccess());\n assertEquals(\"ch_test123\", result.getChargeId());\n assertEquals(1, fakeProcessor.getCharges().size());\n assertEquals(new BigDecimal(\"99.99\"), fakeProcessor.getCharges().get(0).amount());\n}\n\n@Test\nvoid checkout_invalidCard_failsWithoutCharging() {\n FakePaymentProcessor fakeProcessor = new FakePaymentProcessor();\n fakeProcessor.setCardValid(false);\n CheckoutService service = new CheckoutService(fakeProcessor);\n\n OrderResult result = service.checkout(new Cart(new BigDecimal(\"99.99\")), \"tok_invalid\");\n\n assertFalse(result.isSuccess());\n assertEquals(\"Invalid card\", result.getMessage());\n assertTrue(fakeProcessor.getCharges().isEmpty());\n}\n```\n\n---\n\n### Exercise 5: Full Dependency Breaking Workflow\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Apply the full dependency breaking workflow to make this legacy class fully testable.\n\n```java\npublic class OrderFulfillmentService {\n\n public FulfillmentResult fulfill(long orderId) {\n // Dependency 1: Singleton database\n Order order = OrderDatabase.getInstance().findById(orderId);\n if (order == null) {\n return FulfillmentResult.notFound();\n }\n\n // Dependency 2: Static validator\n if (!OrderValidator.isValid(order)) {\n return FulfillmentResult.invalid(\"Order validation failed\");\n }\n\n // Dependency 3: Direct instantiation\n WarehouseClient warehouse = new WarehouseClient(\"https://warehouse.api\");\n for (OrderItem item : order.getItems()) {\n warehouse.reserve(item.getSku(), item.getQuantity());\n }\n\n // Dependency 4: Another singleton\n ShippingService.getInstance().createLabel(order);\n\n // Dependency 5: Static utility\n order.setFulfilledAt(DateTimeUtils.now());\n OrderDatabase.getInstance().save(order);\n\n // Dependency 6: Static notification\n NotificationSender.sendFulfillmentEmail(order);\n\n return FulfillmentResult.success(order.getTrackingNumber());\n }\n}\n```\n\n**Break all dependencies and write comprehensive tests.**\n\n**✅ Solution:**\n\n```java\n// Step 1: Define interfaces for all dependencies\npublic interface OrderRepository {\n Order findById(long id);\n void save(Order order);\n}\n\npublic interface OrderValidationService {\n boolean isValid(Order order);\n}\n\npublic interface WarehouseService {\n void reserve(String sku, int quantity);\n}\n\npublic interface ShippingLabelService {\n void createLabel(Order order);\n}\n\npublic interface Clock {\n Instant now();\n}\n\npublic interface FulfillmentNotifier {\n void notifyFulfillment(Order order);\n}\n\n// Step 2: Create adapters for legacy implementations\npublic class SingletonOrderRepository implements OrderRepository {\n @Override\n public Order findById(long id) {\n return OrderDatabase.getInstance().findById(id);\n }\n\n @Override\n public void save(Order order) {\n OrderDatabase.getInstance().save(order);\n }\n}\n\npublic class StaticOrderValidator implements OrderValidationService {\n @Override\n public boolean isValid(Order order) {\n return OrderValidator.isValid(order);\n }\n}\n\npublic class HttpWarehouseService implements WarehouseService {\n private final WarehouseClient client;\n\n public HttpWarehouseService(String url) {\n this.client = new WarehouseClient(url);\n }\n\n @Override\n public void reserve(String sku, int quantity) {\n client.reserve(sku, quantity);\n }\n}\n\npublic class SingletonShippingService implements ShippingLabelService {\n @Override\n public void createLabel(Order order) {\n ShippingService.getInstance().createLabel(order);\n }\n}\n\npublic class SystemClock implements Clock {\n @Override\n public Instant now() {\n return Instant.now();\n }\n}\n\npublic class EmailFulfillmentNotifier implements FulfillmentNotifier {\n @Override\n public void notifyFulfillment(Order order) {\n NotificationSender.sendFulfillmentEmail(order);\n }\n}\n\n// Step 3: Refactor service with constructor injection\npublic class OrderFulfillmentService {\n private final OrderRepository orderRepository;\n private final OrderValidationService validator;\n private final WarehouseService warehouse;\n private final ShippingLabelService shipping;\n private final Clock clock;\n private final FulfillmentNotifier notifier;\n\n // Full constructor for DI\n public OrderFulfillmentService(\n OrderRepository orderRepository,\n OrderValidationService validator,\n WarehouseService warehouse,\n ShippingLabelService shipping,\n Clock clock,\n FulfillmentNotifier notifier) {\n this.orderRepository = orderRepository;\n this.validator = validator;\n this.warehouse = warehouse;\n this.shipping = shipping;\n this.clock = clock;\n this.notifier = notifier;\n }\n\n // Default constructor for backward compatibility\n public OrderFulfillmentService() {\n this(\n new SingletonOrderRepository(),\n new StaticOrderValidator(),\n new HttpWarehouseService(\"https://warehouse.api\"),\n new SingletonShippingService(),\n new SystemClock(),\n new EmailFulfillmentNotifier()\n );\n }\n\n public FulfillmentResult fulfill(long orderId) {\n Order order = orderRepository.findById(orderId);\n if (order == null) {\n return FulfillmentResult.notFound();\n }\n\n if (!validator.isValid(order)) {\n return FulfillmentResult.invalid(\"Order validation failed\");\n }\n\n for (OrderItem item : order.getItems()) {\n warehouse.reserve(item.getSku(), item.getQuantity());\n }\n\n shipping.createLabel(order);\n\n order.setFulfilledAt(clock.now());\n orderRepository.save(order);\n\n notifier.notifyFulfillment(order);\n\n return FulfillmentResult.success(order.getTrackingNumber());\n }\n}\n\n// Step 4: Comprehensive tests\npublic class OrderFulfillmentServiceTest {\n\n private OrderRepository mockRepo;\n private OrderValidationService mockValidator;\n private WarehouseService mockWarehouse;\n private ShippingLabelService mockShipping;\n private Clock fixedClock;\n private FulfillmentNotifier mockNotifier;\n private OrderFulfillmentService service;\n\n @BeforeEach\n void setup() {\n mockRepo = mock(OrderRepository.class);\n mockValidator = mock(OrderValidationService.class);\n mockWarehouse = mock(WarehouseService.class);\n mockShipping = mock(ShippingLabelService.class);\n fixedClock = () -> Instant.parse(\"2024-01-15T10:00:00Z\");\n mockNotifier = mock(FulfillmentNotifier.class);\n\n service = new OrderFulfillmentService(\n mockRepo, mockValidator, mockWarehouse,\n mockShipping, fixedClock, mockNotifier\n );\n\n // Default setup\n when(mockValidator.isValid(any())).thenReturn(true);\n }\n\n @Test\n void fulfill_orderNotFound_returnsNotFound() {\n when(mockRepo.findById(999L)).thenReturn(null);\n\n FulfillmentResult result = service.fulfill(999L);\n\n assertEquals(FulfillmentResult.notFound(), result);\n verifyNoInteractions(mockValidator, mockWarehouse, mockShipping, mockNotifier);\n }\n\n @Test\n void fulfill_invalidOrder_returnsInvalid() {\n Order order = createOrder(1L);\n when(mockRepo.findById(1L)).thenReturn(order);\n when(mockValidator.isValid(order)).thenReturn(false);\n\n FulfillmentResult result = service.fulfill(1L);\n\n assertEquals(FulfillmentResult.invalid(\"Order validation failed\"), result);\n verifyNoInteractions(mockWarehouse, mockShipping, mockNotifier);\n }\n\n @Test\n void fulfill_validOrder_reservesInventoryForAllItems() {\n Order order = createOrderWithItems(1L,\n new OrderItem(\"SKU-1\", 2),\n new OrderItem(\"SKU-2\", 5)\n );\n when(mockRepo.findById(1L)).thenReturn(order);\n\n service.fulfill(1L);\n\n verify(mockWarehouse).reserve(\"SKU-1\", 2);\n verify(mockWarehouse).reserve(\"SKU-2\", 5);\n }\n\n @Test\n void fulfill_validOrder_createsShippingLabel() {\n Order order = createOrder(1L);\n when(mockRepo.findById(1L)).thenReturn(order);\n\n service.fulfill(1L);\n\n verify(mockShipping).createLabel(order);\n }\n\n @Test\n void fulfill_validOrder_setsFulfilledAtTimestamp() {\n Order order = createOrder(1L);\n when(mockRepo.findById(1L)).thenReturn(order);\n\n service.fulfill(1L);\n\n assertEquals(Instant.parse(\"2024-01-15T10:00:00Z\"), order.getFulfilledAt());\n verify(mockRepo).save(order);\n }\n\n @Test\n void fulfill_validOrder_sendsNotification() {\n Order order = createOrder(1L);\n when(mockRepo.findById(1L)).thenReturn(order);\n\n service.fulfill(1L);\n\n verify(mockNotifier).notifyFulfillment(order);\n }\n\n @Test\n void fulfill_validOrder_returnsSuccessWithTrackingNumber() {\n Order order = createOrder(1L);\n order.setTrackingNumber(\"TRACK-123\");\n when(mockRepo.findById(1L)).thenReturn(order);\n\n FulfillmentResult result = service.fulfill(1L);\n\n assertTrue(result.isSuccess());\n assertEquals(\"TRACK-123\", result.getTrackingNumber());\n }\n\n @Test\n void fulfill_executesInCorrectOrder() {\n Order order = createOrder(1L);\n when(mockRepo.findById(1L)).thenReturn(order);\n\n service.fulfill(1L);\n\n InOrder inOrder = inOrder(mockValidator, mockWarehouse, mockShipping, mockRepo, mockNotifier);\n inOrder.verify(mockValidator).isValid(order);\n inOrder.verify(mockWarehouse).reserve(anyString(), anyInt());\n inOrder.verify(mockShipping).createLabel(order);\n inOrder.verify(mockRepo).save(order);\n inOrder.verify(mockNotifier).notifyFulfillment(order);\n }\n\n private Order createOrder(long id) {\n return createOrderWithItems(id, new OrderItem(\"SKU-DEFAULT\", 1));\n }\n\n private Order createOrderWithItems(long id, OrderItem... items) {\n Order order = new Order();\n order.setId(id);\n order.setItems(Arrays.asList(items));\n order.setTrackingNumber(\"TRACK-\" + id);\n return order;\n }\n}\n```\n\n---\n\n## 📝 Summary\n\n| Technique | Use When |\n|-----------|----------|\n| Extract Factory Method | Direct `new` in method |\n| Parameterize Constructor | Singleton/static dependencies |\n| Wrap Static Calls | Static utility methods |\n| Extract Interface | Need to mock concrete class |\n| Adapt Parameter | Complex parameters (HttpRequest) |\n| Preserve Signatures | Avoid breaking existing callers |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review Dependency Breaking Workflow diagram | 5 min |\n| Day 3 | Redo Exercise 1 (Extract Factory Method) | 10 min |\n| Day 7 | Identify 3 dependencies to break in your current codebase | 15 min |\n| Day 14 | Redo Debug This (The Invisible Seam) | 10 min |\n| Day 30 | Apply Parameterize Constructor to a real class | 20 min |\n\n---\n\n*Next: [Part 22: Strangler Fig Pattern]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.911262Z","createdAt","2026-06-10T07:19:24.912064Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",18,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",21,"author",{"_31":55,"_98":57,"_99":100,"_101":102,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5},"category",{"_31":94,"_72":59,"_35":95,"_75":96,"_97":-5},"tags",[78,79,80,81],"series",{"_31":16,"_72":73,"_35":74,"_75":76,"_77":23},"name","Advanced Clean Code Patterns: From Principles to Production Mastery","advanced-clean-code-patterns","description","A comprehensive 26-part series covering enterprise-grade clean code patterns for Java developers. From SOLID principles and code smells through refactoring patterns, error handling, validation, to legacy modernization and modern Java 21+ features. Includes real production stories, mental models, exercises, and 150+ interview questions.","isActive",{"_31":91,"_72":92,"_35":93},{"_31":88,"_72":89,"_35":90},{"_31":85,"_72":86,"_35":87},{"_31":82,"_72":83,"_35":84},97,"Test Doubles","test-doubles",96,"Seams","seams",95,"Dependency Breaking","dependency-breaking",98,"Decoupling","decoupling",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]