[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":82,"_72":83,"_35":84},"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",19,"title","Fluent Validation","slug","clean-code-part-18-fluent-validation","excerpt","Build programmatic, builder-style validation for complex business rules with error accumulation and conditional logic beyond annotations.","# Advanced Clean Code Patterns Part 18: Fluent Validation\n\nWhile Bean Validation works well for simple constraints, complex business rules often need programmatic validation. Fluent validation provides a readable, composable approach for complex validation scenarios with better error accumulation and conditional logic.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Approach | Programmatic, builder-style validation |\n| Benefits | Readable, composable, conditional logic |\n| Best For | Complex business rules, cross-entity validation |\n| Libraries | Custom, or inspired by FluentValidation (.NET) |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Fluent validator** implementation\n- **Composable rules** with chaining\n- **Conditional validation** based on context\n- **Error accumulation** vs fail-fast\n- **Integration** with Bean Validation\n\n---\n\n## Production Story: The Complex Validation Rules\n\nAn insurance application had validation rules too complex for annotations:\n\n```java\n// ❌ Complex rules don't fit in annotations\n// - Driver under 25 AND sports car = higher premium validation\n// - Married discount only if spouse on same policy\n// - Multi-car discount requires 2+ cars, same household\n// - Good student discount requires age < 25 AND GPA > 3.0\n```\n\n**The fix:** Fluent validation:\n\n```java\n// ✅ Complex rules expressed clearly\nInsuranceValidator.forQuote(quote)\n .validateDriver(driver -> driver\n .hasValidLicense()\n .meetsAgeRequirement(18)\n .when(d -> d.getAge() < 25 && d.hasCarType(CarType.SPORTS),\n d -> d.requiresHighRiskAcknowledgment()))\n .validateVehicle(vehicle -> vehicle\n .isRegistered()\n .hasValidVIN()\n .meetsAgeLimit(20))\n .validateCoverage(coverage -> coverage\n .meetsMinimumLiability(stateRequirements)\n .when(c -> c.includesComprehensive(),\n c -> c.requiresDeductible(100, 2500)))\n .validate();\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Basic Fluent Validator\n\n```java\n// ✅ Fluent validator core\n\npublic class Validator {\n private final T target;\n private final List errors = new ArrayList<>();\n\n private Validator(T target) {\n this.target = target;\n }\n\n public static Validator of(T target) {\n return new Validator<>(target);\n }\n\n // Basic validation methods\n public Validator notNull(Function getter, String fieldName) {\n if (getter.apply(target) == null) {\n errors.add(new ValidationError(fieldName, \"must not be null\"));\n }\n return this;\n }\n\n public Validator notBlank(Function getter, String fieldName) {\n String value = getter.apply(target);\n if (value == null || value.isBlank()) {\n errors.add(new ValidationError(fieldName, \"must not be blank\"));\n }\n return this;\n }\n\n public Validator minLength(Function getter, int min, String fieldName) {\n String value = getter.apply(target);\n if (value != null && value.length() < min) {\n errors.add(new ValidationError(fieldName,\n String.format(\"must be at least %d characters\", min)));\n }\n return this;\n }\n\n public Validator maxLength(Function getter, int max, String fieldName) {\n String value = getter.apply(target);\n if (value != null && value.length() > max) {\n errors.add(new ValidationError(fieldName,\n String.format(\"must not exceed %d characters\", max)));\n }\n return this;\n }\n\n public Validator matches(Function getter, String regex,\n String fieldName, String message) {\n String value = getter.apply(target);\n if (value != null && !value.matches(regex)) {\n errors.add(new ValidationError(fieldName, message));\n }\n return this;\n }\n\n public Validator min(Function getter, long min, String fieldName) {\n Number value = getter.apply(target);\n if (value != null && value.longValue() < min) {\n errors.add(new ValidationError(fieldName,\n String.format(\"must be at least %d\", min)));\n }\n return this;\n }\n\n public Validator max(Function getter, long max, String fieldName) {\n Number value = getter.apply(target);\n if (value != null && value.longValue() > max) {\n errors.add(new ValidationError(fieldName,\n String.format(\"must not exceed %d\", max)));\n }\n return this;\n }\n\n public Validator positive(Function getter, String fieldName) {\n Number value = getter.apply(target);\n if (value != null && value.doubleValue() <= 0) {\n errors.add(new ValidationError(fieldName, \"must be positive\"));\n }\n return this;\n }\n\n // Custom rule\n public Validator satisfies(Predicate rule, String fieldName, String message) {\n if (!rule.test(target)) {\n errors.add(new ValidationError(fieldName, message));\n }\n return this;\n }\n\n // Conditional validation\n public Validator when(Predicate condition, Consumer> validation) {\n if (condition.test(target)) {\n validation.accept(this);\n }\n return this;\n }\n\n // Nested validation\n public Validator validate(Function getter, Consumer> validation) {\n N nested = getter.apply(target);\n if (nested != null) {\n Validator nestedValidator = Validator.of(nested);\n validation.accept(nestedValidator);\n errors.addAll(nestedValidator.errors);\n }\n return this;\n }\n\n // Collection validation\n public Validator validateEach(Function> getter,\n Consumer> validation) {\n Collection items = getter.apply(target);\n if (items != null) {\n int index = 0;\n for (E item : items) {\n Validator itemValidator = Validator.of(item);\n validation.accept(itemValidator);\n for (ValidationError error : itemValidator.errors) {\n errors.add(new ValidationError(\n String.format(\"[%d].%s\", index, error.field()),\n error.message()));\n }\n index++;\n }\n }\n return this;\n }\n\n // Result methods\n public List getErrors() {\n return List.copyOf(errors);\n }\n\n public boolean isValid() {\n return errors.isEmpty();\n }\n\n public void validate() throws ValidationException {\n if (!errors.isEmpty()) {\n throw new ValidationException(errors);\n }\n }\n\n public Result> toResult() {\n if (errors.isEmpty()) {\n return Result.success(target);\n }\n return Result.failure(errors);\n }\n}\n\npublic record ValidationError(String field, String message) {}\n```\n\n---\n\n### Pattern 2: Domain-Specific Validator\n\n```java\n// ✅ User registration validator\n\npublic class UserValidator {\n\n public static Validator forRegistration(UserRegistration user) {\n return Validator.of(user)\n .notBlank(UserRegistration::getEmail, \"email\")\n .matches(UserRegistration::getEmail,\n \"^[\\\\w.+-]+@[\\\\w.-]+\\\\.[a-z]{2,}$\", \"email\", \"must be valid email\")\n .notBlank(UserRegistration::getPassword, \"password\")\n .minLength(UserRegistration::getPassword, 8, \"password\")\n .satisfies(u -> hasUppercase(u.getPassword()), \"password\",\n \"must contain uppercase letter\")\n .satisfies(u -> hasLowercase(u.getPassword()), \"password\",\n \"must contain lowercase letter\")\n .satisfies(u -> hasDigit(u.getPassword()), \"password\",\n \"must contain digit\")\n .satisfies(u -> u.getPassword().equals(u.getConfirmPassword()),\n \"confirmPassword\", \"passwords must match\")\n .notBlank(UserRegistration::getName, \"name\")\n .minLength(UserRegistration::getName, 2, \"name\")\n .maxLength(UserRegistration::getName, 100, \"name\")\n .when(u -> u.getAge() != null,\n v -> v.min(UserRegistration::getAge, 18, \"age\"));\n }\n\n private static boolean hasUppercase(String s) {\n return s != null && s.chars().anyMatch(Character::isUpperCase);\n }\n\n private static boolean hasLowercase(String s) {\n return s != null && s.chars().anyMatch(Character::isLowerCase);\n }\n\n private static boolean hasDigit(String s) {\n return s != null && s.chars().anyMatch(Character::isDigit);\n }\n}\n\n// Usage\nUserValidator.forRegistration(request)\n .validate(); // Throws ValidationException if invalid\n\n// Or get result\nResult> result =\n UserValidator.forRegistration(request).toResult();\n```\n\n---\n\n### Pattern 3: Order Validator with Business Rules\n\n```java\n// ✅ Complex business validation\n\npublic class OrderValidator {\n\n private final InventoryService inventoryService;\n private final CustomerService customerService;\n private final PricingService pricingService;\n\n public OrderValidator(InventoryService inventoryService,\n CustomerService customerService,\n PricingService pricingService) {\n this.inventoryService = inventoryService;\n this.customerService = customerService;\n this.pricingService = pricingService;\n }\n\n public Validator forCreate(CreateOrderRequest request) {\n return Validator.of(request)\n // Basic validation\n .notNull(CreateOrderRequest::getCustomerId, \"customerId\")\n .notNull(CreateOrderRequest::getItems, \"items\")\n .satisfies(r -> r.getItems() != null && !r.getItems().isEmpty(),\n \"items\", \"must not be empty\")\n\n // Validate customer exists and is active\n .satisfies(r -> customerExists(r.getCustomerId()),\n \"customerId\", \"customer not found\")\n .satisfies(r -> customerIsActive(r.getCustomerId()),\n \"customerId\", \"customer account is inactive\")\n\n // Validate each item\n .validateEach(CreateOrderRequest::getItems, this::validateItem)\n\n // Cross-field validation\n .when(r -> r.getShippingMethod() == ShippingMethod.EXPRESS,\n v -> v.satisfies(r -> r.getItems().size() <= 10,\n \"items\", \"express shipping limited to 10 items\"))\n\n // Business rules\n .satisfies(r -> totalWithinLimit(r),\n \"total\", \"order exceeds maximum allowed amount\")\n\n .when(r -> r.getDiscountCode() != null,\n v -> v.satisfies(r -> isValidDiscount(r.getDiscountCode(), r.getCustomerId()),\n \"discountCode\", \"invalid or expired discount code\"));\n }\n\n private void validateItem(Validator v) {\n v.notNull(OrderItemRequest::getProductId, \"productId\")\n .min(OrderItemRequest::getQuantity, 1, \"quantity\")\n .max(OrderItemRequest::getQuantity, 100, \"quantity\")\n .satisfies(item -> productExists(item.getProductId()),\n \"productId\", \"product not found\")\n .satisfies(item -> hasInventory(item.getProductId(), item.getQuantity()),\n \"quantity\", \"insufficient inventory\");\n }\n\n private boolean customerExists(Long customerId) {\n return customerService.exists(customerId);\n }\n\n private boolean customerIsActive(Long customerId) {\n return customerService.findById(customerId)\n .map(Customer::isActive)\n .orElse(false);\n }\n\n private boolean productExists(Long productId) {\n return inventoryService.productExists(productId);\n }\n\n private boolean hasInventory(Long productId, int quantity) {\n return inventoryService.getAvailable(productId) >= quantity;\n }\n\n private boolean totalWithinLimit(CreateOrderRequest request) {\n BigDecimal total = pricingService.calculateTotal(request);\n return total.compareTo(new BigDecimal(\"50000\")) <= 0;\n }\n\n private boolean isValidDiscount(String code, Long customerId) {\n return pricingService.isValidDiscount(code, customerId);\n }\n}\n\n// Usage with dependency injection\n@Service\npublic class OrderService {\n\n private final OrderValidator validator;\n private final OrderRepository repository;\n\n public Order createOrder(CreateOrderRequest request) {\n validator.forCreate(request).validate();\n return repository.save(mapToOrder(request));\n }\n}\n```\n\n---\n\n### Pattern 4: Validation Rules Builder\n\n```java\n// ✅ Reusable validation rules\n\npublic class ValidationRules {\n\n // Email rules\n public static Consumer> email(\n Function getter, String field) {\n return v -> v\n .notBlank(getter, field)\n .matches(getter, \"^[\\\\w.+-]+@[\\\\w.-]+\\\\.[a-z]{2,}$\",\n field, \"must be a valid email address\");\n }\n\n // Phone rules\n public static Consumer> phone(\n Function getter, String field) {\n return v -> v\n .matches(getter, \"^\\\\+?[1-9]\\\\d{1,14}$\",\n field, \"must be a valid phone number\");\n }\n\n // Money rules\n public static Consumer> money(\n Function getter, String field) {\n return v -> v\n .notNull(getter, field)\n .positive(getter, field)\n .satisfies(t -> {\n BigDecimal value = getter.apply(t);\n return value == null || value.scale() <= 2;\n }, field, \"must have at most 2 decimal places\");\n }\n\n // Date range rules\n public static Consumer> dateRange(\n Function startGetter,\n Function endGetter,\n String startField, String endField) {\n return v -> v\n .notNull(startGetter, startField)\n .notNull(endGetter, endField)\n .satisfies(t -> {\n LocalDate start = startGetter.apply(t);\n LocalDate end = endGetter.apply(t);\n return start == null || end == null || !end.isBefore(start);\n }, endField, \"must be after \" + startField);\n }\n\n // Password rules\n public static Consumer> strongPassword(\n Function getter, String field) {\n return v -> v\n .notBlank(getter, field)\n .minLength(getter, 8, field)\n .satisfies(t -> containsUppercase(getter.apply(t)),\n field, \"must contain uppercase letter\")\n .satisfies(t -> containsLowercase(getter.apply(t)),\n field, \"must contain lowercase letter\")\n .satisfies(t -> containsDigit(getter.apply(t)),\n field, \"must contain digit\")\n .satisfies(t -> containsSpecial(getter.apply(t)),\n field, \"must contain special character\");\n }\n\n private static boolean containsUppercase(String s) {\n return s != null && s.chars().anyMatch(Character::isUpperCase);\n }\n\n private static boolean containsLowercase(String s) {\n return s != null && s.chars().anyMatch(Character::isLowerCase);\n }\n\n private static boolean containsDigit(String s) {\n return s != null && s.chars().anyMatch(Character::isDigit);\n }\n\n private static boolean containsSpecial(String s) {\n return s != null && s.matches(\".*[!@#$%^&*(),.?\\\":{}|<>].*\");\n }\n}\n\n// Usage with rules\npublic class BookingValidator {\n\n public static Validator validate(BookingRequest request) {\n return Validator.of(request)\n .apply(ValidationRules.email(BookingRequest::getEmail, \"email\"))\n .apply(ValidationRules.phone(BookingRequest::getPhone, \"phone\"))\n .apply(ValidationRules.dateRange(\n BookingRequest::getCheckIn,\n BookingRequest::getCheckOut,\n \"checkIn\", \"checkOut\"))\n .apply(ValidationRules.money(BookingRequest::getDeposit, \"deposit\"));\n }\n}\n\n// Add apply method to Validator\npublic Validator apply(Consumer> rules) {\n rules.accept(this);\n return this;\n}\n```\n\n---\n\n### Pattern 5: Async Validation\n\n```java\n// ✅ Validation with async checks\n\npublic class AsyncValidator {\n private final T target;\n private final List>> asyncChecks = new ArrayList<>();\n private final List syncErrors = new ArrayList<>();\n\n public static AsyncValidator of(T target) {\n return new AsyncValidator<>(target);\n }\n\n // Sync validations\n public AsyncValidator notNull(Function getter, String field) {\n if (getter.apply(target) == null) {\n syncErrors.add(new ValidationError(field, \"must not be null\"));\n }\n return this;\n }\n\n // Async validations\n public AsyncValidator checkAsync(\n Function> check,\n String field, String message) {\n\n CompletableFuture> future = check.apply(target)\n .thenApply(valid -> valid\n ? List.of()\n : List.of(new ValidationError(field, message)));\n asyncChecks.add(future);\n return this;\n }\n\n public CompletableFuture> validateAsync() {\n return CompletableFuture.allOf(\n asyncChecks.toArray(CompletableFuture[]::new))\n .thenApply(v -> {\n List allErrors = new ArrayList<>(syncErrors);\n for (CompletableFuture> future : asyncChecks) {\n allErrors.addAll(future.join());\n }\n return allErrors;\n });\n }\n}\n\n// Usage\n@Service\npublic class UserService {\n\n private final UserRepository userRepository;\n\n public CompletableFuture registerAsync(UserRegistration request) {\n return AsyncValidator.of(request)\n .notNull(UserRegistration::getEmail, \"email\")\n .notNull(UserRegistration::getPassword, \"password\")\n .checkAsync(\n r -> userRepository.existsByEmailAsync(r.getEmail())\n .thenApply(exists -> !exists),\n \"email\", \"already registered\")\n .checkAsync(\n r -> blacklistService.isBlacklistedAsync(r.getEmail())\n .thenApply(blacklisted -> !blacklisted),\n \"email\", \"email domain not allowed\")\n .validateAsync()\n .thenCompose(errors -> {\n if (!errors.isEmpty()) {\n return CompletableFuture.failedFuture(\n new ValidationException(errors));\n }\n return createUserAsync(request);\n });\n }\n}\n```\n\n---\n\n### Pattern 6: Integration with Bean Validation\n\n```java\n// ✅ Combine Bean Validation with fluent validation\n\n@Service\npublic class OrderValidationService {\n\n private final jakarta.validation.Validator beanValidator;\n private final InventoryService inventoryService;\n\n public void validate(CreateOrderRequest request) {\n // First, run Bean Validation\n Set> violations =\n beanValidator.validate(request);\n\n if (!violations.isEmpty()) {\n List errors = violations.stream()\n .map(v -> new ValidationError(\n v.getPropertyPath().toString(),\n v.getMessage()))\n .toList();\n throw new ValidationException(errors);\n }\n\n // Then, run business validation\n Validator.of(request)\n .validateEach(CreateOrderRequest::getItems, item -> item\n .satisfies(i -> inventoryService.hasStock(i.getProductId(), i.getQuantity()),\n \"quantity\", \"insufficient inventory\"))\n .satisfies(r -> validateBusinessRules(r),\n \"order\", \"business validation failed\")\n .validate();\n }\n}\n\n// Or create a combined validator\npublic class CombinedValidator {\n\n private final jakarta.validation.Validator beanValidator;\n private final Validator fluentValidator;\n\n public List validate(T target) {\n List errors = new ArrayList<>();\n\n // Bean Validation errors\n Set> violations = beanValidator.validate(target);\n violations.forEach(v -> errors.add(new ValidationError(\n v.getPropertyPath().toString(),\n v.getMessage())));\n\n // Fluent validation errors\n errors.addAll(fluentValidator.getErrors());\n\n return errors;\n }\n}\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Not Accumulating All Errors\n\n```java\n// ❌ Fail-fast - only shows first error\npublic void validate(User user) {\n if (user.getEmail() == null) throw new ValidationException(\"email required\");\n if (user.getName() == null) throw new ValidationException(\"name required\");\n}\n\n// ✅ Accumulate all errors\npublic List validate(User user) {\n return Validator.of(user)\n .notNull(User::getEmail, \"email\")\n .notNull(User::getName, \"name\")\n .getErrors(); // Returns all errors at once\n}\n```\n\n### Mistake 2: Validation with Side Effects\n\n```java\n// ❌ Side effects in validation\nvalidator.satisfies(order -> {\n inventoryService.reserve(order.getItems()); // Side effect!\n return true;\n}, \"items\", \"reservation failed\");\n\n// ✅ Validation should be read-only\nvalidator.satisfies(order ->\n inventoryService.canReserve(order.getItems()), // Read-only check\n \"items\", \"insufficient inventory\");\n```\n\n---\n\n## 🐛 Debug This: The Premature Exit\n\nA developer reports: \"Our fluent validator only returns the first error even though we're supposed to accumulate all of them!\"\n\n```java\npublic class OrderValidator {\n\n public List validate(CreateOrderRequest request) {\n List errors = new ArrayList<>();\n\n // BUG: Early returns prevent error accumulation!\n if (request.getCustomerId() == null) {\n errors.add(new ValidationError(\"customerId\", \"required\"));\n return errors; // Returns early with just 1 error\n }\n\n if (request.getItems() == null || request.getItems().isEmpty()) {\n errors.add(new ValidationError(\"items\", \"required\"));\n return errors; // Returns early with just 1 error\n }\n\n for (OrderItem item : request.getItems()) {\n if (item.getQuantity() <= 0) {\n errors.add(new ValidationError(\"quantity\", \"must be positive\"));\n return errors; // Returns early!\n }\n }\n\n return errors; // Only reaches here if everything is valid\n }\n}\n\n// Test:\n// Request with null customerId, empty items, and invalid quantity\n// Expected: 3 errors\n// Actual: 1 error (customerId required)\n```\n\n**Why does only one error get returned?**\n\n---\n\n**✅ Solution:**\n\nThe bug is the multiple `return errors;` statements that exit early after each validation check. This is a fail-fast approach, but the intent was error accumulation.\n\n**The fix - remove early returns:**\n\n```java\npublic class OrderValidator {\n\n public List validate(CreateOrderRequest request) {\n List errors = new ArrayList<>();\n\n // Check all fields, don't return early\n if (request.getCustomerId() == null) {\n errors.add(new ValidationError(\"customerId\", \"required\"));\n }\n\n if (request.getItems() == null || request.getItems().isEmpty()) {\n errors.add(new ValidationError(\"items\", \"required\"));\n } else {\n // Only validate items if they exist\n for (int i = 0; i < request.getItems().size(); i++) {\n OrderItem item = request.getItems().get(i);\n if (item.getQuantity() <= 0) {\n errors.add(new ValidationError(\n \"items[\" + i + \"].quantity\", \"must be positive\"));\n }\n }\n }\n\n return errors; // Return ALL accumulated errors\n }\n}\n```\n\n**Even better - use fluent validator:**\n\n```java\npublic List validate(CreateOrderRequest request) {\n return Validator.of(request)\n .notNull(CreateOrderRequest::getCustomerId, \"customerId\")\n .satisfies(r -> r.getItems() != null && !r.getItems().isEmpty(),\n \"items\", \"required\")\n .validateEach(CreateOrderRequest::getItems, item ->\n item.positive(OrderItem::getQuantity, \"quantity\"))\n .getErrors(); // Accumulates all errors automatically\n}\n```\n\n**The lesson:** Error accumulation requires checking all rules without early exits. Fluent validation naturally handles this pattern.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Basic Fluent Validator\n⭐ Difficulty: Easy | ⏱️ Time: 15 minutes\n\n**Task:** Create a simple fluent validator with basic methods.\n\n```java\n// Implement Validator with:\n// - notNull(getter, fieldName)\n// - notBlank(getter, fieldName)\n// - min(getter, minValue, fieldName)\n// - getErrors() and isValid()\n```\n\n**✅ Solution:**\n\n```java\npublic class Validator {\n private final T target;\n private final List errors = new ArrayList<>();\n\n private Validator(T target) {\n this.target = target;\n }\n\n public static Validator of(T target) {\n return new Validator<>(target);\n }\n\n public Validator notNull(Function getter, String field) {\n if (getter.apply(target) == null) {\n errors.add(new ValidationError(field, \"must not be null\"));\n }\n return this;\n }\n\n public Validator notBlank(Function getter, String field) {\n String value = getter.apply(target);\n if (value == null || value.isBlank()) {\n errors.add(new ValidationError(field, \"must not be blank\"));\n }\n return this;\n }\n\n public Validator min(Function getter,\n long minValue, String field) {\n Number value = getter.apply(target);\n if (value != null && value.longValue() < minValue) {\n errors.add(new ValidationError(field,\n \"must be at least \" + minValue));\n }\n return this;\n }\n\n public List getErrors() {\n return List.copyOf(errors);\n }\n\n public boolean isValid() {\n return errors.isEmpty();\n }\n\n public void validate() throws ValidationException {\n if (!errors.isEmpty()) {\n throw new ValidationException(errors);\n }\n }\n}\n\npublic record ValidationError(String field, String message) {}\n\n// Usage\nList errors = Validator.of(user)\n .notNull(User::getId, \"id\")\n .notBlank(User::getName, \"name\")\n .min(User::getAge, 18, \"age\")\n .getErrors();\n```\n\n---\n\n### Exercise 2: Conditional Validation\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Add conditional validation to the fluent validator.\n\n```java\n// Add when() method that:\n// - Takes a condition predicate\n// - Runs additional validations only if condition is true\n\n// Example usage:\nValidator.of(order)\n .notNull(Order::getItems, \"items\")\n .when(o -> o.getShippingMethod() == EXPRESS,\n v -> v.min(Order::getTotal, 50, \"total\"))\n```\n\n**✅ Solution:**\n\n```java\npublic Validator when(Predicate condition,\n Consumer> validations) {\n if (condition.test(target)) {\n validations.accept(this);\n }\n return this;\n}\n\n// Also add unless (opposite of when)\npublic Validator unless(Predicate condition,\n Consumer> validations) {\n if (!condition.test(target)) {\n validations.accept(this);\n }\n return this;\n}\n\n// Usage examples\nValidator.of(order)\n .notNull(Order::getItems, \"items\")\n // Only validate shipping address for physical products\n .when(o -> o.getType() == ProductType.PHYSICAL,\n v -> v.notNull(Order::getShippingAddress, \"shippingAddress\"))\n // Express shipping has minimum order\n .when(o -> o.getShippingMethod() == ShippingMethod.EXPRESS,\n v -> v.min(Order::getTotal, 50, \"total\")\n .satisfies(o -> o.getItems().size() <= 10,\n \"items\", \"express limited to 10 items\"))\n // Free shipping for orders over $100\n .when(o -> o.getTotal().compareTo(new BigDecimal(\"100\")) >= 0,\n v -> v.satisfies(o -> o.getShippingFee().equals(BigDecimal.ZERO),\n \"shippingFee\", \"should be free for orders over $100\"))\n .validate();\n```\n\n---\n\n### Exercise 3: Nested Object Validation\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Add support for validating nested objects and collections.\n\n```java\n// Add methods:\n// - validate(getter, Consumer>) for nested objects\n// - validateEach(getter, Consumer>) for collections\n```\n\n**✅ Solution:**\n\n```java\n// Validate nested object\npublic Validator validate(Function getter,\n Consumer> validation) {\n N nested = getter.apply(target);\n if (nested != null) {\n Validator nestedValidator = Validator.of(nested);\n validation.accept(nestedValidator);\n errors.addAll(nestedValidator.errors);\n }\n return this;\n}\n\n// Validate with field prefix\npublic Validator validate(Function getter,\n String prefix,\n Consumer> validation) {\n N nested = getter.apply(target);\n if (nested != null) {\n Validator nestedValidator = Validator.of(nested);\n validation.accept(nestedValidator);\n for (ValidationError error : nestedValidator.errors) {\n errors.add(new ValidationError(\n prefix + \".\" + error.field(),\n error.message()));\n }\n }\n return this;\n}\n\n// Validate each item in collection\npublic Validator validateEach(Function> getter,\n Consumer> validation) {\n Collection items = getter.apply(target);\n if (items != null) {\n int index = 0;\n for (E item : items) {\n Validator itemValidator = Validator.of(item);\n validation.accept(itemValidator);\n for (ValidationError error : itemValidator.errors) {\n errors.add(new ValidationError(\n String.format(\"[%d].%s\", index, error.field()),\n error.message()));\n }\n index++;\n }\n }\n return this;\n}\n\n// Usage\nValidator.of(order)\n .notNull(Order::getCustomerId, \"customerId\")\n // Validate nested address\n .validate(Order::getShippingAddress, \"shippingAddress\", addr -> addr\n .notBlank(Address::getStreet, \"street\")\n .notBlank(Address::getCity, \"city\")\n .notBlank(Address::getZipCode, \"zipCode\"))\n // Validate each item\n .validateEach(Order::getItems, item -> item\n .notNull(OrderItem::getProductId, \"productId\")\n .min(OrderItem::getQuantity, 1, \"quantity\")\n .max(OrderItem::getQuantity, 100, \"quantity\"))\n .validate();\n```\n\n---\n\n### Exercise 4: Reusable Validation Rules\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Create composable, reusable validation rules.\n\n```java\n// Create ValidationRules class with:\n// - email(), phone(), money() rule builders\n// - Add apply() method to Validator to use these rules\n```\n\n**✅ Solution:**\n\n```java\npublic class ValidationRules {\n\n // Email validation rule\n public static Consumer> email(\n Function getter, String field) {\n return v -> v\n .notBlank(getter, field)\n .matches(getter, \"^[\\\\w.+-]+@[\\\\w.-]+\\\\.[a-z]{2,}$\",\n field, \"must be a valid email\");\n }\n\n // Phone validation rule\n public static Consumer> phone(\n Function getter, String field) {\n return v -> v\n .matches(getter, \"^\\\\+?[1-9]\\\\d{1,14}$\",\n field, \"must be a valid phone number\");\n }\n\n // Money validation rule\n public static Consumer> money(\n Function getter, String field) {\n return v -> v\n .notNull(getter, field)\n .positive(getter, field)\n .satisfies(t -> {\n BigDecimal value = getter.apply(t);\n return value == null || value.scale() <= 2;\n }, field, \"must have at most 2 decimal places\");\n }\n\n // Strong password rule\n public static Consumer> strongPassword(\n Function getter, String field) {\n return v -> v\n .notBlank(getter, field)\n .minLength(getter, 8, field)\n .satisfies(t -> containsPattern(getter.apply(t), \"[A-Z]\"),\n field, \"must contain uppercase\")\n .satisfies(t -> containsPattern(getter.apply(t), \"[a-z]\"),\n field, \"must contain lowercase\")\n .satisfies(t -> containsPattern(getter.apply(t), \"\\\\d\"),\n field, \"must contain digit\");\n }\n\n private static boolean containsPattern(String s, String pattern) {\n return s != null && s.matches(\".*\" + pattern + \".*\");\n }\n}\n\n// Add apply method to Validator\npublic Validator apply(Consumer> rule) {\n rule.accept(this);\n return this;\n}\n\n// Usage\nValidator.of(registration)\n .apply(ValidationRules.email(Registration::getEmail, \"email\"))\n .apply(ValidationRules.phone(Registration::getPhone, \"phone\"))\n .apply(ValidationRules.strongPassword(Registration::getPassword, \"password\"))\n .validate();\n\n// Or combine rules\nConsumer> allRules = v -> {\n ValidationRules.email(Registration::getEmail, \"email\").accept(v);\n ValidationRules.phone(Registration::getPhone, \"phone\").accept(v);\n};\n\nValidator.of(registration)\n .apply(allRules)\n .validate();\n```\n\n---\n\n### Exercise 5: Validation with Result Type\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Integrate fluent validation with the Result pattern.\n\n```java\n// Create ValidatingResult that:\n// - Accumulates validation errors\n// - Returns Result>\n// - Supports chaining with map/flatMap\n```\n\n**✅ Solution:**\n\n```java\npublic class ValidatingResult {\n private final T value;\n private final List errors;\n\n private ValidatingResult(T value, List errors) {\n this.value = value;\n this.errors = List.copyOf(errors);\n }\n\n public static ValidatingResult of(T value) {\n return new ValidatingResult<>(value, List.of());\n }\n\n public static ValidatingResult invalid(List errors) {\n return new ValidatingResult<>(null, errors);\n }\n\n // Validation methods\n public ValidatingResult validate(Consumer> validation) {\n if (!errors.isEmpty()) {\n return this; // Already invalid, skip\n }\n\n Validator validator = Validator.of(value);\n validation.accept(validator);\n\n if (validator.isValid()) {\n return this;\n }\n\n List allErrors = new ArrayList<>(errors);\n allErrors.addAll(validator.getErrors());\n return new ValidatingResult<>(value, allErrors);\n }\n\n // Transform value if valid\n public ValidatingResult map(Function mapper) {\n if (!errors.isEmpty()) {\n return new ValidatingResult<>(null, errors);\n }\n return new ValidatingResult<>(mapper.apply(value), List.of());\n }\n\n // Chain validation with transformation\n public ValidatingResult flatMap(\n Function> mapper) {\n if (!errors.isEmpty()) {\n return new ValidatingResult<>(null, errors);\n }\n return mapper.apply(value);\n }\n\n // Convert to Result\n public Result> toResult() {\n if (errors.isEmpty()) {\n return Result.success(value);\n }\n return Result.failure(errors);\n }\n\n // Get value if valid\n public Optional getValue() {\n return errors.isEmpty() ? Optional.ofNullable(value) : Optional.empty();\n }\n\n public List getErrors() {\n return errors;\n }\n\n public boolean isValid() {\n return errors.isEmpty();\n }\n}\n\n// Service using ValidatingResult\npublic class UserService {\n\n public Result> register(\n RegistrationRequest request) {\n\n return ValidatingResult.of(request)\n // Validate request\n .validate(v -> v\n .notBlank(RegistrationRequest::getEmail, \"email\")\n .notBlank(RegistrationRequest::getPassword, \"password\")\n .notBlank(RegistrationRequest::getName, \"name\"))\n // Transform to user\n .map(req -> new User(\n req.getEmail(),\n req.getName(),\n hashPassword(req.getPassword())))\n // Validate user entity\n .validate(v -> v\n .satisfies(u -> !userRepository.existsByEmail(u.getEmail()),\n \"email\", \"already registered\"))\n // Convert to Result\n .toResult();\n }\n}\n\n// Usage in controller\n@PostMapping(\"/register\")\npublic ResponseEntity register(@RequestBody RegistrationRequest request) {\n return userService.register(request)\n .map(user -> ResponseEntity.status(201).body(user))\n .getOrElseGet(errors -> ResponseEntity.badRequest()\n .body(new ValidationErrorResponse(errors)));\n}\n```\n\n---\n\n## 📝 Summary\n\n| Approach | Use When |\n|----------|----------|\n| Bean Validation | Simple constraints, standard validation |\n| Fluent Validation | Complex rules, conditional logic, readability |\n| Combined | Bean for simple, fluent for business rules |\n| Async Validation | Database checks, external service validation |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review fluent vs bean validation decision table | 5 min |\n| Day 3 | Redo Exercise 1 (Basic Fluent Validator) | 15 min |\n| Day 7 | Redo Exercise 3 (Nested Object Validation) | 20 min |\n| Day 14 | Redo Debug This (Premature Exit) | 15 min |\n| Day 30 | Identify complex validation in your codebase to refactor | 20 min |\n\n---\n\n*Next: [Part 19: Understanding Legacy Code]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.866383Z","createdAt","2026-06-10T07:19:24.867104Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",16,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",18,"author",{"_31":55,"_97":57,"_98":99,"_100":101,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5},"category",{"_31":93,"_72":59,"_35":94,"_75":95,"_96":-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":90,"_72":91,"_35":92},{"_31":87,"_72":88,"_35":89},{"_31":85,"_72":34,"_35":86},{"_31":82,"_72":83,"_35":84},85,"Validation Dsl","validation-dsl",84,"fluent-validation",86,"Custom Validators","custom-validators",87,"Composable Validation","composable-validation",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]