[{"_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",13,"title","Chain of Responsibility and Pipelines","slug","clean-code-part-12-chain-pipeline","excerpt","Master sequential processing patterns: validation chains, middleware pipelines, and handler delegation that decouple processing steps.","# Advanced Clean Code Patterns Part 12: Chain of Responsibility & Pipeline\n\nWhen processing requires multiple steps or multiple handlers might process a request, Chain of Responsibility and Pipeline patterns provide clean solutions. This article covers classic chains, middleware patterns, and type-safe pipelines.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Patterns Covered | Chain of Responsibility, Pipeline, Middleware |\n| Primary Benefit | Decoupled processing, easy to extend |\n| Use Cases | Validation, request handling, data transformation |\n| Java Features | Lambdas, Generics, Records |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Chain of Responsibility** for handler delegation\n- **Pipeline Pattern** for sequential transformations\n- **Middleware Pattern** (request/response chains)\n- **Spring integration** with interceptors and filters\n- **When to use chains** vs simple conditionals\n\n---\n\n## Production Story: The Validation Spaghetti\n\nAn e-commerce checkout had validation scattered everywhere:\n\n```java\n// ❌ Validation spaghetti\npublic OrderResult checkout(CheckoutRequest request) {\n // 50 lines of validation\n if (request.getCart() == null || request.getCart().isEmpty()) {\n return OrderResult.error(\"Cart is empty\");\n }\n if (request.getCustomer() == null) {\n return OrderResult.error(\"Customer required\");\n }\n if (request.getPayment() == null) {\n return OrderResult.error(\"Payment required\");\n }\n // Check inventory for each item...\n for (CartItem item : request.getCart()) {\n if (!inventoryService.isAvailable(item.getProductId(), item.getQuantity())) {\n return OrderResult.error(\"Product unavailable: \" + item.getProductId());\n }\n }\n // Check customer credit...\n if (request.getPayment().getType() == PaymentType.CREDIT) {\n if (!creditService.checkLimit(request.getCustomer(), request.getTotal())) {\n return OrderResult.error(\"Credit limit exceeded\");\n }\n }\n // 30 more validations...\n\n // Finally, actual business logic buried at the bottom\n return processOrder(request);\n}\n```\n\n**The fix:** Validation chain:\n\n```java\n// ✅ Clean validation chain\npublic OrderResult checkout(CheckoutRequest request) {\n return validationChain.validate(request)\n .map(this::processOrder)\n .orElseGet(errors -> OrderResult.validationFailed(errors));\n}\n\n// Validators are separate, testable, reusable\n@Component\npublic class CartValidator implements CheckoutValidator { ... }\n\n@Component\npublic class InventoryValidator implements CheckoutValidator { ... }\n\n@Component\npublic class CreditValidator implements CheckoutValidator { ... }\n```\n\n---\n\n## Mental Model: Chain vs Pipeline\n\n```text\n┌─────────────────────────────────────────────────────────────────┐\n│ CHAIN VS PIPELINE │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ CHAIN OF RESPONSIBILITY │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Request ──→ [Handler A] ──→ [Handler B] ──→ [Handler C] │ │\n│ │ │ │ │ │ │\n│ │ ↓ ↓ ↓ │ │\n│ │ \"Can I?\" \"Can I?\" \"Can I?\" │ │\n│ │ │ │ │ │ │\n│ │ (Yes: Handle) (Yes: Handle) (Yes: Handle) │ │\n│ │ (No: Pass on) (No: Pass on) (No: Pass on) │ │\n│ │ │ │\n│ │ • Handler decides if it should process │ │\n│ │ • Can stop chain or pass to next │ │\n│ │ • Request may be handled by 0, 1, or many handlers │ │\n│ │ │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n│ PIPELINE │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Input ──→ [Step A] ──→ [Step B] ──→ [Step C] ──→ Output │ │\n│ │ (A→B) (B→C) (C→D) │ │\n│ │ │ │\n│ │ • Each step transforms data │ │\n│ │ • All steps execute in sequence │ │\n│ │ • Output of one is input to next │ │\n│ │ │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Classic Chain of Responsibility\n\n```java\n// ✅ Chain of Responsibility for request handling\n\n// Handler interface\npublic interface SupportHandler {\n void setNext(SupportHandler next);\n void handle(SupportTicket ticket);\n}\n\n// Base handler with chain logic\npublic abstract class BaseSupportHandler implements SupportHandler {\n protected SupportHandler next;\n\n @Override\n public void setNext(SupportHandler next) {\n this.next = next;\n }\n\n protected void passToNext(SupportTicket ticket) {\n if (next != null) {\n next.handle(ticket);\n } else {\n throw new UnhandledTicketException(ticket);\n }\n }\n}\n\n// Concrete handlers\npublic class Level1Support extends BaseSupportHandler {\n @Override\n public void handle(SupportTicket ticket) {\n if (ticket.getSeverity() == Severity.LOW) {\n resolveWithFAQ(ticket);\n } else {\n passToNext(ticket);\n }\n }\n}\n\npublic class Level2Support extends BaseSupportHandler {\n @Override\n public void handle(SupportTicket ticket) {\n if (ticket.getSeverity() == Severity.MEDIUM) {\n investigateAndResolve(ticket);\n } else {\n passToNext(ticket);\n }\n }\n}\n\npublic class Level3Support extends BaseSupportHandler {\n @Override\n public void handle(SupportTicket ticket) {\n // Level 3 handles everything that reaches it\n escalateToEngineering(ticket);\n }\n}\n\n// Build chain\nSupportHandler chain = buildChain();\nchain.handle(new SupportTicket(Severity.HIGH, \"System down\"));\n\nprivate SupportHandler buildChain() {\n SupportHandler level1 = new Level1Support();\n SupportHandler level2 = new Level2Support();\n SupportHandler level3 = new Level3Support();\n\n level1.setNext(level2);\n level2.setNext(level3);\n\n return level1;\n}\n```\n\n---\n\n### Pattern 2: Functional Chain (Modern Approach)\n\n```java\n// ✅ Functional chain with lambdas\n\n@FunctionalInterface\npublic interface Handler {\n Optional handle(T request);\n\n default Handler andThen(Handler next) {\n return request -> this.handle(request)\n .or(() -> next.handle(request));\n }\n}\n\n// Build chain fluently\nHandler chain = ((Handler) this::handleLevel1)\n .andThen(this::handleLevel2)\n .andThen(this::handleLevel3);\n\nOptional result = chain.handle(ticket);\n\n// ✅ With Spring auto-discovery\n@Service\npublic class SupportChain {\n private final Handler chain;\n\n public SupportChain(List handlers) {\n this.chain = handlers.stream()\n .sorted(Comparator.comparing(SupportHandler::getPriority))\n .map(h -> (Handler) h::handle)\n .reduce(Handler::andThen)\n .orElseThrow(() -> new IllegalStateException(\"No handlers\"));\n }\n\n public SupportTicket process(SupportTicket ticket) {\n return chain.handle(ticket)\n .orElseThrow(() -> new UnhandledTicketException(ticket));\n }\n}\n```\n\n---\n\n### Pattern 3: Validation Chain\n\n```java\n// ✅ Validation chain with error accumulation\n\npublic interface Validator {\n ValidationResult validate(T target);\n}\n\npublic record ValidationResult(List errors) {\n public static ValidationResult ok() {\n return new ValidationResult(List.of());\n }\n\n public static ValidationResult error(String message) {\n return new ValidationResult(List.of(message));\n }\n\n public boolean isValid() {\n return errors.isEmpty();\n }\n\n public ValidationResult merge(ValidationResult other) {\n List combined = new ArrayList<>(errors);\n combined.addAll(other.errors);\n return new ValidationResult(combined);\n }\n}\n\n@Service\npublic class ValidationChain {\n private final List> validators;\n\n public ValidationChain(List> validators) {\n this.validators = validators;\n }\n\n // Fail-fast: stop on first error\n public ValidationResult validateFailFast(T target) {\n for (Validator validator : validators) {\n ValidationResult result = validator.validate(target);\n if (!result.isValid()) {\n return result;\n }\n }\n return ValidationResult.ok();\n }\n\n // Collect all errors\n public ValidationResult validateAll(T target) {\n return validators.stream()\n .map(v -> v.validate(target))\n .reduce(ValidationResult.ok(), ValidationResult::merge);\n }\n}\n\n// Individual validators\n@Component\npublic class EmailValidator implements Validator {\n @Override\n public ValidationResult validate(User user) {\n if (user.getEmail() == null || !user.getEmail().contains(\"@\")) {\n return ValidationResult.error(\"Invalid email\");\n }\n return ValidationResult.ok();\n }\n}\n\n@Component\npublic class PasswordValidator implements Validator {\n @Override\n public ValidationResult validate(User user) {\n List errors = new ArrayList<>();\n String password = user.getPassword();\n\n if (password == null || password.length() < 8) {\n errors.add(\"Password must be at least 8 characters\");\n }\n if (!password.matches(\".*[A-Z].*\")) {\n errors.add(\"Password must contain uppercase\");\n }\n if (!password.matches(\".*[0-9].*\")) {\n errors.add(\"Password must contain a number\");\n }\n\n return new ValidationResult(errors);\n }\n}\n```\n\n---\n\n### Pattern 4: Pipeline Pattern\n\n```java\n// ✅ Type-safe pipeline\n\npublic interface PipelineStep {\n O process(I input);\n}\n\npublic class Pipeline {\n private final Function steps;\n\n private Pipeline(Function steps) {\n this.steps = steps;\n }\n\n public static Pipeline start() {\n return new Pipeline<>(Function.identity());\n }\n\n public Pipeline addStep(PipelineStep step) {\n return new Pipeline<>(steps.andThen(step::process));\n }\n\n public Pipeline addStep(Function step) {\n return new Pipeline<>(steps.andThen(step));\n }\n\n public O execute(I input) {\n return steps.apply(input);\n }\n}\n\n// Usage with type transformations\nPipeline orderPipeline = Pipeline.start()\n .addStep(this::validate) // RawOrder -> ValidatedOrder\n .addStep(this::enrich) // ValidatedOrder -> EnrichedOrder\n .addStep(this::calculatePricing) // EnrichedOrder -> PricedOrder\n .addStep(this::applyDiscounts) // PricedOrder -> ProcessedOrder\n .addStep(this::finalize); // ProcessedOrder -> ProcessedOrder\n\nProcessedOrder result = orderPipeline.execute(rawOrder);\n```\n\n**Pipeline with error handling:**\n\n```java\n// ✅ Pipeline with Result type\n\npublic sealed interface Result permits Success, Failure {\n Result map(Function mapper);\n Result flatMap(Function> mapper);\n T orElseThrow();\n}\n\npublic record Success(T value) implements Result {\n @Override\n public Result map(Function mapper) {\n return new Success<>(mapper.apply(value));\n }\n\n @Override\n public Result flatMap(Function> mapper) {\n return mapper.apply(value);\n }\n\n @Override\n public T orElseThrow() {\n return value;\n }\n}\n\npublic record Failure(String error) implements Result {\n @Override\n public Result map(Function mapper) {\n return new Failure<>(error);\n }\n\n @Override\n public Result flatMap(Function> mapper) {\n return new Failure<>(error);\n }\n\n @Override\n public T orElseThrow() {\n throw new PipelineException(error);\n }\n}\n\n// Pipeline with error handling\npublic class SafePipeline {\n private final Function> steps;\n\n public static SafePipeline start() {\n return new SafePipeline<>(i -> new Success<>(i));\n }\n\n public SafePipeline addStep(Function> step) {\n return new SafePipeline<>(i -> steps.apply(i).flatMap(step));\n }\n\n public Result execute(I input) {\n return steps.apply(input);\n }\n}\n\n// Usage - errors propagate automatically\nSafePipeline pipeline = SafePipeline.start()\n .addStep(this::validate) // Returns Result\n .addStep(this::checkInventory) // Returns Result<...>\n .addStep(this::processPayment); // Returns Result<...>\n\nResult result = pipeline.execute(rawOrder);\n\n// Handle result\nswitch (result) {\n case Success(var order) -> sendConfirmation(order);\n case Failure(var error) -> notifyCustomer(error);\n}\n```\n\n---\n\n### Pattern 5: Middleware Pattern\n\n```java\n// ✅ Middleware pattern (like Express.js)\n\n@FunctionalInterface\npublic interface Middleware {\n T handle(T request, MiddlewareChain chain);\n}\n\npublic interface MiddlewareChain {\n T proceed(T request);\n}\n\npublic class MiddlewareExecutor {\n private final List> middlewares;\n private final Function finalHandler;\n\n public MiddlewareExecutor(List> middlewares,\n Function finalHandler) {\n this.middlewares = middlewares;\n this.finalHandler = finalHandler;\n }\n\n public T execute(T request) {\n return new Chain(0).proceed(request);\n }\n\n private class Chain implements MiddlewareChain {\n private final int index;\n\n Chain(int index) {\n this.index = index;\n }\n\n @Override\n public T proceed(T request) {\n if (index < middlewares.size()) {\n return middlewares.get(index).handle(request, new Chain(index + 1));\n }\n return finalHandler.apply(request);\n }\n }\n}\n\n// Middleware implementations\npublic class LoggingMiddleware implements Middleware {\n @Override\n public HttpRequest handle(HttpRequest request, MiddlewareChain chain) {\n log.info(\"Request: {} {}\", request.getMethod(), request.getPath());\n long start = System.currentTimeMillis();\n\n HttpRequest response = chain.proceed(request);\n\n log.info(\"Response: {} in {}ms\", response.getStatus(),\n System.currentTimeMillis() - start);\n return response;\n }\n}\n\npublic class AuthenticationMiddleware implements Middleware {\n @Override\n public HttpRequest handle(HttpRequest request, MiddlewareChain chain) {\n String token = request.getHeader(\"Authorization\");\n if (token == null || !authService.isValid(token)) {\n return HttpRequest.unauthorized();\n }\n\n User user = authService.getUser(token);\n return chain.proceed(request.withUser(user));\n }\n}\n\npublic class RateLimitMiddleware implements Middleware {\n @Override\n public HttpRequest handle(HttpRequest request, MiddlewareChain chain) {\n String clientIp = request.getClientIp();\n if (!rateLimiter.tryAcquire(clientIp)) {\n return HttpRequest.tooManyRequests();\n }\n return chain.proceed(request);\n }\n}\n```\n\n---\n\n### Pattern 6: Spring Integration\n\n```java\n// ✅ Chain with Spring Boot\n\n// Handler interface with Spring ordering\npublic interface OrderProcessor extends Ordered {\n boolean canHandle(Order order);\n ProcessingResult process(Order order);\n}\n\n@Component\n@Order(1)\npublic class FraudCheckProcessor implements OrderProcessor {\n @Override\n public boolean canHandle(Order order) {\n return order.getTotal().compareTo(new BigDecimal(\"1000\")) > 0;\n }\n\n @Override\n public ProcessingResult process(Order order) {\n return fraudService.check(order);\n }\n\n @Override\n public int getOrder() { return 1; }\n}\n\n@Component\n@Order(2)\npublic class InventoryProcessor implements OrderProcessor {\n @Override\n public boolean canHandle(Order order) {\n return true; // Always check inventory\n }\n\n @Override\n public ProcessingResult process(Order order) {\n return inventoryService.reserve(order);\n }\n\n @Override\n public int getOrder() { return 2; }\n}\n\n// Chain executor\n@Service\npublic class OrderProcessorChain {\n private final List processors;\n\n public OrderProcessorChain(List processors) {\n // Spring auto-sorts by @Order\n this.processors = processors;\n }\n\n public ProcessingResult process(Order order) {\n for (OrderProcessor processor : processors) {\n if (processor.canHandle(order)) {\n ProcessingResult result = processor.process(order);\n if (!result.isSuccess()) {\n return result; // Stop on failure\n }\n }\n }\n return ProcessingResult.success();\n }\n}\n\n// ✅ Using HandlerInterceptor (Spring MVC)\n@Component\npublic class AuditInterceptor implements HandlerInterceptor {\n\n @Override\n public boolean preHandle(HttpServletRequest request,\n HttpServletResponse response,\n Object handler) {\n MDC.put(\"requestId\", UUID.randomUUID().toString());\n MDC.put(\"userId\", extractUserId(request));\n return true;\n }\n\n @Override\n public void afterCompletion(HttpServletRequest request,\n HttpServletResponse response,\n Object handler,\n Exception ex) {\n auditService.log(\n MDC.get(\"requestId\"),\n request.getRequestURI(),\n response.getStatus());\n MDC.clear();\n }\n}\n\n@Configuration\npublic class WebConfig implements WebMvcConfigurer {\n @Override\n public void addInterceptors(InterceptorRegistry registry) {\n registry.addInterceptor(new AuditInterceptor())\n .addPathPatterns(\"/api/**\");\n }\n}\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Missing Termination\n\n```java\n// ❌ Chain without default handler\npublic void handle(Request request) {\n if (canHandle(request)) {\n doHandle(request);\n } else if (next != null) {\n next.handle(request);\n }\n // Silent failure if no handler found!\n}\n\n// ✅ Always have termination\npublic void handle(Request request) {\n if (canHandle(request)) {\n doHandle(request);\n } else if (next != null) {\n next.handle(request);\n } else {\n throw new UnhandledRequestException(request);\n // Or: defaultHandler.handle(request);\n }\n}\n```\n\n### Mistake 2: Tight Coupling in Chain\n\n```java\n// ❌ Handler knows about specific next handler\npublic class Level1Handler {\n public void handle(Request request) {\n if (!canHandle(request)) {\n new Level2Handler().handle(request); // Tight coupling!\n }\n }\n}\n\n// ✅ Handler only knows interface\npublic class Level1Handler implements Handler {\n private Handler next;\n\n @Override\n public void setNext(Handler next) {\n this.next = next;\n }\n\n @Override\n public void handle(Request request) {\n if (!canHandle(request) && next != null) {\n next.handle(request);\n }\n }\n}\n```\n\n---\n\n## 🐛 Debug This: The Broken Chain\n\nA developer reports: \"Our validation chain works for some requests but silently skips validation for others!\"\n\n```java\npublic interface Validator {\n void setNext(Validator next);\n ValidationResult validate(Request request);\n}\n\npublic abstract class BaseValidator implements Validator {\n protected Validator next;\n\n @Override\n public void setNext(Validator next) {\n this.next = next;\n }\n\n protected ValidationResult passToNext(Request request) {\n if (next != null) {\n return next.validate(request);\n }\n return ValidationResult.ok();\n }\n}\n\npublic class RequiredFieldsValidator extends BaseValidator {\n @Override\n public ValidationResult validate(Request request) {\n if (request.getName() == null) {\n return ValidationResult.error(\"Name required\");\n }\n // BUG: Forgot to call passToNext!\n return ValidationResult.ok();\n }\n}\n\npublic class EmailValidator extends BaseValidator {\n @Override\n public ValidationResult validate(Request request) {\n if (!request.getEmail().contains(\"@\")) {\n return ValidationResult.error(\"Invalid email\");\n }\n return passToNext(request);\n }\n}\n\npublic class AgeValidator extends BaseValidator {\n @Override\n public ValidationResult validate(Request request) {\n if (request.getAge() < 18) {\n return ValidationResult.error(\"Must be 18+\");\n }\n return passToNext(request);\n }\n}\n\n// Chain: RequiredFields -> Email -> Age\n// Test: Request with valid name but invalid email passes validation!\n```\n\n**Why does the email validation get skipped?**\n\n---\n\n**✅ Solution:**\n\nThe bug is in `RequiredFieldsValidator` - when validation passes (name is not null), it returns `ValidationResult.ok()` **without calling `passToNext()`**. This breaks the chain completely.\n\n```java\npublic class RequiredFieldsValidator extends BaseValidator {\n @Override\n public ValidationResult validate(Request request) {\n if (request.getName() == null) {\n return ValidationResult.error(\"Name required\");\n }\n // BUG: Chain stops here when name is valid!\n return ValidationResult.ok();\n // Should be: return passToNext(request);\n }\n}\n```\n\n**The fix:**\n\n```java\npublic class RequiredFieldsValidator extends BaseValidator {\n @Override\n public ValidationResult validate(Request request) {\n if (request.getName() == null) {\n return ValidationResult.error(\"Name required\");\n }\n return passToNext(request); // Continue chain!\n }\n}\n```\n\n**Better approach - use Template Method to prevent this bug:**\n\n```java\npublic abstract class BaseValidator implements Validator {\n protected Validator next;\n\n @Override\n public final ValidationResult validate(Request request) {\n ValidationResult result = doValidate(request);\n if (!result.isValid()) {\n return result; // Stop on error\n }\n return passToNext(request); // Always continue if valid\n }\n\n protected abstract ValidationResult doValidate(Request request);\n\n // Subclasses only implement doValidate, can't forget passToNext\n}\n```\n\n**The lesson:** When implementing Chain of Responsibility, ensure chain continuation is enforced by the base class, not left to subclass implementations.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Simple Handler Chain\n⭐ Difficulty: Easy | ⏱️ Time: 15 minutes\n\n**Task:** Implement a discount handler chain for e-commerce.\n\n```java\n// Create handlers for:\n// - VIP customers get 20% off\n// - Orders over $100 get 10% off\n// - First-time buyers get 5% off\n// - Default: no discount\n\n// Chain should stop at first applicable discount\nOrder order = new Order(customerId, 150.00, isFirstTime);\ndouble discount = discountChain.calculate(order);\n```\n\n**✅ Solution:**\n\n```java\npublic interface DiscountHandler {\n void setNext(DiscountHandler next);\n double calculate(Order order);\n}\n\npublic abstract class BaseDiscountHandler implements DiscountHandler {\n protected DiscountHandler next;\n\n @Override\n public void setNext(DiscountHandler next) {\n this.next = next;\n }\n\n protected double passToNext(Order order) {\n if (next != null) {\n return next.calculate(order);\n }\n return 0.0; // No discount\n }\n}\n\npublic class VipDiscountHandler extends BaseDiscountHandler {\n private final Set vipCustomers;\n\n public VipDiscountHandler(Set vipCustomers) {\n this.vipCustomers = vipCustomers;\n }\n\n @Override\n public double calculate(Order order) {\n if (vipCustomers.contains(order.getCustomerId())) {\n return order.getTotal() * 0.20; // 20% off\n }\n return passToNext(order);\n }\n}\n\npublic class LargeOrderDiscountHandler extends BaseDiscountHandler {\n @Override\n public double calculate(Order order) {\n if (order.getTotal() > 100) {\n return order.getTotal() * 0.10; // 10% off\n }\n return passToNext(order);\n }\n}\n\npublic class FirstTimeDiscountHandler extends BaseDiscountHandler {\n @Override\n public double calculate(Order order) {\n if (order.isFirstTimeBuyer()) {\n return order.getTotal() * 0.05; // 5% off\n }\n return passToNext(order);\n }\n}\n\n// Build chain\nDiscountHandler chain = new VipDiscountHandler(vipCustomers);\nchain.setNext(new LargeOrderDiscountHandler());\n((LargeOrderDiscountHandler) chain).setNext(new FirstTimeDiscountHandler());\n```\n\n---\n\n### Exercise 2: Validation Pipeline\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Create a validation pipeline that collects all errors (not fail-fast).\n\n```java\n// Pipeline should:\n// 1. Run all validators\n// 2. Collect all errors\n// 3. Return combined result\n\nValidationResult result = pipeline.validate(user);\n// Result: [\"Email invalid\", \"Password too short\", \"Age must be 18+\"]\n```\n\n**✅ Solution:**\n\n```java\npublic record ValidationResult(List errors) {\n public static ValidationResult ok() {\n return new ValidationResult(List.of());\n }\n\n public static ValidationResult error(String message) {\n return new ValidationResult(List.of(message));\n }\n\n public static ValidationResult errors(List messages) {\n return new ValidationResult(List.copyOf(messages));\n }\n\n public boolean isValid() {\n return errors.isEmpty();\n }\n\n public ValidationResult merge(ValidationResult other) {\n List combined = new ArrayList<>(errors);\n combined.addAll(other.errors);\n return new ValidationResult(combined);\n }\n}\n\n@FunctionalInterface\npublic interface Validator {\n ValidationResult validate(T target);\n}\n\npublic class ValidationPipeline {\n private final List> validators = new ArrayList<>();\n\n public ValidationPipeline addValidator(Validator validator) {\n validators.add(validator);\n return this;\n }\n\n public ValidationResult validate(T target) {\n return validators.stream()\n .map(v -> v.validate(target))\n .reduce(ValidationResult.ok(), ValidationResult::merge);\n }\n}\n\n// Usage\nValidationPipeline pipeline = new ValidationPipeline()\n .addValidator(user -> {\n if (!user.getEmail().contains(\"@\")) {\n return ValidationResult.error(\"Email invalid\");\n }\n return ValidationResult.ok();\n })\n .addValidator(user -> {\n if (user.getPassword().length() < 8) {\n return ValidationResult.error(\"Password too short\");\n }\n return ValidationResult.ok();\n })\n .addValidator(user -> {\n if (user.getAge() < 18) {\n return ValidationResult.error(\"Age must be 18+\");\n }\n return ValidationResult.ok();\n });\n\nValidationResult result = pipeline.validate(new User(\"test\", \"short\", 16));\n// errors: [\"Email invalid\", \"Password too short\", \"Age must be 18+\"]\n```\n\n---\n\n### Exercise 3: Middleware Chain\n⭐⭐ Difficulty: Medium | ⏱️ Time: 25 minutes\n\n**Task:** Implement HTTP middleware pattern with before/after hooks.\n\n```java\n// Middleware can:\n// 1. Modify request before passing down\n// 2. Modify response after getting it back\n// 3. Short-circuit the chain (e.g., auth failure)\n\nResponse response = middleware.execute(request);\n// Logs: \"Auth check -> Rate limit check -> Handler -> Rate limit done -> Auth done\"\n```\n\n**✅ Solution:**\n\n```java\npublic interface Middleware {\n Response handle(Request request, MiddlewareChain chain);\n}\n\npublic interface MiddlewareChain {\n Response proceed(Request request);\n}\n\npublic class MiddlewareExecutor {\n private final List middlewares;\n private final Function handler;\n\n public MiddlewareExecutor(List middlewares,\n Function handler) {\n this.middlewares = middlewares;\n this.handler = handler;\n }\n\n public Response execute(Request request) {\n return new ChainImpl(0).proceed(request);\n }\n\n private class ChainImpl implements MiddlewareChain {\n private final int index;\n\n ChainImpl(int index) {\n this.index = index;\n }\n\n @Override\n public Response proceed(Request request) {\n if (index < middlewares.size()) {\n return middlewares.get(index)\n .handle(request, new ChainImpl(index + 1));\n }\n return handler.apply(request);\n }\n }\n}\n\n// Middlewares\npublic class LoggingMiddleware implements Middleware {\n @Override\n public Response handle(Request request, MiddlewareChain chain) {\n System.out.println(\">> Request: \" + request.getPath());\n long start = System.currentTimeMillis();\n\n Response response = chain.proceed(request);\n\n System.out.println(\"<< Response: \" + response.getStatus() +\n \" in \" + (System.currentTimeMillis() - start) + \"ms\");\n return response;\n }\n}\n\npublic class AuthMiddleware implements Middleware {\n @Override\n public Response handle(Request request, MiddlewareChain chain) {\n String token = request.getHeader(\"Authorization\");\n if (token == null || !isValid(token)) {\n return Response.unauthorized(\"Invalid token\");\n }\n return chain.proceed(request.withUser(getUser(token)));\n }\n}\n\npublic class RateLimitMiddleware implements Middleware {\n private final RateLimiter limiter = new RateLimiter(100);\n\n @Override\n public Response handle(Request request, MiddlewareChain chain) {\n if (!limiter.tryAcquire(request.getClientIp())) {\n return Response.tooManyRequests();\n }\n return chain.proceed(request);\n }\n}\n\n// Usage\nMiddlewareExecutor executor = new MiddlewareExecutor(\n List.of(\n new LoggingMiddleware(),\n new AuthMiddleware(),\n new RateLimitMiddleware()\n ),\n request -> new Response(200, \"OK\")\n);\n```\n\n---\n\n### Exercise 4: Type-Safe Pipeline\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 25 minutes\n\n**Task:** Create a type-safe pipeline where each step transforms the type.\n\n```java\n// Pipeline: String -> ParsedData -> ValidatedData -> EnrichedData -> Result\nPipeline pipeline = Pipeline.start()\n .then(this::parse) // String -> ParsedData\n .then(this::validate) // ParsedData -> ValidatedData\n .then(this::enrich) // ValidatedData -> EnrichedData\n .then(this::process); // EnrichedData -> Result\n\nResult result = pipeline.execute(\"input data\");\n```\n\n**✅ Solution:**\n\n```java\npublic class Pipeline {\n private final Function function;\n\n private Pipeline(Function function) {\n this.function = function;\n }\n\n public static Pipeline start() {\n return new Pipeline<>(Function.identity());\n }\n\n public Pipeline then(Function step) {\n return new Pipeline<>(function.andThen(step));\n }\n\n public O execute(I input) {\n return function.apply(input);\n }\n}\n\n// Domain types\nrecord ParsedData(String id, Map fields) {}\nrecord ValidatedData(String id, Map fields, boolean valid) {}\nrecord EnrichedData(String id, Map fields, Instant timestamp) {}\nrecord Result(String id, String status, Instant processedAt) {}\n\n// Pipeline steps\nclass DataProcessor {\n ParsedData parse(String input) {\n // Parse JSON/CSV/etc\n return new ParsedData(\"123\", Map.of(\"name\", \"Test\"));\n }\n\n ValidatedData validate(ParsedData data) {\n boolean isValid = data.fields().containsKey(\"name\");\n return new ValidatedData(data.id(), data.fields(), isValid);\n }\n\n EnrichedData enrich(ValidatedData data) {\n return new EnrichedData(data.id(), data.fields(), Instant.now());\n }\n\n Result process(EnrichedData data) {\n return new Result(data.id(), \"PROCESSED\", data.timestamp());\n }\n}\n\n// Usage\nDataProcessor processor = new DataProcessor();\nPipeline pipeline = Pipeline.start()\n .then(processor::parse)\n .then(processor::validate)\n .then(processor::enrich)\n .then(processor::process);\n\nResult result = pipeline.execute(\"{\\\"name\\\": \\\"test\\\"}\");\n```\n\n---\n\n### Exercise 5: Pipeline with Error Handling\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 30 minutes\n\n**Task:** Create a pipeline with Result type for error propagation.\n\n```java\n// Pipeline should:\n// 1. Stop on first error\n// 2. Propagate error through remaining steps\n// 3. Allow error recovery/mapping\n\nResult result = pipeline.execute(rawOrder);\n\nresult.fold(\n error -> log.error(\"Failed: {}\", error),\n order -> sendConfirmation(order)\n);\n```\n\n**✅ Solution:**\n\n```java\npublic sealed interface Result permits Result.Success, Result.Failure {\n\n Result map(Function mapper);\n Result flatMap(Function> mapper);\n T orElse(T defaultValue);\n T orElseThrow();\n U fold(Function onError, Function onSuccess);\n\n record Success(T value) implements Result {\n @Override\n public Result map(Function mapper) {\n return new Success<>(mapper.apply(value));\n }\n\n @Override\n public Result flatMap(Function> mapper) {\n return mapper.apply(value);\n }\n\n @Override\n public T orElse(T defaultValue) {\n return value;\n }\n\n @Override\n public T orElseThrow() {\n return value;\n }\n\n @Override\n public U fold(Function onError, Function onSuccess) {\n return onSuccess.apply(value);\n }\n }\n\n record Failure(String error) implements Result {\n @Override\n public Result map(Function mapper) {\n return new Failure<>(error);\n }\n\n @Override\n public Result flatMap(Function> mapper) {\n return new Failure<>(error);\n }\n\n @Override\n public T orElse(T defaultValue) {\n return defaultValue;\n }\n\n @Override\n public T orElseThrow() {\n throw new RuntimeException(error);\n }\n\n @Override\n public U fold(Function onError, Function onSuccess) {\n return onError.apply(error);\n }\n }\n\n static Result success(T value) {\n return new Success<>(value);\n }\n\n static Result failure(String error) {\n return new Failure<>(error);\n }\n}\n\npublic class SafePipeline {\n private final Function> function;\n\n private SafePipeline(Function> function) {\n this.function = function;\n }\n\n public static SafePipeline start() {\n return new SafePipeline<>(Result::success);\n }\n\n public SafePipeline then(Function> step) {\n return new SafePipeline<>(input ->\n function.apply(input).flatMap(step)\n );\n }\n\n public Result execute(I input) {\n return function.apply(input);\n }\n}\n\n// Usage\nSafePipeline pipeline = SafePipeline.start()\n .then(order -> {\n if (order.getItems().isEmpty()) {\n return Result.failure(\"Order has no items\");\n }\n return Result.success(new ValidatedOrder(order));\n })\n .then(order -> {\n if (!inventoryService.checkAvailability(order)) {\n return Result.failure(\"Items not in stock\");\n }\n return Result.success(new CheckedOrder(order));\n })\n .then(order -> {\n PaymentResult payment = paymentService.process(order);\n if (!payment.isSuccess()) {\n return Result.failure(\"Payment failed: \" + payment.getMessage());\n }\n return Result.success(new ProcessedOrder(order, payment));\n });\n\nResult result = pipeline.execute(rawOrder);\n\nString message = result.fold(\n error -> \"Order failed: \" + error,\n order -> \"Order confirmed: \" + order.getId()\n);\n```\n\n---\n\n## 🎤 Interview Questions\n\n### Q1: When use Chain of Responsibility vs simple if-else?\n\n**Answer:**\nUse Chain when:\n- Handlers are independent and reusable\n- Need to add/remove handlers at runtime\n- Different configurations need different chains\n- Handlers are in different modules/teams\n\nUse if-else when:\n- Logic is simple (2-3 cases)\n- Conditions are tightly coupled\n- No reuse needed\n\n### Q2: Difference between Chain of Responsibility and Pipeline?\n\n**Answer:**\n- **Chain**: Handler decides if it should process; request may be handled by 0, 1, or many handlers\n- **Pipeline**: All steps execute in sequence; transforms data step by step\n\nChain = \"who should handle this?\"\nPipeline = \"process this through all steps\"\n\n---\n\n## 📝 Summary\n\n| Pattern | Use When |\n|---------|----------|\n| Chain of Responsibility | Multiple potential handlers, one processes |\n| Pipeline | Sequential transformations |\n| Middleware | Request/response processing |\n| Validation Chain | Multiple validators, error accumulation |\n| Spring Interceptors | HTTP request processing |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review Chain vs Pipeline mental model | 5 min |\n| Day 3 | Redo Exercise 2 (Validation Pipeline) | 20 min |\n| Day 7 | Answer interview questions without looking | 10 min |\n| Day 14 | Redo Debug This (Broken Chain) | 15 min |\n| Day 30 | Identify one chain/pipeline opportunity in your codebase | 20 min |\n\n---\n\n*Next: [Part 13: Template Method & Hooks]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.779212Z","createdAt","2026-06-10T07:19:24.780367Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",17,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",12,"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},61,"Pipeline Pattern","pipeline-pattern",63,"Middleware","middleware",62,"Filters","filters",60,"Chain Of Responsibility","chain-of-responsibility",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]