Update javaxval/src/test/java/org/baeldung/javaxval/messageinterpolator/ParameterMessageInterpolaterIntegrationTest.java

update to use the givenX_whenY_thenZ naming convention for tests

Co-Authored-By: KevinGilmore <[email protected]>

javaxval/.gitignore

@@ -0,0 +1,6 @@
+.classpath
+.project
+.settings/
+target/
+bin/
+

javaxval/README.md

@@ -0,0 +1,12 @@
+## Java Bean Validation Examples
+
+This module contains articles about Bean Validation.
+
+### Relevant Articles: 
+- [Java Bean Validation Basics](https://www.baeldung.com/javax-validation)
+- [Validating Container Elements with Bean Validation 2.0](https://www.baeldung.com/bean-validation-container-elements)
+- [Method Constraints with Bean Validation 2.0](https://www.baeldung.com/javax-validation-method-constraints)
+- [Difference Between @NotNull, @NotEmpty, and @NotBlank Constraints in Bean Validation](https://www.baeldung.com/java-bean-validation-not-null-empty-blank)
+- [Javax BigDecimal Validation](https://www.baeldung.com/javax-bigdecimal-validation)
+- [Grouping Javax Validation Constraints](https://www.baeldung.com/javax-validation-groups)
+- [Javax Validations for Enums](https://www.baeldung.com/javax-validations-enums)

javaxval/pom.xml

@@ -0,0 +1,61 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>javaxval</artifactId>
+    <version>0.1-SNAPSHOT</version>
+    <name>javaxval</name>
+    
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>javax.validation</groupId>
+            <artifactId>validation-api</artifactId>
+            <version>${validation-api.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <version>${hibernate-validator.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish</groupId>
+            <artifactId>javax.el</artifactId>
+            <version>${javax.el.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+	
+    <properties>
+        <validation-api.version>2.0.1.Final</validation-api.version>
+        <hibernate-validator.version>6.0.13.Final</hibernate-validator.version>
+        <javax.el.version>3.0.0</javax.el.version>    
+        <org.springframework.version>5.0.2.RELEASE</org.springframework.version>
+        <assertj.version>3.11.1</assertj.version>
+    </properties>    
+</project>

javaxval/src/main/java/org/baeldung/javaxval/beanvalidation/User.java

@@ -0,0 +1,93 @@
+package org.baeldung.javaxval.beanvalidation;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+
+import javax.validation.constraints.AssertTrue;
+import javax.validation.constraints.Email;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Past;
+import javax.validation.constraints.Size;
+
+public class User {
+
+    @NotNull(message = "Name cannot be null")
+    private String name;
+
+    @AssertTrue
+    private boolean working;
+
+    @Size(min = 10, max = 200, message = "Number of characters should be in between 10 and 200 inclusive")
+    private String aboutMe;
+
+    @Min(value = 18, message = "Age should not be less than 18")
+    @Max(value = 150, message = "Age should not be more than 150")
+    private int age;
+
+    @Email(message = "Email should be valid")
+    private String email;
+
+    private List<@NotBlank String> preferences;
+
+    private LocalDate dateOfBirth;
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public boolean isWorking() {
+        return working;
+    }
+
+    public void setWorking(boolean working) {
+        this.working = working;
+    }
+
+    public String getAboutMe() {
+        return aboutMe;
+    }
+
+    public void setAboutMe(String aboutMe) {
+        this.aboutMe = aboutMe;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Optional<@Past LocalDate> getDateOfBirth() {
+        return Optional.ofNullable(dateOfBirth);
+    }
+
+    public void setDateOfBirth(LocalDate dateOfBirth) {
+        this.dateOfBirth = dateOfBirth;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public List<String> getPreferences() {
+        return preferences;
+    }
+
+    public void setPreferences(List<String> preferences) {
+        this.preferences = preferences;
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/bigdecimal/Invoice.java

@@ -0,0 +1,19 @@
+package org.baeldung.javaxval.bigdecimal;
+
+import java.math.BigDecimal;
+
+import javax.validation.constraints.DecimalMin;
+import javax.validation.constraints.Digits;
+
+public class Invoice {
+
+    @DecimalMin(value = "0.0", inclusive = false)
+    @Digits(integer = 3, fraction = 2)
+    private BigDecimal price;
+    private String description;
+
+    public Invoice(BigDecimal price, String description) {
+        this.price = price;
+        this.description = description;
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/container/validation/Customer.java

@@ -0,0 +1,66 @@
+package org.baeldung.javaxval.container.validation;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.OptionalInt;
+
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.PositiveOrZero;
+
+public class Customer {
+
+    @NotBlank(message = "Name cannot be empty")
+    private String name;
+
+    private List<@NotBlank(message = "Address must not be blank") String> addresses;
+
+    private Integer age;
+
+    @PositiveOrZero
+    private OptionalInt numberOfOrders;
+
+    @NotBlank
+    private Profile profile;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<String> getAddresses() {
+        return addresses;
+    }
+
+    public void setAddresses(List<String> addresses) {
+        this.addresses = addresses;
+    }
+
+    public Optional<@Min(18) Integer> getAge() {
+        return Optional.ofNullable(age);
+    }
+
+    public void setAge(Integer age) {
+        this.age = age;
+    }
+
+    public OptionalInt getNumberOfOrders() {
+        return numberOfOrders;
+    }
+
+    public void setNumberOfOrders(OptionalInt numberOfOrders) {
+        this.numberOfOrders = numberOfOrders;
+    }
+
+    public Profile getProfile() {
+        return profile;
+    }
+
+    public void setProfile(Profile profile) {
+        this.profile = profile;
+    }
+
+}

javaxval/src/main/java/org/baeldung/javaxval/container/validation/CustomerMap.java

@@ -0,0 +1,19 @@
+package org.baeldung.javaxval.container.validation;
+
+import java.util.Map;
+
+import javax.validation.constraints.Email;
+import javax.validation.constraints.NotNull;
+
+public class CustomerMap {
+
+    private Map<@Email(message = "Must be a valid email") String, @NotNull Customer> customers;
+
+    public Map<String, Customer> getCustomers() {
+        return customers;
+    }
+
+    public void setCustomers(Map<String, Customer> customers) {
+        this.customers = customers;
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/container/validation/Profile.java

@@ -0,0 +1,13 @@
+package org.baeldung.javaxval.container.validation;
+
+public class Profile {
+    private String companyName;
+
+    public String getCompanyName() {
+        return companyName;
+    }
+
+    public void setCompanyName(String companyName) {
+        this.companyName = companyName;
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/container/validation/valueextractors/ProfileValueExtractor.java

@@ -0,0 +1,17 @@
+package org.baeldung.javaxval.container.validation.valueextractors;
+
+import javax.validation.valueextraction.ExtractedValue;
+import javax.validation.valueextraction.UnwrapByDefault;
+import javax.validation.valueextraction.ValueExtractor;
+
+import org.baeldung.javaxval.container.validation.Profile;
+
+@UnwrapByDefault
+public class ProfileValueExtractor implements ValueExtractor<@ExtractedValue(type = String.class) Profile> {
+
+    @Override
+    public void extractValues(Profile originalValue, ValueExtractor.ValueReceiver receiver) {
+        receiver.value(null, originalValue.getCompanyName());
+    }
+
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/CustomerTypeSubSetValidator.java

@@ -0,0 +1,24 @@
+package org.baeldung.javaxval.enums;
+
+import java.util.Arrays;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+import org.baeldung.javaxval.enums.constraints.CustomerTypeSubset;
+import org.baeldung.javaxval.enums.demo.CustomerType;
+
+public class CustomerTypeSubSetValidator implements ConstraintValidator<CustomerTypeSubset, CustomerType> {
+    private CustomerType[] subset;
+
+    @Override
+    public void initialize(CustomerTypeSubset constraint) {
+        this.subset = constraint.anyOf();
+    }
+
+    @Override
+    public boolean isValid(CustomerType value, ConstraintValidatorContext context) {
+        return value == null || Arrays.asList(subset)
+            .contains(value);
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/EnumNamePatternValidator.java

@@ -0,0 +1,33 @@
+package org.baeldung.javaxval.enums;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+import org.baeldung.javaxval.enums.constraints.EnumNamePattern;
+
+public class EnumNamePatternValidator implements ConstraintValidator<EnumNamePattern, Enum<?>> {
+    private Pattern pattern;
+
+    @Override
+    public void initialize(EnumNamePattern constraintAnnotation) {
+        try {
+            pattern = Pattern.compile(constraintAnnotation.regexp());
+        } catch (PatternSyntaxException e) {
+            throw new IllegalArgumentException("Given regex is invalid", e);
+        }
+    }
+
+    @Override
+    public boolean isValid(Enum<?> value, ConstraintValidatorContext context) {
+        if (value == null) {
+            return true;
+        }
+
+        Matcher m = pattern.matcher(value.name());
+        return m.matches();
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/EnumSubSetValidator.java

@@ -0,0 +1,25 @@
+package org.baeldung.javaxval.enums;
+
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+public abstract class EnumSubSetValidator<T extends Annotation, U> implements ConstraintValidator<T, U> {
+    private U[] subset;
+
+    protected void initialize(U[] subset) {
+        this.subset = subset;
+    }
+
+    @Override
+    public boolean isValid(U value, ConstraintValidatorContext context) {
+        if (value == null) {
+            return true;
+        }
+
+        return Arrays.asList(subset)
+            .contains(value);
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/InheritedCustomerTypeSubSetValidator.java

@@ -0,0 +1,11 @@
+package org.baeldung.javaxval.enums;
+
+import org.baeldung.javaxval.enums.constraints.CustomerTypeSubset;
+import org.baeldung.javaxval.enums.demo.CustomerType;
+
+public class InheritedCustomerTypeSubSetValidator extends EnumSubSetValidator<CustomerTypeSubset, CustomerType> {
+    @Override
+    public void initialize(CustomerTypeSubset constraint) {
+        super.initialize(constraint.anyOf());
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/ValueOfEnumValidator.java

@@ -0,0 +1,31 @@
+package org.baeldung.javaxval.enums;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+import org.baeldung.javaxval.enums.constraints.ValueOfEnum;
+
+public class ValueOfEnumValidator implements ConstraintValidator<ValueOfEnum, CharSequence> {
+    private List<String> acceptedValues;
+
+    @Override
+    public void initialize(ValueOfEnum annotation) {
+        acceptedValues = Stream.of(annotation.enumClass()
+            .getEnumConstants())
+            .map(Enum::name)
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    public boolean isValid(CharSequence value, ConstraintValidatorContext context) {
+        if (value == null) {
+            return true;
+        }
+
+        return acceptedValues.contains(value.toString());
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/constraints/CustomerTypeSubset.java

@@ -0,0 +1,45 @@
+package org.baeldung.javaxval.enums.constraints;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE_USE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+
+import org.baeldung.javaxval.enums.CustomerTypeSubSetValidator;
+import org.baeldung.javaxval.enums.demo.CustomerType;
+
+@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
+@Retention(RUNTIME)
+@Documented
+@Constraint(validatedBy = CustomerTypeSubSetValidator.class)
+public @interface CustomerTypeSubset {
+    /**
+     * @return subset of CustomerType enum
+     */
+    CustomerType[] anyOf();
+
+    /**
+     * @return the error message template
+     */
+    String message() default "must be any of {anyOf}";
+
+    /**
+     * @return the groups the constraint belongs to
+     */
+    Class<?>[] groups() default {};
+
+    /**
+     * @return the payload associated to the constraint
+     */
+    Class<? extends Payload>[] payload() default {};
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/constraints/EnumNamePattern.java

@@ -0,0 +1,45 @@
+package org.baeldung.javaxval.enums.constraints;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE_USE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+
+import org.baeldung.javaxval.enums.EnumNamePatternValidator;
+
+@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
+@Retention(RUNTIME)
+@Documented
+@Constraint(validatedBy = EnumNamePatternValidator.class)
+public @interface EnumNamePattern {
+
+    /**
+     * @return the regular expression to match
+     */
+    String regexp();
+
+    /**
+     * @return the error message template
+     */
+    String message() default "must match \"{regexp}\"";
+
+    /**
+     * @return the groups the constraint belongs to
+     */
+    Class<?>[] groups() default {};
+
+    /**
+     * @return the payload associated to the constraint
+     */
+    Class<? extends Payload>[] payload() default {};
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/constraints/ValueOfEnum.java

@@ -0,0 +1,44 @@
+package org.baeldung.javaxval.enums.constraints;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE_USE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+
+import org.baeldung.javaxval.enums.ValueOfEnumValidator;
+
+@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
+@Retention(RUNTIME)
+@Documented
+@Constraint(validatedBy = ValueOfEnumValidator.class)
+public @interface ValueOfEnum {
+    /**
+     * @return class containing enum values to which this String should match
+     */
+    Class<? extends Enum<?>> enumClass();
+
+    /**
+     * @return the error message template
+     */
+    String message() default "must be any of enum {enumClass}";
+
+    /**
+     * @return the groups the constraint belongs to
+     */
+    Class<?>[] groups() default {};
+
+    /**
+     * @return the payload associated to the constraint
+     */
+    Class<? extends Payload>[] payload() default {};
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/demo/Customer.java

@@ -0,0 +1,77 @@
+package org.baeldung.javaxval.enums.demo;
+
+import javax.validation.constraints.NotNull;
+
+import org.baeldung.javaxval.enums.constraints.CustomerTypeSubset;
+import org.baeldung.javaxval.enums.constraints.EnumNamePattern;
+import org.baeldung.javaxval.enums.constraints.ValueOfEnum;
+
+public class Customer {
+    @ValueOfEnum(enumClass = CustomerType.class)
+    private String customerTypeString;
+
+    @NotNull
+    @CustomerTypeSubset(anyOf = { CustomerType.NEW, CustomerType.OLD })
+    private CustomerType customerTypeOfSubset;
+
+    @EnumNamePattern(regexp = "NEW|DEFAULT")
+    private CustomerType customerTypeMatchesPattern;
+
+    public Customer() {
+    }
+
+    public Customer(String customerTypeString, CustomerType customerTypeOfSubset, CustomerType customerTypeMatchesPattern) {
+        this.customerTypeString = customerTypeString;
+        this.customerTypeOfSubset = customerTypeOfSubset;
+        this.customerTypeMatchesPattern = customerTypeMatchesPattern;
+    }
+
+    public String getCustomerTypeString() {
+        return customerTypeString;
+    }
+
+    public void setCustomerTypeString(String customerTypeString) {
+        this.customerTypeString = customerTypeString;
+    }
+
+    public CustomerType getCustomerTypeOfSubset() {
+        return customerTypeOfSubset;
+    }
+
+    public void setCustomerTypeOfSubset(CustomerType customerTypeOfSubset) {
+        this.customerTypeOfSubset = customerTypeOfSubset;
+    }
+
+    public CustomerType getCustomerTypeMatchesPattern() {
+        return customerTypeMatchesPattern;
+    }
+
+    public void setCustomerTypeMatchesPattern(CustomerType customerTypeMatchesPattern) {
+        this.customerTypeMatchesPattern = customerTypeMatchesPattern;
+    }
+
+    public static class Builder {
+        private String customerTypeString;
+        private CustomerType customerTypeOfSubset = CustomerType.NEW;
+        private CustomerType customerTypeMatchesPattern;
+
+        public Builder withCustomerTypeString(String customerTypeString) {
+            this.customerTypeString = customerTypeString;
+            return this;
+        }
+
+        public Builder withCustomerTypeOfSubset(CustomerType customerTypeOfSubset) {
+            this.customerTypeOfSubset = customerTypeOfSubset;
+            return this;
+        }
+
+        public Builder withCustomerTypeMatchesPattern(CustomerType customerTypeMatchesPattern) {
+            this.customerTypeMatchesPattern = customerTypeMatchesPattern;
+            return this;
+        }
+
+        public Customer build() {
+            return new Customer(customerTypeString, customerTypeOfSubset, customerTypeMatchesPattern);
+        }
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/enums/demo/CustomerType.java

@@ -0,0 +1,5 @@
+package org.baeldung.javaxval.enums.demo;
+
+public enum CustomerType {
+    NEW, OLD, DEFAULT
+}

javaxval/src/main/java/org/baeldung/javaxval/javabeanconstraints/application/Application.java

@@ -0,0 +1,18 @@
+package org.baeldung.javaxval.javabeanconstraints.application;
+
+import javax.validation.Validation;
+import javax.validation.Validator;
+
+import org.baeldung.javaxval.javabeanconstraints.entities.UserNotBlank;
+
+public class Application {
+
+    public static void main(String[] args) {
+        Validator validator = Validation.buildDefaultValidatorFactory()
+            .getValidator();
+        UserNotBlank user = new UserNotBlank(" ");
+        validator.validate(user)
+            .stream()
+            .forEach(violation -> System.out.println(violation.getMessage()));
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/javabeanconstraints/entities/UserNotBlank.java

@@ -0,0 +1,22 @@
+package org.baeldung.javaxval.javabeanconstraints.entities;
+
+import javax.validation.constraints.NotBlank;
+
+public class UserNotBlank {
+
+    @NotBlank(message = "Name is mandatory")
+    private final String name;
+
+    public UserNotBlank(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String toString() {
+        return "User{" + "name=" + name + "}";
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/javabeanconstraints/entities/UserNotEmpty.java

@@ -0,0 +1,22 @@
+package org.baeldung.javaxval.javabeanconstraints.entities;
+
+import javax.validation.constraints.NotEmpty;
+
+public class UserNotEmpty {
+
+    @NotEmpty(message = "Name is mandatory")
+    private final String name;
+
+    public UserNotEmpty(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String toString() {
+        return "User{" + "name=" + name + "}";
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/javabeanconstraints/entities/UserNotNull.java

@@ -0,0 +1,22 @@
+package org.baeldung.javaxval.javabeanconstraints.entities;
+
+import javax.validation.constraints.NotNull;
+
+public class UserNotNull {
+
+    @NotNull(message = "Name is mandatory")
+    private final String name;
+
+    public UserNotNull(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String toString() {
+        return "User{" + "name=" + name + "}";
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/messageinterpolator/Person.java

@@ -0,0 +1,42 @@
+package org.baeldung.javaxval.messageinterpolator;
+
+import javax.validation.constraints.Email;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.Size;
+
+public class Person {
+
+    @Size(min = 10, max = 100, message = "Name should be between {min} and {max} characters")
+    private String name;
+
+    @Min(value = 18, message = "Age should not be less than {value}")
+    private int age;
+    
+    @Email(message = "Email address should be in a correct format: ${validatedValue}")
+    private String email;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+    
+    public String getEmail() {
+        return email;
+    }
+    
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+}

javaxval/src/main/java/org/baeldung/javaxval/methodvalidation/MethodValidationConfig.java

@@ -0,0 +1,38 @@
+package org.baeldung.javaxval.methodvalidation;
+
+import java.time.LocalDate;
+
+import org.baeldung.javaxval.methodvalidation.model.Customer;
+import org.baeldung.javaxval.methodvalidation.model.Reservation;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Scope;
+import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
+
+@Configuration
+@ComponentScan({ "org.baeldung.javaxval.methodvalidation.model" })
+public class MethodValidationConfig {
+
+    @Bean
+    public MethodValidationPostProcessor methodValidationPostProcessor() {
+        return new MethodValidationPostProcessor();
+    }
+
+    @Bean("customer")
+    @Scope(BeanDefinition.SCOPE_PROTOTYPE)
+    public Customer customer(String firstName, String lastName) {
+
+        Customer customer = new Customer(firstName, lastName);
+        return customer;
+    }
+
+    @Bean("reservation")
+    @Scope(BeanDefinition.SCOPE_PROTOTYPE)
+    public Reservation reservation(LocalDate begin, LocalDate end, Customer customer, int room) {
+
+        Reservation reservation = new Reservation(begin, end, customer, room);
+        return reservation;
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/methodvalidation/constraints/ConsistentDateParameterValidator.java

@@ -0,0 +1,26 @@
+package org.baeldung.javaxval.methodvalidation.constraints;
+
+import java.time.LocalDate;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+import javax.validation.constraintvalidation.SupportedValidationTarget;
+import javax.validation.constraintvalidation.ValidationTarget;
+
+@SupportedValidationTarget(ValidationTarget.PARAMETERS)
+public class ConsistentDateParameterValidator implements ConstraintValidator<ConsistentDateParameters, Object[]> {
+
+    @Override
+    public boolean isValid(Object[] value, ConstraintValidatorContext context) {
+
+        if (value[0] == null || value[1] == null) {
+            return true;
+        }
+
+        if (!(value[0] instanceof LocalDate) || !(value[1] instanceof LocalDate)) {
+            throw new IllegalArgumentException("Illegal method signature, expected two parameters of type LocalDate.");
+        }
+
+        return ((LocalDate) value[0]).isAfter(LocalDate.now()) && ((LocalDate) value[0]).isBefore((LocalDate) value[1]);
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/methodvalidation/constraints/ConsistentDateParameters.java

@@ -0,0 +1,25 @@
+package org.baeldung.javaxval.methodvalidation.constraints;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+
+@Constraint(validatedBy = ConsistentDateParameterValidator.class)
+@Target({ METHOD, CONSTRUCTOR })
+@Retention(RUNTIME)
+@Documented
+public @interface ConsistentDateParameters {
+
+    String message() default "End date must be after begin date and both must be in the future";
+
+    Class<?>[] groups() default {};
+
+    Class<? extends Payload>[] payload() default {};
+}

javaxval/src/main/java/org/baeldung/javaxval/methodvalidation/constraints/ValidReservation.java

@@ -0,0 +1,25 @@
+package org.baeldung.javaxval.methodvalidation.constraints;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+
+@Constraint(validatedBy = ValidReservationValidator.class)
+@Target({ METHOD, CONSTRUCTOR })
+@Retention(RUNTIME)
+@Documented
+public @interface ValidReservation {
+
+    String message() default "End date must be after begin date and both must be in the future, room number must be bigger than 0";
+
+    Class<?>[] groups() default {};
+
+    Class<? extends Payload>[] payload() default {};
+}

javaxval/src/main/java/org/baeldung/javaxval/methodvalidation/constraints/ValidReservationValidator.java

@@ -0,0 +1,33 @@
+package org.baeldung.javaxval.methodvalidation.constraints;
+
+import java.time.LocalDate;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+import org.baeldung.javaxval.methodvalidation.model.Reservation;
+
+public class ValidReservationValidator implements ConstraintValidator<ValidReservation, Reservation> {
+
+    @Override
+    public boolean isValid(Reservation reservation, ConstraintValidatorContext context) {
+
+        if (reservation == null) {
+            return true;
+        }
+
+        if (!(reservation instanceof Reservation)) {
+            throw new IllegalArgumentException("Illegal method signature, expected parameter of type Reservation.");
+        }
+
+        if (reservation.getBegin() == null || reservation.getEnd() == null || reservation.getCustomer() == null) {
+            return false;
+        }
+
+        return (reservation.getBegin()
+            .isAfter(LocalDate.now())
+            && reservation.getBegin()
+                .isBefore(reservation.getEnd())
+            && reservation.getRoom() > 0);
+    }
+}

javaxval/src/main/java/org/baeldung/javaxval/methodvalidation/model/Customer.java

@@ -0,0 +1,41 @@
+package org.baeldung.javaxval.methodvalidation.model;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Size;
+
+import org.springframework.validation.annotation.Validated;
+
+@Validated
+public class Customer {
+
+    @Size(min = 5, max = 200)
+    private String firstName;
+
+    @Size(min = 5, max = 200)
+    private String lastName;
+
+    public Customer(@Size(min = 5, max = 200) @NotNull String firstName, @Size(min = 5, max = 200) @NotNull String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public Customer() {
+
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+}