[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":88,"_72":89,"_35":90},"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",14,"title","Template Method Pattern","slug","clean-code-part-13-template-method","excerpt","Define algorithm skeletons with extension points using Template Method pattern, functional alternatives, and Spring template classes like JdbcTemplate.","# Advanced Clean Code Patterns Part 13: Template Method & Hooks\n\nTemplate Method defines the skeleton of an algorithm, letting subclasses override specific steps. Combined with hook methods, it provides powerful extension points while enforcing consistent structure. This article covers classic templates, functional alternatives, and Spring's template classes.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Pattern Type | Behavioral Design Pattern |\n| Primary Benefit | Algorithm skeleton reuse, consistent structure |\n| Hook Types | Required (abstract), Optional (default), Notification |\n| Spring Examples | JdbcTemplate, RestTemplate, TransactionTemplate |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Template Method Pattern** with abstract and hook methods\n- **Functional templates** with lambdas\n- **Spring templates** (JdbcTemplate, RestTemplate)\n- **Hook patterns** for extensibility\n- **When to use** vs composition alternatives\n\n---\n\n## Production Story: The Report Generator\n\nA reporting system had copy-pasted code across 15 report types:\n\n```java\n// ❌ Copy-paste duplication in every report\npublic class SalesReport {\n public void generate() {\n authenticate();\n log.info(\"Starting Sales Report\");\n List data = fetchSalesData(); // Only this differs!\n validate(data);\n format(data);\n log.info(\"Completed Sales Report\");\n sendNotification();\n }\n}\n\npublic class InventoryReport {\n public void generate() {\n authenticate();\n log.info(\"Starting Inventory Report\");\n List data = fetchInventoryData(); // Only this differs!\n validate(data);\n format(data);\n log.info(\"Completed Inventory Report\");\n sendNotification();\n }\n}\n// ... 13 more nearly identical classes\n```\n\n**Problems:**\n- Bug fixes needed in 15 places\n- Inconsistent error handling\n- New reports copy-pasted more bugs\n- Testing required 15 separate test suites\n\n**The fix:** Template Method:\n\n```java\n// ✅ Template Method extracts common structure\npublic abstract class ReportTemplate {\n\n // Template method - defines the skeleton\n public final void generate() {\n authenticate();\n logStart();\n List data = fetchData(); // Abstract - subclasses implement\n validate(data);\n format(data);\n postProcess(data); // Hook - optional override\n logComplete();\n sendNotification();\n }\n\n protected abstract List fetchData();\n protected void postProcess(List data) { } // Hook with default\n}\n\npublic class SalesReport extends ReportTemplate {\n @Override\n protected List fetchData() {\n return salesRepository.findByDateRange(startDate, endDate);\n }\n}\n```\n\n---\n\n## Mental Model: Template Method Structure\n\n```text\n┌─────────────────────────────────────────────────────────────────┐\n│ TEMPLATE METHOD STRUCTURE │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ AbstractClass │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ templateMethod() { // FINAL - skeleton │ │\n│ │ step1(); // Concrete - shared │ │\n│ │ step2(); // ABSTRACT - must override │ │\n│ │ step3(); // Hook - may override │ │\n│ │ step4(); // Concrete - shared │ │\n│ │ } │ │\n│ │ │ │\n│ │ step1() { /* shared implementation */ } │ │\n│ │ abstract step2(); // Subclass MUST implement │ │\n│ │ step3() { /* default, empty */ } // Hook - optional │ │\n│ │ step4() { /* shared implementation */ } │ │\n│ │ │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ ▲ │\n│ │ extends │\n│ ┌───────────────────────┴────────────────────────────────────┐ │\n│ │ │ │\n│ │ ConcreteClass │ │\n│ │ ┌────────────────────────────────────────────────────┐ │ │\n│ │ │ step2() { /* required implementation */ } │ │ │\n│ │ │ step3() { /* optional override */ } │ │ │\n│ │ └────────────────────────────────────────────────────┘ │ │\n│ │ │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Classic Template Method\n\n```java\n// ✅ Template Method for data processing\n\npublic abstract class DataProcessor {\n\n // Template method - final to prevent override of structure\n public final R process(T input) {\n validate(input);\n T prepared = prepare(input);\n R result = doProcess(prepared);\n R enriched = enrich(result);\n audit(input, enriched);\n return enriched;\n }\n\n // Concrete method - shared implementation\n protected void validate(T input) {\n Objects.requireNonNull(input, \"Input cannot be null\");\n }\n\n // Abstract methods - MUST be implemented\n protected abstract T prepare(T input);\n protected abstract R doProcess(T input);\n\n // Hook methods - CAN be overridden\n protected R enrich(R result) {\n return result; // Default: no enrichment\n }\n\n protected void audit(T input, R result) {\n // Default: no auditing\n }\n}\n\n// Concrete implementation\npublic class OrderProcessor extends DataProcessor {\n\n @Override\n protected RawOrder prepare(RawOrder input) {\n return input.withNormalizedAddresses();\n }\n\n @Override\n protected ProcessedOrder doProcess(RawOrder input) {\n return orderService.process(input);\n }\n\n @Override\n protected ProcessedOrder enrich(ProcessedOrder result) {\n // Override hook to add shipping info\n return result.withEstimatedDelivery(\n shippingService.calculateDelivery(result));\n }\n\n @Override\n protected void audit(RawOrder input, ProcessedOrder result) {\n // Override hook to enable auditing\n auditService.log(input.getId(), result.getStatus());\n }\n}\n```\n\n---\n\n### Pattern 2: Hook Types\n\n```java\n// ✅ Different types of hooks\n\npublic abstract class PaymentTemplate {\n\n public final PaymentResult processPayment(Payment payment) {\n // 1. Required hook - subclass MUST implement\n validatePayment(payment);\n\n // 2. Conditional hook - controls flow\n if (requiresVerification(payment)) {\n verify(payment);\n }\n\n // 3. Notification hook - for observation\n beforeProcess(payment);\n\n PaymentResult result = doProcess(payment);\n\n // 4. Transformation hook - modify result\n result = transformResult(result);\n\n // 5. Notification hook\n afterProcess(payment, result);\n\n return result;\n }\n\n // Required hooks (abstract)\n protected abstract void validatePayment(Payment payment);\n protected abstract PaymentResult doProcess(Payment payment);\n\n // Conditional hook - controls whether step runs\n protected boolean requiresVerification(Payment payment) {\n return payment.getAmount().compareTo(new BigDecimal(\"1000\")) > 0;\n }\n\n // Notification hooks - for observation/logging\n protected void beforeProcess(Payment payment) { }\n protected void afterProcess(Payment payment, PaymentResult result) { }\n\n // Transformation hook - can modify result\n protected PaymentResult transformResult(PaymentResult result) {\n return result;\n }\n\n // Internal hook for verification\n protected void verify(Payment payment) {\n // Default verification\n fraudService.check(payment);\n }\n}\n\n// Implementation with selective hook overrides\npublic class CreditCardPaymentProcessor extends PaymentTemplate {\n\n @Override\n protected void validatePayment(Payment payment) {\n if (payment.getCardNumber() == null) {\n throw new ValidationException(\"Card number required\");\n }\n }\n\n @Override\n protected PaymentResult doProcess(Payment payment) {\n return gateway.charge(payment);\n }\n\n @Override\n protected boolean requiresVerification(Payment payment) {\n // International cards always require verification\n return payment.isInternational() || super.requiresVerification(payment);\n }\n\n @Override\n protected void afterProcess(Payment payment, PaymentResult result) {\n // Add logging for credit card payments\n log.info(\"Credit card payment processed: {}\", result.getTransactionId());\n metrics.recordPayment(\"credit_card\", result.isSuccess());\n }\n}\n```\n\n---\n\n### Pattern 3: Functional Template (Lambda-Based)\n\n```java\n// ✅ Template with functional customization points\n\npublic class FunctionalTemplate {\n private final Consumer validator;\n private final Function preparer;\n private final Function processor;\n private final Function enricher;\n private final BiConsumer auditor;\n\n private FunctionalTemplate(Builder builder) {\n this.validator = builder.validator;\n this.preparer = builder.preparer;\n this.processor = builder.processor;\n this.enricher = builder.enricher;\n this.auditor = builder.auditor;\n }\n\n public O process(I input) {\n validator.accept(input);\n I prepared = preparer.apply(input);\n O result = processor.apply(prepared);\n O enriched = enricher.apply(result);\n auditor.accept(input, enriched);\n return enriched;\n }\n\n public static Builder builder() {\n return new Builder<>();\n }\n\n public static class Builder {\n private Consumer validator = i -> {};\n private Function preparer = Function.identity();\n private Function processor;\n private Function enricher = Function.identity();\n private BiConsumer auditor = (i, o) -> {};\n\n public Builder validator(Consumer validator) {\n this.validator = validator;\n return this;\n }\n\n public Builder preparer(Function preparer) {\n this.preparer = preparer;\n return this;\n }\n\n public Builder processor(Function processor) {\n this.processor = processor;\n return this;\n }\n\n public Builder enricher(Function enricher) {\n this.enricher = enricher;\n return this;\n }\n\n public Builder auditor(BiConsumer auditor) {\n this.auditor = auditor;\n return this;\n }\n\n public FunctionalTemplate build() {\n Objects.requireNonNull(processor, \"Processor required\");\n return new FunctionalTemplate<>(this);\n }\n }\n}\n\n// Usage - compose behavior without inheritance\nFunctionalTemplate orderTemplate = FunctionalTemplate.builder()\n .validator(order -> {\n if (order.getItems().isEmpty()) {\n throw new ValidationException(\"Order must have items\");\n }\n })\n .preparer(order -> order.withNormalizedData())\n .processor(order -> receiptService.generateReceipt(order))\n .enricher(receipt -> receipt.withTaxDetails(taxService.calculate(receipt)))\n .auditor((order, receipt) -> auditLog.record(order.getId(), receipt.getId()))\n .build();\n\nReceipt receipt = orderTemplate.process(order);\n```\n\n---\n\n### Pattern 4: Spring Template Classes\n\n```java\n// ✅ Using Spring's JdbcTemplate\n\n@Repository\npublic class OrderRepository {\n private final JdbcTemplate jdbcTemplate;\n\n public OrderRepository(JdbcTemplate jdbcTemplate) {\n this.jdbcTemplate = jdbcTemplate;\n }\n\n // JdbcTemplate handles: connection, statement, exception, cleanup\n // You only provide: SQL and mapping\n public List findByCustomerId(Long customerId) {\n return jdbcTemplate.query(\n \"SELECT * FROM orders WHERE customer_id = ?\",\n (rs, rowNum) -> new Order(\n rs.getLong(\"id\"),\n rs.getLong(\"customer_id\"),\n rs.getBigDecimal(\"total\"),\n rs.getTimestamp(\"created_at\").toLocalDateTime()\n ),\n customerId\n );\n }\n\n public Order findById(Long id) {\n return jdbcTemplate.queryForObject(\n \"SELECT * FROM orders WHERE id = ?\",\n (rs, rowNum) -> mapOrder(rs),\n id\n );\n }\n\n public void save(Order order) {\n jdbcTemplate.update(\n \"INSERT INTO orders (customer_id, total, created_at) VALUES (?, ?, ?)\",\n order.getCustomerId(),\n order.getTotal(),\n order.getCreatedAt()\n );\n }\n}\n\n// ✅ Using TransactionTemplate\n@Service\npublic class OrderService {\n private final TransactionTemplate transactionTemplate;\n private final OrderRepository orderRepository;\n private final InventoryService inventoryService;\n\n public Order createOrder(CreateOrderRequest request) {\n return transactionTemplate.execute(status -> {\n // All operations in one transaction\n Order order = orderRepository.save(new Order(request));\n inventoryService.reserve(order.getItems());\n paymentService.authorize(order);\n\n if (someCondition) {\n status.setRollbackOnly(); // Programmatic rollback\n }\n\n return order;\n });\n }\n}\n\n// ✅ Using RestTemplate (legacy) or WebClient\n@Service\npublic class ExternalApiService {\n private final RestTemplate restTemplate;\n\n public User fetchUser(Long id) {\n // RestTemplate handles: connection, serialization, error handling\n return restTemplate.getForObject(\n \"https://api.example.com/users/{id}\",\n User.class,\n id\n );\n }\n\n public User createUser(CreateUserRequest request) {\n return restTemplate.postForObject(\n \"https://api.example.com/users\",\n request,\n User.class\n );\n }\n}\n```\n\n---\n\n### Pattern 5: Custom Spring Template\n\n```java\n// ✅ Building your own template for repeated patterns\n\npublic class RetryTemplate {\n\n public T execute(RetryCallback callback, int maxAttempts) {\n Exception lastException = null;\n\n for (int attempt = 1; attempt <= maxAttempts; attempt++) {\n try {\n beforeAttempt(attempt);\n T result = callback.doWithRetry(attempt);\n onSuccess(attempt);\n return result;\n } catch (Exception e) {\n lastException = e;\n onError(attempt, e);\n\n if (attempt < maxAttempts) {\n waitBeforeRetry(attempt);\n }\n }\n }\n\n throw new RetryExhaustedException(\"All retries failed\", lastException);\n }\n\n // Hooks for customization\n protected void beforeAttempt(int attempt) {\n log.debug(\"Attempt {} starting\", attempt);\n }\n\n protected void onSuccess(int attempt) {\n log.debug(\"Attempt {} succeeded\", attempt);\n }\n\n protected void onError(int attempt, Exception e) {\n log.warn(\"Attempt {} failed: {}\", attempt, e.getMessage());\n }\n\n protected void waitBeforeRetry(int attempt) {\n try {\n long delay = calculateBackoff(attempt);\n Thread.sleep(delay);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n throw new RuntimeException(\"Retry interrupted\", e);\n }\n }\n\n protected long calculateBackoff(int attempt) {\n return (long) Math.pow(2, attempt) * 100; // Exponential backoff\n }\n}\n\n@FunctionalInterface\npublic interface RetryCallback {\n T doWithRetry(int attempt) throws Exception;\n}\n\n// Usage\nRetryTemplate retry = new RetryTemplate();\n\nString result = retry.execute(\n attempt -> externalService.fetchData(),\n 3\n);\n\n// Extended with custom backoff\npublic class CustomRetryTemplate extends RetryTemplate {\n @Override\n protected long calculateBackoff(int attempt) {\n return attempt * 1000; // Linear backoff\n }\n\n @Override\n protected void onError(int attempt, Exception e) {\n super.onError(attempt, e);\n metrics.incrementRetryCount();\n }\n}\n```\n\n---\n\n### Pattern 6: Template with Strategy\n\n```java\n// ✅ Combining Template Method with Strategy Pattern\n\npublic abstract class ExportTemplate {\n\n private final ExportFormatter formatter;\n\n protected ExportTemplate(ExportFormatter formatter) {\n this.formatter = formatter;\n }\n\n public final byte[] export(ExportRequest request) {\n // Template method\n List data = fetchData(request);\n List filtered = applyFilters(data, request.getFilters());\n List sorted = applySorting(filtered, request.getSortBy());\n\n // Delegate formatting to strategy\n return formatter.format(sorted);\n }\n\n protected abstract List fetchData(ExportRequest request);\n\n protected List applyFilters(List data, List filters) {\n // Default filtering implementation\n return data.stream()\n .filter(item -> filters.stream().allMatch(f -> f.matches(item)))\n .toList();\n }\n\n protected List applySorting(List data, String sortBy) {\n // Hook - can be overridden\n return data;\n }\n}\n\n// Strategy for formatting\npublic interface ExportFormatter {\n byte[] format(List data);\n}\n\npublic class CsvFormatter implements ExportFormatter {\n @Override\n public byte[] format(List data) { /* CSV formatting */ }\n}\n\npublic class ExcelFormatter implements ExportFormatter {\n @Override\n public byte[] format(List data) { /* Excel formatting */ }\n}\n\npublic class JsonFormatter implements ExportFormatter {\n @Override\n public byte[] format(List data) { /* JSON formatting */ }\n}\n\n// Concrete export\npublic class OrderExport extends ExportTemplate {\n\n public OrderExport(ExportFormatter formatter) {\n super(formatter);\n }\n\n @Override\n protected List fetchData(ExportRequest request) {\n return orderRepository.findByDateRange(\n request.getStartDate(),\n request.getEndDate()\n );\n }\n\n @Override\n protected List applySorting(List data, String sortBy) {\n return switch (sortBy) {\n case \"date\" -> data.stream()\n .sorted(Comparator.comparing(Order::getCreatedAt))\n .toList();\n case \"amount\" -> data.stream()\n .sorted(Comparator.comparing(Order::getTotal).reversed())\n .toList();\n default -> data;\n };\n }\n}\n\n// Usage\nOrderExport csvExport = new OrderExport(new CsvFormatter());\nOrderExport excelExport = new OrderExport(new ExcelFormatter());\n\nbyte[] csv = csvExport.export(request);\nbyte[] excel = excelExport.export(request);\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Forgetting to Make Template Final\n\n```java\n// ❌ Template method can be overridden - breaks algorithm\npublic void process() { // Should be final!\n step1();\n step2();\n step3();\n}\n\n// Subclass accidentally breaks structure\n@Override\npublic void process() {\n step2(); // Oops, skipped step1!\n step3();\n}\n\n// ✅ Correct - template is final\npublic final void process() {\n step1();\n step2();\n step3();\n}\n```\n\n### Mistake 2: Too Many Abstract Methods\n\n```java\n// ❌ Too many required methods - hard to implement\npublic abstract class BadTemplate {\n protected abstract void step1();\n protected abstract void step2();\n protected abstract void step3();\n protected abstract void step4();\n protected abstract void step5();\n // Subclass must implement ALL 5!\n}\n\n// ✅ Minimize required methods, use hooks for optional\npublic abstract class GoodTemplate {\n protected abstract void coreBehavior(); // Only truly variable part\n\n protected void beforeCore() { } // Hook\n protected void afterCore() { } // Hook\n}\n```\n\n---\n\n## 🐛 Debug This: The Broken Hook\n\nA developer reports: \"Our payment template should skip fraud check for PayPal payments under $500, but ALL payments are getting fraud checked!\"\n\n```java\npublic abstract class PaymentTemplate {\n\n public PaymentResult processPayment(Payment payment) {\n validate(payment);\n\n if (requiresFraudCheck()) {\n performFraudCheck(payment);\n }\n\n PaymentResult result = doProcess(payment);\n afterProcess(result);\n return result;\n }\n\n protected abstract void validate(Payment payment);\n protected abstract PaymentResult doProcess(Payment payment);\n\n // Hook - should fraud check run?\n protected boolean requiresFraudCheck() {\n return true; // Default: yes\n }\n\n protected void performFraudCheck(Payment payment) {\n fraudService.check(payment);\n }\n\n protected void afterProcess(PaymentResult result) { }\n}\n\npublic class PayPalPaymentProcessor extends PaymentTemplate {\n\n @Override\n protected void validate(Payment payment) {\n if (payment.getPayPalEmail() == null) {\n throw new ValidationException(\"PayPal email required\");\n }\n }\n\n @Override\n protected PaymentResult doProcess(Payment payment) {\n return payPalService.process(payment);\n }\n\n // Developer thought this was overriding the hook...\n protected boolean requiresFraudCheck(Payment payment) { // BUG!\n return payment.getAmount().compareTo(new BigDecimal(\"500\")) > 0;\n }\n}\n\n// Result: ALL PayPal payments get fraud checked, even $10 payments!\n```\n\n**Why does the fraud check run for all payments regardless of amount?**\n\n---\n\n**✅ Solution:**\n\nThe bug is a **method signature mismatch**. The hook method in the base class is:\n```java\nprotected boolean requiresFraudCheck() // No parameters\n```\n\nBut the subclass method has:\n```java\nprotected boolean requiresFraudCheck(Payment payment) // Has parameter!\n```\n\nThis is **method overloading, not overriding!** The base class `requiresFraudCheck()` is never overridden - it always returns `true`. The subclass method is a completely different method that never gets called.\n\n**The fix - use @Override to catch errors:**\n\n```java\npublic class PayPalPaymentProcessor extends PaymentTemplate {\n\n // Compiler error! Method doesn't override anything\n @Override // This would fail to compile\n protected boolean requiresFraudCheck(Payment payment) {\n return payment.getAmount().compareTo(new BigDecimal(\"500\")) > 0;\n }\n}\n```\n\n**Better design - pass context to hooks:**\n\n```java\npublic abstract class PaymentTemplate {\n\n public PaymentResult processPayment(Payment payment) {\n validate(payment);\n\n // Pass payment to hook so it can make decisions\n if (requiresFraudCheck(payment)) {\n performFraudCheck(payment);\n }\n\n PaymentResult result = doProcess(payment);\n afterProcess(result);\n return result;\n }\n\n // Hook with context parameter\n protected boolean requiresFraudCheck(Payment payment) {\n return true; // Default: yes\n }\n}\n\npublic class PayPalPaymentProcessor extends PaymentTemplate {\n\n @Override\n protected boolean requiresFraudCheck(Payment payment) {\n return payment.getAmount().compareTo(new BigDecimal(\"500\")) > 0;\n }\n}\n```\n\n**The lesson:** Always use `@Override` annotation - it causes a compile error if the signature doesn't match. Design hooks with necessary context parameters.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Basic Template Method\n⭐ Difficulty: Easy | ⏱️ Time: 15 minutes\n\n**Task:** Create a template for data export with customizable format.\n\n```java\n// Create ExportTemplate with:\n// - Template method: export()\n// - Required: fetchData(), formatData()\n// - Hook: getFilename() with default\n\n// Implement CSVExport and JSONExport\n```\n\n**✅ Solution:**\n\n```java\npublic abstract class ExportTemplate {\n\n public final byte[] export() {\n List data = fetchData();\n validateData(data);\n String formatted = formatData(data);\n return formatted.getBytes(StandardCharsets.UTF_8);\n }\n\n // Required - must implement\n protected abstract List fetchData();\n protected abstract String formatData(List data);\n\n // Hook with default\n protected void validateData(List data) {\n if (data == null || data.isEmpty()) {\n throw new IllegalStateException(\"No data to export\");\n }\n }\n\n // Hook for filename\n protected String getFilename() {\n return \"export_\" + System.currentTimeMillis();\n }\n}\n\npublic class CSVExport extends ExportTemplate {\n private final UserRepository repository;\n\n @Override\n protected List fetchData() {\n return repository.findAll();\n }\n\n @Override\n protected String formatData(List data) {\n StringBuilder csv = new StringBuilder(\"id,name,email\\n\");\n for (User user : data) {\n csv.append(String.format(\"%d,%s,%s%n\",\n user.getId(), user.getName(), user.getEmail()));\n }\n return csv.toString();\n }\n\n @Override\n protected String getFilename() {\n return \"users_\" + LocalDate.now() + \".csv\";\n }\n}\n\npublic class JSONExport extends ExportTemplate {\n private final OrderRepository repository;\n private final ObjectMapper mapper;\n\n @Override\n protected List fetchData() {\n return repository.findAll();\n }\n\n @Override\n protected String formatData(List data) {\n try {\n return mapper.writeValueAsString(data);\n } catch (JsonProcessingException e) {\n throw new ExportException(\"JSON formatting failed\", e);\n }\n }\n}\n```\n\n---\n\n### Exercise 2: Hooks Implementation\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Add multiple hook types to a notification template.\n\n```java\n// Create NotificationTemplate with:\n// - Conditional hook: shouldSend()\n// - Notification hooks: beforeSend(), afterSend()\n// - Transformation hook: transformMessage()\n\n// Implement EmailNotification and SMSNotification\n```\n\n**✅ Solution:**\n\n```java\npublic abstract class NotificationTemplate {\n\n public final void send(Notification notification) {\n // Conditional hook\n if (!shouldSend(notification)) {\n log.info(\"Notification skipped: {}\", notification.getId());\n return;\n }\n\n // Notification hook\n beforeSend(notification);\n\n // Transformation hook\n String message = transformMessage(notification.getMessage());\n\n // Core operation\n doSend(notification.getRecipient(), message);\n\n // Notification hook\n afterSend(notification);\n }\n\n // Required hooks\n protected abstract void doSend(String recipient, String message);\n\n // Conditional hook - controls if notification sends\n protected boolean shouldSend(Notification notification) {\n return notification.getRecipient() != null;\n }\n\n // Notification hooks - observe lifecycle\n protected void beforeSend(Notification notification) { }\n protected void afterSend(Notification notification) { }\n\n // Transformation hook - modify message\n protected String transformMessage(String message) {\n return message; // Default: no transformation\n }\n}\n\npublic class EmailNotification extends NotificationTemplate {\n\n @Override\n protected void doSend(String recipient, String message) {\n emailService.send(recipient, \"Notification\", message);\n }\n\n @Override\n protected boolean shouldSend(Notification notification) {\n // Only send if email is valid\n return super.shouldSend(notification) &&\n notification.getRecipient().contains(\"@\");\n }\n\n @Override\n protected String transformMessage(String message) {\n return \"\" + message + \"\";\n }\n\n @Override\n protected void afterSend(Notification notification) {\n metrics.increment(\"email.sent\");\n }\n}\n\npublic class SMSNotification extends NotificationTemplate {\n\n @Override\n protected void doSend(String recipient, String message) {\n smsGateway.send(recipient, message);\n }\n\n @Override\n protected boolean shouldSend(Notification notification) {\n // Don't send SMS at night\n int hour = LocalTime.now().getHour();\n return super.shouldSend(notification) && hour >= 8 && hour <= 22;\n }\n\n @Override\n protected String transformMessage(String message) {\n // SMS has 160 char limit\n return message.length() > 160\n ? message.substring(0, 157) + \"...\"\n : message;\n }\n}\n```\n\n---\n\n### Exercise 3: Functional Template\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Convert a class-based template to functional style.\n\n```java\n// Convert this to use lambdas/functions instead of inheritance:\npublic abstract class DataImportTemplate {\n public final int importData(InputStream input) {\n List lines = readLines(input);\n List parsed = parse(lines);\n List validated = validate(parsed);\n return save(validated);\n }\n\n protected abstract List parse(List lines);\n protected abstract int save(List records);\n protected List validate(List records) { return records; }\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class FunctionalImportTemplate {\n private final Function, List> parser;\n private final Function, Integer> saver;\n private final UnaryOperator> validator;\n\n private FunctionalImportTemplate(\n Function, List> parser,\n Function, Integer> saver,\n UnaryOperator> validator) {\n this.parser = parser;\n this.saver = saver;\n this.validator = validator;\n }\n\n public int importData(InputStream input) {\n List lines = readLines(input);\n List parsed = parser.apply(lines);\n List validated = validator.apply(parsed);\n return saver.apply(validated);\n }\n\n private List readLines(InputStream input) {\n try (BufferedReader reader = new BufferedReader(\n new InputStreamReader(input))) {\n return reader.lines().toList();\n } catch (IOException e) {\n throw new ImportException(\"Failed to read input\", e);\n }\n }\n\n public static Builder builder() {\n return new Builder<>();\n }\n\n public static class Builder {\n private Function, List> parser;\n private Function, Integer> saver;\n private UnaryOperator> validator = UnaryOperator.identity();\n\n public Builder parser(Function, List> parser) {\n this.parser = parser;\n return this;\n }\n\n public Builder saver(Function, Integer> saver) {\n this.saver = saver;\n return this;\n }\n\n public Builder validator(UnaryOperator> validator) {\n this.validator = validator;\n return this;\n }\n\n public FunctionalImportTemplate build() {\n Objects.requireNonNull(parser, \"Parser required\");\n Objects.requireNonNull(saver, \"Saver required\");\n return new FunctionalImportTemplate<>(parser, saver, validator);\n }\n }\n}\n\n// Usage\nFunctionalImportTemplate userImport = FunctionalImportTemplate.builder()\n .parser(lines -> lines.stream()\n .skip(1) // Skip header\n .map(line -> {\n String[] parts = line.split(\",\");\n return new User(parts[0], parts[1], parts[2]);\n })\n .toList())\n .validator(users -> users.stream()\n .filter(u -> u.getEmail().contains(\"@\"))\n .toList())\n .saver(users -> {\n userRepository.saveAll(users);\n return users.size();\n })\n .build();\n\nint imported = userImport.importData(inputStream);\n```\n\n---\n\n### Exercise 4: Spring-Style Template\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 25 minutes\n\n**Task:** Create a custom template for API calls with retry and circuit breaker.\n\n```java\n// Create ApiTemplate with:\n// - Automatic retry on failure\n// - Circuit breaker pattern\n// - Request/response logging\n// - Timeout handling\n\nString result = apiTemplate.execute(\n () -> httpClient.get(\"https://api.example.com/data\"),\n 3 // max retries\n);\n```\n\n**✅ Solution:**\n\n```java\npublic class ApiTemplate {\n private final CircuitBreaker circuitBreaker;\n private final Duration timeout;\n\n public ApiTemplate(int failureThreshold, Duration timeout) {\n this.circuitBreaker = new CircuitBreaker(failureThreshold);\n this.timeout = timeout;\n }\n\n public T execute(ApiCallback callback, int maxRetries) {\n // Circuit breaker check\n if (!circuitBreaker.allowRequest()) {\n throw new CircuitOpenException(\"Circuit is open, request blocked\");\n }\n\n Exception lastException = null;\n\n for (int attempt = 1; attempt <= maxRetries; attempt++) {\n try {\n beforeRequest(attempt);\n\n T result = executeWithTimeout(callback);\n\n afterRequest(attempt, result);\n circuitBreaker.recordSuccess();\n return result;\n\n } catch (Exception e) {\n lastException = e;\n onError(attempt, e);\n circuitBreaker.recordFailure();\n\n if (attempt < maxRetries && shouldRetry(e)) {\n waitBeforeRetry(attempt);\n } else if (!shouldRetry(e)) {\n break;\n }\n }\n }\n\n throw new ApiException(\"API call failed after \" + maxRetries + \" attempts\",\n lastException);\n }\n\n private T executeWithTimeout(ApiCallback callback) throws Exception {\n CompletableFuture future = CompletableFuture.supplyAsync(() -> {\n try {\n return callback.execute();\n } catch (Exception e) {\n throw new CompletionException(e);\n }\n });\n\n return future.get(timeout.toMillis(), TimeUnit.MILLISECONDS);\n }\n\n // Hooks\n protected void beforeRequest(int attempt) {\n log.debug(\"API request attempt {}\", attempt);\n }\n\n protected void afterRequest(int attempt, T result) {\n log.debug(\"API request succeeded on attempt {}\", attempt);\n }\n\n protected void onError(int attempt, Exception e) {\n log.warn(\"API request failed on attempt {}: {}\", attempt, e.getMessage());\n }\n\n protected boolean shouldRetry(Exception e) {\n return e instanceof TimeoutException ||\n e instanceof IOException ||\n (e instanceof HttpException && ((HttpException)e).isRetryable());\n }\n\n protected void waitBeforeRetry(int attempt) {\n try {\n long delay = (long) Math.pow(2, attempt) * 100;\n Thread.sleep(Math.min(delay, 5000));\n } catch (InterruptedException ie) {\n Thread.currentThread().interrupt();\n }\n }\n}\n\n@FunctionalInterface\npublic interface ApiCallback {\n T execute() throws Exception;\n}\n\n// Usage\nApiTemplate api = new ApiTemplate(5, Duration.ofSeconds(10));\n\nUser user = api.execute(\n () -> restClient.getForObject(\"/users/123\", User.class),\n 3\n);\n```\n\n---\n\n### Exercise 5: Template with Strategy Combination\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 30 minutes\n\n**Task:** Create a report generation template that combines with formatting and delivery strategies.\n\n```java\n// Create ReportTemplate with:\n// - Template for report lifecycle\n// - Strategy for formatting (PDF, Excel, HTML)\n// - Strategy for delivery (Email, S3, FTP)\n// - Hooks for customization\n\nReport report = reportTemplate\n .withFormatter(new PDFFormatter())\n .withDelivery(new EmailDelivery(\"user@example.com\"))\n .generate(reportRequest);\n```\n\n**✅ Solution:**\n\n```java\n// Strategies\npublic interface ReportFormatter {\n byte[] format(ReportData data);\n String getContentType();\n String getFileExtension();\n}\n\npublic interface ReportDelivery {\n void deliver(byte[] content, String filename, String contentType);\n}\n\n// Template\npublic abstract class ReportTemplate {\n private ReportFormatter formatter;\n private ReportDelivery delivery;\n\n public ReportTemplate withFormatter(ReportFormatter formatter) {\n this.formatter = Objects.requireNonNull(formatter);\n return this;\n }\n\n public ReportTemplate withDelivery(ReportDelivery delivery) {\n this.delivery = Objects.requireNonNull(delivery);\n return this;\n }\n\n // Template method\n public final Report generate(ReportRequest request) {\n Objects.requireNonNull(formatter, \"Formatter required\");\n\n // Hooks\n beforeGenerate(request);\n\n // Core algorithm\n List data = fetchData(request);\n List filtered = applyFilters(data, request.getFilters());\n List sorted = applySorting(filtered, request.getSortBy());\n ReportData reportData = transform(sorted);\n\n // Delegate to strategy\n byte[] content = formatter.format(reportData);\n\n String filename = getFilename(request) + formatter.getFileExtension();\n\n // Optional delivery\n if (delivery != null) {\n delivery.deliver(content, filename, formatter.getContentType());\n }\n\n afterGenerate(request, content);\n\n return new Report(filename, content, formatter.getContentType());\n }\n\n // Required hooks\n protected abstract List fetchData(ReportRequest request);\n protected abstract ReportData transform(List data);\n\n // Optional hooks\n protected List applyFilters(List data, List filters) {\n return data;\n }\n\n protected List applySorting(List data, String sortBy) {\n return data;\n }\n\n protected String getFilename(ReportRequest request) {\n return \"report_\" + LocalDate.now();\n }\n\n protected void beforeGenerate(ReportRequest request) { }\n protected void afterGenerate(ReportRequest request, byte[] content) { }\n}\n\n// Concrete implementations\npublic class SalesReportTemplate extends ReportTemplate {\n\n @Override\n protected List fetchData(ReportRequest request) {\n return salesRepository.findByDateRange(\n request.getStartDate(), request.getEndDate());\n }\n\n @Override\n protected ReportData transform(List sales) {\n BigDecimal total = sales.stream()\n .map(Sale::getAmount)\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n\n return new ReportData()\n .addSection(\"Summary\", Map.of(\n \"Total Sales\", total,\n \"Count\", sales.size()))\n .addTable(\"Details\", sales);\n }\n\n @Override\n protected String getFilename(ReportRequest request) {\n return \"sales_report_\" + request.getStartDate() + \"_\" + request.getEndDate();\n }\n}\n\n// Formatters\npublic class PDFFormatter implements ReportFormatter {\n @Override\n public byte[] format(ReportData data) {\n // Use iText or similar\n return pdfGenerator.generate(data);\n }\n\n @Override public String getContentType() { return \"application/pdf\"; }\n @Override public String getFileExtension() { return \".pdf\"; }\n}\n\npublic class ExcelFormatter implements ReportFormatter {\n @Override\n public byte[] format(ReportData data) {\n // Use Apache POI\n return excelGenerator.generate(data);\n }\n\n @Override public String getContentType() {\n return \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\";\n }\n @Override public String getFileExtension() { return \".xlsx\"; }\n}\n\n// Delivery strategies\npublic class EmailDelivery implements ReportDelivery {\n private final String recipient;\n\n @Override\n public void deliver(byte[] content, String filename, String contentType) {\n emailService.sendWithAttachment(recipient, \"Your Report\",\n content, filename, contentType);\n }\n}\n\npublic class S3Delivery implements ReportDelivery {\n private final String bucket;\n\n @Override\n public void deliver(byte[] content, String filename, String contentType) {\n s3Client.putObject(bucket, filename, content, contentType);\n }\n}\n\n// Usage\nReport report = new SalesReportTemplate()\n .withFormatter(new PDFFormatter())\n .withDelivery(new EmailDelivery(\"manager@company.com\"))\n .generate(new ReportRequest(startDate, endDate, filters));\n```\n\n---\n\n## 🎤 Interview Questions\n\n### Q1: Template Method vs Strategy Pattern?\n\n**Answer:**\n- **Template Method**: Uses inheritance, defines algorithm skeleton with variable steps\n- **Strategy**: Uses composition, entire algorithm is interchangeable\n\nTemplate Method: \"same algorithm, different steps\"\nStrategy: \"different algorithms entirely\"\n\n### Q2: What are hooks in Template Method?\n\n**Answer:**\nHooks are optional methods with default (often empty) implementations:\n- **Required hooks** (abstract): Must be implemented\n- **Optional hooks**: Default implementation, can override\n- **Notification hooks**: For observation (beforeX, afterX)\n- **Conditional hooks**: Control flow (shouldDoX returns boolean)\n\n---\n\n## 📝 Summary\n\n| Concept | Use When |\n|---------|----------|\n| Template Method | Shared algorithm structure, variable steps |\n| Required Hooks | Step MUST be customized |\n| Optional Hooks | Step CAN be customized |\n| Functional Template | Prefer composition over inheritance |\n| Spring Templates | Database, HTTP, transaction operations |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review Template Method structure diagram | 5 min |\n| Day 3 | Redo Exercise 1 (Basic Template Method) | 15 min |\n| Day 7 | Answer interview questions without looking | 10 min |\n| Day 14 | Redo Debug This (Broken Hook) | 15 min |\n| Day 30 | Identify one duplicated algorithm in your codebase to template | 20 min |\n\n---\n\n*Next: [Part 14: Exception Hierarchy Design]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.793785Z","createdAt","2026-06-10T07:19:24.794610Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",19,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",13,"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},64,"Template Method","template-method",67,"Hook Methods","hook-methods",65,"Behavioral Patterns","behavioral-patterns",66,"Algorithm Skeleton","algorithm-skeleton",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]