[{"_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",18,"title","Bean Validation","slug","clean-code-part-17-bean-validation","excerpt","Master Jakarta Bean Validation: built-in constraints, custom validators, validation groups, and Spring Boot integration for declarative validation.","# Advanced Clean Code Patterns Part 17: Bean Validation\n\nJakarta Bean Validation (formerly JSR-380) provides a declarative way to validate objects using annotations. This article covers built-in constraints, custom validators, groups, and integration with Spring Boot.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Specification | Jakarta Bean Validation 3.0 |\n| Implementation | Hibernate Validator |\n| Dependency | spring-boot-starter-validation |\n| Scope | DTOs, entities, method parameters |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Built-in constraints** and when to use them\n- **Custom validators** for business rules\n- **Validation groups** for context-specific validation\n- **Cross-field validation** for complex rules\n- **Spring integration** with @Valid and @Validated\n\n---\n\n## Production Story: The Manual Validation Nightmare\n\nA registration service had validation scattered everywhere:\n\n```java\n// ❌ Manual validation - error-prone, inconsistent\npublic User register(RegistrationRequest request) {\n if (request.getEmail() == null || request.getEmail().isEmpty()) {\n throw new ValidationException(\"Email required\");\n }\n if (!request.getEmail().matches(\"^[\\\\w.+-]+@[\\\\w.-]+\\\\.[a-z]{2,}$\")) {\n throw new ValidationException(\"Invalid email\");\n }\n if (request.getPassword() == null || request.getPassword().length() < 8) {\n throw new ValidationException(\"Password too short\");\n }\n // 50 more lines of validation...\n}\n```\n\n**Problems:**\n- Validation logic duplicated across endpoints\n- Inconsistent error messages\n- Easy to forget validation in new code\n- Hard to test\n- Business logic mixed with validation\n\n**The fix:** Bean Validation annotations:\n\n```java\n// ✅ Declarative validation\npublic record RegistrationRequest(\n @NotBlank(message = \"Email required\")\n @Email(message = \"Invalid email format\")\n String email,\n\n @NotBlank(message = \"Password required\")\n @Size(min = 8, message = \"Password must be at least 8 characters\")\n @Pattern(regexp = \".*[A-Z].*\", message = \"Must contain uppercase\")\n String password,\n\n @NotBlank @Size(min = 2, max = 50)\n String name\n) {}\n\n// Controller - just add @Valid\n@PostMapping(\"/register\")\npublic User register(@Valid @RequestBody RegistrationRequest request) {\n return userService.register(request);\n}\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Built-in Constraints\n\n```java\n// ✅ Common built-in constraints\n\npublic class OrderRequest {\n\n // Null checks\n @NotNull(message = \"Customer ID required\")\n private Long customerId;\n\n @NotBlank(message = \"Description cannot be blank\") // Not null + not empty + not whitespace\n private String description;\n\n @NotEmpty(message = \"Items cannot be empty\") // Not null + not empty (works for collections)\n private List items;\n\n // Size constraints\n @Size(min = 2, max = 100, message = \"Name must be 2-100 characters\")\n private String name;\n\n @Size(min = 1, max = 50, message = \"Order must have 1-50 items\")\n private List items;\n\n // Numeric constraints\n @Min(value = 1, message = \"Quantity must be at least 1\")\n @Max(value = 1000, message = \"Quantity cannot exceed 1000\")\n private Integer quantity;\n\n @Positive(message = \"Price must be positive\")\n private BigDecimal price;\n\n @PositiveOrZero(message = \"Discount cannot be negative\")\n private BigDecimal discount;\n\n @DecimalMin(value = \"0.01\", message = \"Minimum order is $0.01\")\n @DecimalMax(value = \"10000.00\", message = \"Maximum order is $10,000\")\n private BigDecimal total;\n\n @Digits(integer = 10, fraction = 2, message = \"Invalid currency format\")\n private BigDecimal amount;\n\n // String patterns\n @Email(message = \"Invalid email\")\n private String email;\n\n @Pattern(regexp = \"^\\\\+?[1-9]\\\\d{1,14}$\", message = \"Invalid phone number\")\n private String phone;\n\n @Pattern(regexp = \"^[A-Z]{2}\\\\d{6}$\", message = \"Invalid reference number\")\n private String referenceNumber;\n\n // Date/Time constraints\n @Past(message = \"Birth date must be in the past\")\n private LocalDate birthDate;\n\n @PastOrPresent(message = \"Cannot be in the future\")\n private LocalDateTime createdAt;\n\n @Future(message = \"Delivery date must be in the future\")\n private LocalDate deliveryDate;\n\n @FutureOrPresent(message = \"Start date cannot be in the past\")\n private LocalDate startDate;\n\n // Boolean\n @AssertTrue(message = \"Must accept terms and conditions\")\n private Boolean acceptedTerms;\n\n @AssertFalse(message = \"Cannot be a demo account\")\n private Boolean isDemoAccount;\n}\n```\n\n---\n\n### Pattern 2: Nested Validation\n\n```java\n// ✅ Validate nested objects with @Valid\n\npublic class OrderRequest {\n\n @NotNull\n @Valid // Cascade validation to nested object\n private CustomerInfo customer;\n\n @NotEmpty\n @Valid // Validate each item in collection\n private List items;\n\n @Valid // Optional but validated if present\n private ShippingAddress shippingAddress;\n}\n\npublic class CustomerInfo {\n @NotBlank\n private String name;\n\n @NotBlank\n @Email\n private String email;\n}\n\npublic class OrderItemRequest {\n @NotNull\n private Long productId;\n\n @Min(1) @Max(100)\n private Integer quantity;\n}\n\npublic class ShippingAddress {\n @NotBlank\n private String street;\n\n @NotBlank\n private String city;\n\n @Pattern(regexp = \"\\\\d{5}(-\\\\d{4})?\")\n private String zipCode;\n}\n```\n\n---\n\n### Pattern 3: Custom Validators\n\n```java\n// ✅ Custom constraint annotation\n\n@Target({ElementType.FIELD, ElementType.PARAMETER})\n@Retention(RetentionPolicy.RUNTIME)\n@Constraint(validatedBy = ValidPasswordValidator.class)\n@Documented\npublic @interface ValidPassword {\n String message() default \"Invalid password\";\n Class[] groups() default {};\n Class[] payload() default {};\n\n int minLength() default 8;\n boolean requireUppercase() default true;\n boolean requireLowercase() default true;\n boolean requireDigit() default true;\n boolean requireSpecial() default false;\n}\n\n// Validator implementation\npublic class ValidPasswordValidator implements ConstraintValidator {\n\n private int minLength;\n private boolean requireUppercase;\n private boolean requireLowercase;\n private boolean requireDigit;\n private boolean requireSpecial;\n\n @Override\n public void initialize(ValidPassword annotation) {\n this.minLength = annotation.minLength();\n this.requireUppercase = annotation.requireUppercase();\n this.requireLowercase = annotation.requireLowercase();\n this.requireDigit = annotation.requireDigit();\n this.requireSpecial = annotation.requireSpecial();\n }\n\n @Override\n public boolean isValid(String password, ConstraintValidatorContext context) {\n if (password == null) {\n return true; // Let @NotNull handle null check\n }\n\n List violations = new ArrayList<>();\n\n if (password.length() < minLength) {\n violations.add(\"at least \" + minLength + \" characters\");\n }\n if (requireUppercase && !password.matches(\".*[A-Z].*\")) {\n violations.add(\"an uppercase letter\");\n }\n if (requireLowercase && !password.matches(\".*[a-z].*\")) {\n violations.add(\"a lowercase letter\");\n }\n if (requireDigit && !password.matches(\".*\\\\d.*\")) {\n violations.add(\"a digit\");\n }\n if (requireSpecial && !password.matches(\".*[!@#$%^&*(),.?\\\":{}|<>].*\")) {\n violations.add(\"a special character\");\n }\n\n if (!violations.isEmpty()) {\n context.disableDefaultConstraintViolation();\n context.buildConstraintViolationWithTemplate(\n \"Password must contain: \" + String.join(\", \", violations))\n .addConstraintViolation();\n return false;\n }\n\n return true;\n }\n}\n\n// Usage\npublic class RegistrationRequest {\n @NotBlank\n @ValidPassword(minLength = 10, requireSpecial = true)\n private String password;\n}\n```\n\n---\n\n### Pattern 4: Cross-Field Validation\n\n```java\n// ✅ Class-level constraint for cross-field validation\n\n@Target(ElementType.TYPE)\n@Retention(RetentionPolicy.RUNTIME)\n@Constraint(validatedBy = PasswordMatchValidator.class)\npublic @interface PasswordMatch {\n String message() default \"Passwords do not match\";\n Class[] groups() default {};\n Class[] payload() default {};\n\n String passwordField() default \"password\";\n String confirmField() default \"confirmPassword\";\n}\n\npublic class PasswordMatchValidator\n implements ConstraintValidator {\n\n private String passwordField;\n private String confirmField;\n\n @Override\n public void initialize(PasswordMatch annotation) {\n this.passwordField = annotation.passwordField();\n this.confirmField = annotation.confirmField();\n }\n\n @Override\n public boolean isValid(Object obj, ConstraintValidatorContext context) {\n try {\n Object password = getFieldValue(obj, passwordField);\n Object confirm = getFieldValue(obj, confirmField);\n\n boolean valid = Objects.equals(password, confirm);\n\n if (!valid) {\n context.disableDefaultConstraintViolation();\n context.buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate())\n .addPropertyNode(confirmField)\n .addConstraintViolation();\n }\n\n return valid;\n } catch (Exception e) {\n return false;\n }\n }\n\n private Object getFieldValue(Object obj, String fieldName) throws Exception {\n Field field = obj.getClass().getDeclaredField(fieldName);\n field.setAccessible(true);\n return field.get(obj);\n }\n}\n\n// Usage\n@PasswordMatch\npublic class ChangePasswordRequest {\n @NotBlank\n private String currentPassword;\n\n @NotBlank\n @ValidPassword\n private String password;\n\n @NotBlank\n private String confirmPassword;\n}\n\n// ✅ Date range validation\n@Target(ElementType.TYPE)\n@Retention(RetentionPolicy.RUNTIME)\n@Constraint(validatedBy = ValidDateRangeValidator.class)\npublic @interface ValidDateRange {\n String message() default \"End date must be after start date\";\n Class[] groups() default {};\n Class[] payload() default {};\n\n String startField();\n String endField();\n}\n\n@ValidDateRange(startField = \"startDate\", endField = \"endDate\")\npublic class ReportRequest {\n @NotNull\n @PastOrPresent\n private LocalDate startDate;\n\n @NotNull\n private LocalDate endDate;\n}\n```\n\n---\n\n### Pattern 5: Validation Groups\n\n```java\n// ✅ Different validation rules for different contexts\n\n// Define groups\npublic interface ValidationGroups {\n interface Create {}\n interface Update {}\n interface Patch {}\n}\n\npublic class UserRequest {\n\n @Null(groups = Create.class, message = \"ID must be null for creation\")\n @NotNull(groups = Update.class, message = \"ID required for update\")\n private Long id;\n\n @NotBlank(groups = {Create.class, Update.class})\n @Size(min = 2, max = 50, groups = {Create.class, Update.class})\n private String name;\n\n @NotBlank(groups = Create.class, message = \"Email required\")\n @Email(groups = {Create.class, Update.class})\n private String email;\n\n @NotBlank(groups = Create.class, message = \"Password required for registration\")\n @ValidPassword(groups = Create.class)\n private String password;\n}\n\n// Controller with groups\n@RestController\n@RequestMapping(\"/api/users\")\npublic class UserController {\n\n @PostMapping\n public User create(\n @Validated(Create.class) @RequestBody UserRequest request) {\n return userService.create(request);\n }\n\n @PutMapping(\"/{id}\")\n public User update(\n @PathVariable Long id,\n @Validated(Update.class) @RequestBody UserRequest request) {\n return userService.update(id, request);\n }\n}\n\n// ✅ Group sequence for ordered validation\n@GroupSequence({BasicChecks.class, AdvancedChecks.class, Default.class})\npublic interface OrderedValidation {}\n\npublic class PaymentRequest {\n @NotNull(groups = BasicChecks.class)\n private Long amount;\n\n @CreditCardNumber(groups = AdvancedChecks.class)\n private String cardNumber;\n}\n```\n\n---\n\n### Pattern 6: Method Parameter Validation\n\n```java\n// ✅ Validate method parameters and return values\n\n@Service\n@Validated // Enable method-level validation\npublic class OrderService {\n\n // Validate parameters\n public Order createOrder(\n @NotNull @Valid CreateOrderRequest request,\n @NotNull Long customerId) {\n // ...\n }\n\n // Validate return value\n @NotNull\n public Order findById(@Min(1) Long id) {\n // ...\n }\n\n // Validate collection elements\n public void processOrders(\n @NotEmpty List<@Valid OrderRequest> orders) {\n // ...\n }\n}\n\n// Controller path variable validation\n@RestController\n@Validated\n@RequestMapping(\"/api/orders\")\npublic class OrderController {\n\n @GetMapping(\"/{id}\")\n public Order getOrder(\n @PathVariable @Min(1) Long id) {\n return orderService.findById(id);\n }\n\n @GetMapping\n public List search(\n @RequestParam @Size(min = 3) String query,\n @RequestParam @Min(0) @Max(100) Integer limit) {\n return orderService.search(query, limit);\n }\n}\n```\n\n---\n\n### Pattern 7: Conditional Validation\n\n```java\n// ✅ Validate based on other field values\n\n@Target(ElementType.TYPE)\n@Retention(RetentionPolicy.RUNTIME)\n@Constraint(validatedBy = ConditionalValidator.class)\npublic @interface ConditionalValidation {\n String message() default \"Conditional validation failed\";\n Class[] groups() default {};\n Class[] payload() default {};\n\n String conditionalField();\n String expectedValue();\n String[] requiredFields();\n}\n\npublic class ConditionalValidator\n implements ConstraintValidator {\n\n private String conditionalField;\n private String expectedValue;\n private String[] requiredFields;\n\n @Override\n public void initialize(ConditionalValidation annotation) {\n this.conditionalField = annotation.conditionalField();\n this.expectedValue = annotation.expectedValue();\n this.requiredFields = annotation.requiredFields();\n }\n\n @Override\n public boolean isValid(Object obj, ConstraintValidatorContext context) {\n try {\n Object conditionalValue = getFieldValue(obj, conditionalField);\n\n if (!expectedValue.equals(String.valueOf(conditionalValue))) {\n return true; // Condition not met, skip validation\n }\n\n boolean valid = true;\n context.disableDefaultConstraintViolation();\n\n for (String field : requiredFields) {\n Object value = getFieldValue(obj, field);\n if (value == null || (value instanceof String s && s.isBlank())) {\n context.buildConstraintViolationWithTemplate(\n field + \" is required when \" + conditionalField + \" is \" + expectedValue)\n .addPropertyNode(field)\n .addConstraintViolation();\n valid = false;\n }\n }\n\n return valid;\n } catch (Exception e) {\n return false;\n }\n }\n}\n\n// Usage - require shipping address only for physical products\n@ConditionalValidation(\n conditionalField = \"productType\",\n expectedValue = \"PHYSICAL\",\n requiredFields = {\"shippingAddress\", \"shippingMethod\"})\npublic class OrderRequest {\n private ProductType productType;\n private ShippingAddress shippingAddress;\n private ShippingMethod shippingMethod;\n}\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Forgetting @Valid for Nested Objects\n\n```java\n// ❌ Nested object not validated\npublic class OrderRequest {\n @NotNull\n private CustomerInfo customer; // Customer fields NOT validated!\n}\n\n// ✅ Add @Valid\npublic class OrderRequest {\n @NotNull\n @Valid\n private CustomerInfo customer;\n}\n```\n\n### Mistake 2: @Validated vs @Valid\n\n```java\n// @Valid - Bean Validation standard, works on parameters\n// @Validated - Spring, supports validation groups\n\n@PostMapping\npublic User create(@Valid @RequestBody UserRequest request) { } // No groups\n\n@PostMapping\npublic User create(@Validated(Create.class) @RequestBody UserRequest request) { } // With groups\n```\n\n---\n\n## 🐛 Debug This: The Silent Validation\n\nA developer reports: \"Our nested object validation doesn't work! Invalid addresses are saved to the database.\"\n\n```java\npublic class OrderRequest {\n\n @NotNull(message = \"Customer ID required\")\n private Long customerId;\n\n @NotEmpty(message = \"Items cannot be empty\")\n private List items;\n\n @NotNull(message = \"Shipping address required\")\n private ShippingAddress shippingAddress; // BUG: Missing @Valid!\n}\n\npublic class ShippingAddress {\n @NotBlank(message = \"Street required\")\n private String street;\n\n @NotBlank(message = \"City required\")\n private String city;\n\n @Pattern(regexp = \"\\\\d{5}\", message = \"Invalid ZIP code\")\n private String zipCode;\n}\n\n@RestController\npublic class OrderController {\n\n @PostMapping(\"/orders\")\n public Order createOrder(@Valid @RequestBody OrderRequest request) {\n // Validation passes even with invalid address!\n return orderService.create(request);\n }\n}\n\n// Test:\n// POST /orders with {\"customerId\": 1, \"items\": [...], \"shippingAddress\": {\"street\": \"\", \"city\": \"\", \"zipCode\": \"invalid\"}}\n// Expected: 400 Bad Request with validation errors\n// Actual: 201 Created - invalid address saved!\n```\n\n**Why doesn't the address validation work?**\n\n---\n\n**✅ Solution:**\n\nThe bug is a missing `@Valid` annotation on the nested `shippingAddress` field. Bean Validation does NOT automatically cascade to nested objects - you must explicitly tell it to validate nested objects with `@Valid`.\n\n```java\n@NotNull(message = \"Shipping address required\")\nprivate ShippingAddress shippingAddress; // Only checks null, NOT the fields inside!\n```\n\n**The fix:**\n\n```java\npublic class OrderRequest {\n\n @NotNull(message = \"Customer ID required\")\n private Long customerId;\n\n @NotEmpty(message = \"Items cannot be empty\")\n @Valid // Validate each item in the list\n private List items;\n\n @NotNull(message = \"Shipping address required\")\n @Valid // Cascade validation to nested object!\n private ShippingAddress shippingAddress;\n}\n```\n\n**Same issue applies to collections:**\n\n```java\n// ❌ Only checks that list is not empty, doesn't validate items\n@NotEmpty\nprivate List items;\n\n// ✅ Validates each item in the list\n@NotEmpty\n@Valid\nprivate List items;\n```\n\n**The lesson:** Always add `@Valid` to fields that contain nested objects or collections that need validation. Bean Validation only checks the immediate field by default.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Basic Constraints\n⭐ Difficulty: Easy | ⏱️ Time: 10 minutes\n\n**Task:** Add validation constraints to this DTO.\n\n```java\n// Add constraints for:\n// - email: required, valid email format\n// - name: required, 2-50 characters\n// - age: optional, but if present must be 18-120\n// - phone: optional, must match pattern if present\n\npublic class UserRequest {\n private String email;\n private String name;\n private Integer age;\n private String phone;\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class UserRequest {\n\n @NotBlank(message = \"Email is required\")\n @Email(message = \"Invalid email format\")\n private String email;\n\n @NotBlank(message = \"Name is required\")\n @Size(min = 2, max = 50, message = \"Name must be 2-50 characters\")\n private String name;\n\n @Min(value = 18, message = \"Must be at least 18\")\n @Max(value = 120, message = \"Must be at most 120\")\n private Integer age; // null is valid (not @NotNull)\n\n @Pattern(regexp = \"^\\\\+?[1-9]\\\\d{1,14}$\",\n message = \"Invalid phone number format\")\n private String phone; // null is valid (Pattern allows null)\n}\n```\n\n---\n\n### Exercise 2: Custom Password Validator\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Create a custom password validator with configurable requirements.\n\n```java\n// @ValidPassword annotation that checks:\n// - Minimum length (configurable)\n// - Contains uppercase (configurable)\n// - Contains digit (configurable)\n// - Contains special character (configurable)\n// - Custom error message listing all violations\n```\n\n**✅ Solution:**\n\n```java\n@Target({ElementType.FIELD, ElementType.PARAMETER})\n@Retention(RetentionPolicy.RUNTIME)\n@Constraint(validatedBy = PasswordValidator.class)\npublic @interface ValidPassword {\n String message() default \"Invalid password\";\n Class[] groups() default {};\n Class[] payload() default {};\n\n int minLength() default 8;\n boolean requireUppercase() default true;\n boolean requireDigit() default true;\n boolean requireSpecial() default false;\n}\n\npublic class PasswordValidator implements ConstraintValidator {\n\n private int minLength;\n private boolean requireUppercase;\n private boolean requireDigit;\n private boolean requireSpecial;\n\n @Override\n public void initialize(ValidPassword ann) {\n this.minLength = ann.minLength();\n this.requireUppercase = ann.requireUppercase();\n this.requireDigit = ann.requireDigit();\n this.requireSpecial = ann.requireSpecial();\n }\n\n @Override\n public boolean isValid(String password, ConstraintValidatorContext ctx) {\n if (password == null) {\n return true; // Let @NotNull handle null\n }\n\n List violations = new ArrayList<>();\n\n if (password.length() < minLength) {\n violations.add(\"at least \" + minLength + \" characters\");\n }\n if (requireUppercase && !password.matches(\".*[A-Z].*\")) {\n violations.add(\"an uppercase letter\");\n }\n if (requireDigit && !password.matches(\".*\\\\d.*\")) {\n violations.add(\"a digit\");\n }\n if (requireSpecial && !password.matches(\".*[!@#$%^&*(),.?\\\":{}|<>].*\")) {\n violations.add(\"a special character\");\n }\n\n if (!violations.isEmpty()) {\n ctx.disableDefaultConstraintViolation();\n ctx.buildConstraintViolationWithTemplate(\n \"Password must contain: \" + String.join(\", \", violations))\n .addConstraintViolation();\n return false;\n }\n\n return true;\n }\n}\n\n// Usage\npublic class RegistrationRequest {\n @NotBlank\n @ValidPassword(minLength = 10, requireSpecial = true)\n private String password;\n}\n```\n\n---\n\n### Exercise 3: Cross-Field Validation\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Create a class-level validator for password confirmation.\n\n```java\n// @PasswordMatch that:\n// - Validates password == confirmPassword\n// - Adds error to confirmPassword field\n// - Works with any field names (configurable)\n```\n\n**✅ Solution:**\n\n```java\n@Target(ElementType.TYPE)\n@Retention(RetentionPolicy.RUNTIME)\n@Constraint(validatedBy = PasswordMatchValidator.class)\npublic @interface PasswordMatch {\n String message() default \"Passwords do not match\";\n Class[] groups() default {};\n Class[] payload() default {};\n\n String passwordField() default \"password\";\n String confirmField() default \"confirmPassword\";\n}\n\npublic class PasswordMatchValidator\n implements ConstraintValidator {\n\n private String passwordField;\n private String confirmField;\n\n @Override\n public void initialize(PasswordMatch ann) {\n this.passwordField = ann.passwordField();\n this.confirmField = ann.confirmField();\n }\n\n @Override\n public boolean isValid(Object obj, ConstraintValidatorContext ctx) {\n try {\n Object password = getFieldValue(obj, passwordField);\n Object confirm = getFieldValue(obj, confirmField);\n\n boolean valid = Objects.equals(password, confirm);\n\n if (!valid) {\n ctx.disableDefaultConstraintViolation();\n ctx.buildConstraintViolationWithTemplate(\n ctx.getDefaultConstraintMessageTemplate())\n .addPropertyNode(confirmField)\n .addConstraintViolation();\n }\n\n return valid;\n } catch (Exception e) {\n return false;\n }\n }\n\n private Object getFieldValue(Object obj, String fieldName) throws Exception {\n Field field = obj.getClass().getDeclaredField(fieldName);\n field.setAccessible(true);\n return field.get(obj);\n }\n}\n\n// Usage\n@PasswordMatch\npublic class ChangePasswordRequest {\n @NotBlank\n private String currentPassword;\n\n @NotBlank\n @ValidPassword\n private String password;\n\n @NotBlank\n private String confirmPassword;\n}\n```\n\n---\n\n### Exercise 4: Validation Groups\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Implement validation groups for create vs update operations.\n\n```java\n// Different rules for Create vs Update:\n// - Create: ID must be null, email required, password required\n// - Update: ID required, email optional, password optional\n```\n\n**✅ Solution:**\n\n```java\n// Define groups\npublic interface ValidationGroups {\n interface Create {}\n interface Update {}\n}\n\npublic class UserRequest {\n\n @Null(groups = Create.class, message = \"ID must be null for creation\")\n @NotNull(groups = Update.class, message = \"ID required for update\")\n private Long id;\n\n @NotBlank(groups = Create.class, message = \"Email required\")\n @Email(groups = {Create.class, Update.class}, message = \"Invalid email\")\n private String email;\n\n @NotBlank(groups = Create.class, message = \"Name required\")\n @Size(min = 2, max = 50, groups = {Create.class, Update.class})\n private String name;\n\n @NotBlank(groups = Create.class, message = \"Password required for registration\")\n @ValidPassword(groups = Create.class)\n private String password;\n\n // Getters/setters\n}\n\n// Controller\n@RestController\n@RequestMapping(\"/api/users\")\npublic class UserController {\n\n @PostMapping\n public User create(\n @Validated(Create.class) @RequestBody UserRequest request) {\n return userService.create(request);\n }\n\n @PutMapping(\"/{id}\")\n public User update(\n @PathVariable Long id,\n @Validated(Update.class) @RequestBody UserRequest request) {\n return userService.update(id, request);\n }\n\n @PatchMapping(\"/{id}\")\n public User patch(\n @PathVariable Long id,\n @RequestBody UserRequest request) {\n // No validation group = no constraints checked\n // Useful for partial updates\n return userService.patch(id, request);\n }\n}\n```\n\n---\n\n### Exercise 5: Method Parameter Validation\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Enable validation on service method parameters.\n\n```java\n// Create a service with:\n// - Validated method parameters\n// - Validated return values\n// - Validated collection elements\n```\n\n**✅ Solution:**\n\n```java\n@Service\n@Validated // Enable method-level validation\npublic class OrderService {\n\n private final OrderRepository repository;\n\n // Validate individual parameters\n public Order createOrder(\n @NotNull(message = \"Request cannot be null\")\n @Valid CreateOrderRequest request,\n @NotNull(message = \"Customer ID required\")\n @Min(value = 1, message = \"Invalid customer ID\") Long customerId) {\n\n Order order = new Order(request, customerId);\n return repository.save(order);\n }\n\n // Validate return value\n @NotNull\n public Order findById(\n @Min(value = 1, message = \"ID must be positive\") Long id) {\n\n return repository.findById(id)\n .orElseThrow(() -> new OrderNotFoundException(id));\n }\n\n // Validate collection elements\n public List processOrders(\n @NotEmpty(message = \"Orders list cannot be empty\")\n List<@Valid OrderRequest> orders) {\n\n return orders.stream()\n .map(this::createFromRequest)\n .map(repository::save)\n .toList();\n }\n\n // Validate with groups at method level\n public Order updateOrder(\n @Min(1) Long id,\n @Validated(Update.class) @Valid OrderRequest request) {\n\n Order existing = findById(id);\n existing.update(request);\n return repository.save(existing);\n }\n}\n\n// Configuration - ensure AOP proxy is created\n@Configuration\n@EnableMethodValidation\npublic class ValidationConfig {\n\n @Bean\n public MethodValidationPostProcessor methodValidationPostProcessor() {\n return new MethodValidationPostProcessor();\n }\n}\n\n// Exception handling for method validation\n@RestControllerAdvice\npublic class ValidationExceptionHandler {\n\n @ExceptionHandler(ConstraintViolationException.class)\n public ResponseEntity handleMethodValidation(\n ConstraintViolationException ex) {\n\n List> errors = ex.getConstraintViolations()\n .stream()\n .map(cv -> Map.of(\n \"parameter\", extractParameterName(cv.getPropertyPath()),\n \"message\", cv.getMessage()))\n .toList();\n\n ApiProblem problem = ApiProblem.builder()\n .type(\"validation-error\")\n .title(\"Method Parameter Validation Failed\")\n .status(HttpStatus.BAD_REQUEST)\n .detail(\"Invalid method parameters\")\n .extension(\"errors\", errors)\n .build();\n\n return ResponseEntity.badRequest().body(problem);\n }\n\n private String extractParameterName(Path path) {\n StringBuilder name = new StringBuilder();\n for (Path.Node node : path) {\n if (node.getKind() == ElementKind.PARAMETER ||\n node.getKind() == ElementKind.PROPERTY) {\n if (name.length() > 0) name.append(\".\");\n name.append(node.getName());\n }\n }\n return name.toString();\n }\n}\n```\n\n---\n\n## 🎤 Interview Questions\n\n### Q1: Difference between @NotNull, @NotEmpty, @NotBlank?\n\n**Answer:**\n- `@NotNull`: Not null, but can be empty string or empty collection\n- `@NotEmpty`: Not null AND not empty (size > 0), for String/Collection/Map/Array\n- `@NotBlank`: Not null AND not empty AND not just whitespace, only for String\n\n### Q2: How to validate method parameters in a service?\n\n**Answer:**\n1. Add `@Validated` to the class\n2. Add constraints to method parameters\n3. Spring AOP intercepts and validates\n4. `ConstraintViolationException` thrown on violation\n\n---\n\n## 📝 Summary\n\n| Constraint | Use For |\n|------------|---------|\n| @NotNull/@NotBlank/@NotEmpty | Required fields |\n| @Size | Length limits |\n| @Min/@Max/@Positive | Numeric bounds |\n| @Email/@Pattern | Format validation |\n| @Past/@Future | Date constraints |\n| @Valid | Nested validation |\n| Custom validators | Business rules |\n| Groups | Context-specific validation |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review built-in constraints table | 5 min |\n| Day 3 | Redo Exercise 1 (Basic Constraints) | 10 min |\n| Day 7 | Answer interview questions without looking | 10 min |\n| Day 14 | Redo Debug This (Silent Validation) | 15 min |\n| Day 30 | Audit validation in one DTO in your codebase | 20 min |\n\n---\n\n*Next: [Part 18: Fluent Validation]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.853271Z","createdAt","2026-06-10T07:19:24.853961Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",15,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",17,"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":91,"_72":34,"_35":92},{"_31":88,"_72":89,"_35":90},{"_31":85,"_72":86,"_35":87},{"_31":82,"_72":83,"_35":84},81,"Jakarta Validation","jakarta-validation",83,"Dto Validation","dto-validation",82,"Constraints","constraints",80,"bean-validation",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]