JavaBean Validation - ExecutableValidator Examples

package com.logicbig.example;

import javax.validation.*;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.validation.executable.ExecutableValidator;
import java.lang.reflect.Constructor;
import java.util.Comparator;
import java.util.Set;

public class ConstructorParamValidationExample {

    private static class User {
        private final String name;
        private final String phone;

        public User(@NotNull String name,
                    @NotNull
                    @Pattern(regexp = "(\\d){3,3}-\\d{3,3}-\\d{4,4}",
                            message = "must match 111-111-1111 format")
                            String phone) {
            this.name = name;
            this.phone = phone;
        }

        public String getName() {
            return name;
        }

        public String getPhone() {
            return phone;
        }
    }


    public static void main(String[] args) throws NoSuchMethodException {

        Validator validator = getValidator();
        Constructor<User> constructor =
                User.class.getConstructor(String.class, String.class);
        ExecutableValidator executableValidator = validator.forExecutables();

        String userName = null;
        String userPhone = "223-223-222";

        Set<ConstraintViolation<User>> constraintViolations =
                executableValidator.validateConstructorParameters(constructor,
                        new Object[]{userName, userPhone});

        if (constraintViolations.size() > 0) {
            constraintViolations.stream().sorted(Comparator.comparing(o -> o.getPropertyPath().toString()))
                                .forEach(ConstructorParamValidationExample::printError);
        } else {
            User user = new User(userName, userPhone);
            System.out.println(user);
        }
    }

    private static Validator getValidator() {
        Configuration<?> config = Validation.byDefaultProvider().configure();
        ValidatorFactory factory = config.buildValidatorFactory();
        Validator validator = factory.getValidator();
        factory.close();
        return validator;
    }

    private static void printError(
            ConstraintViolation<User> violation) {
        System.out.println(violation.getPropertyPath() + " " + violation.getMessage());
    }
}

package com.logicbig.example;

import javax.validation.*;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.validation.executable.ExecutableValidator;
import java.lang.reflect.Method;
import java.util.Comparator;
import java.util.Set;

public class MethodParamValidationExample {

    private static class Task {
        public void run (@Size(min = 3, max = 20) String name,
                         @NotNull Runnable runnable) {
            System.out.println("starting task synchronously: " + name);
            runnable.run();
        }
    }

    public static void main (String[] args) throws NoSuchMethodException {

        Validator validator = getValidator();
        Method method = Task.class.getDeclaredMethod("run",
                new Class[]{String.class, Runnable.class});
        ExecutableValidator executableValidator = validator.forExecutables();

        Task task = new Task();
        String taskName = "a";
        Runnable runnable = null;


        Set<ConstraintViolation<Task>> violations =
                            executableValidator.validateParameters(task, method,
                                                new Object[]{taskName, runnable});

        if (violations.size() > 0) {
            violations.stream().sorted(Comparator.comparing(o -> o.getPropertyPath().toString()))
                                .forEach(MethodParamValidationExample::printError);
        } else {
            task.run(taskName, runnable);
        }
    }

    private static Validator getValidator(){
        Configuration<?> config = Validation.byDefaultProvider().configure();
        ValidatorFactory factory = config.buildValidatorFactory();
        Validator validator = factory.getValidator();
        factory.close();
        return validator;
    }

    private static void printError (
                        ConstraintViolation<Task> violation) {
        System.out.println(violation.getPropertyPath() + " " + violation.getMessage());
    }
}

package com.logicbig.example;

import javax.validation.*;
import javax.validation.executable.ExecutableValidator;
import java.lang.annotation.*;
import java.lang.reflect.Constructor;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Set;

public class ConstructorReturnValidationExample {

    public static class Order {
        private final BigDecimal price;
        private final BigDecimal quantity;

        @ValidOrder
        public Order (BigDecimal price, BigDecimal quantity) {
            this.price = price;
            this.quantity = quantity;
        }

        public BigDecimal getPrice () {
            return price;
        }

        public BigDecimal getQuantity () {
            return quantity;
        }

        public BigDecimal getTotalPrice () {
            return (price != null && quantity != null ?
                    price.multiply(quantity) : BigDecimal.ZERO)
                    .setScale(2, RoundingMode.CEILING);
        }
    }

    public static void main (String[] args) throws NoSuchMethodException {
        Order order = new Order(new BigDecimal(4.5), new BigDecimal(10));
        Constructor<Order> constructor =
                            Order.class.getConstructor(BigDecimal.class, BigDecimal.class);

        Validator validator = getValidator();
        ExecutableValidator executableValidator = validator.forExecutables();
        Set<ConstraintViolation<Order>> constraintViolations =
                            executableValidator.validateConstructorReturnValue(constructor, order);

        if (constraintViolations.size() > 0) {
            constraintViolations.stream().forEach(
                                ConstructorReturnValidationExample::printError);
        } else {
            //proceed using order
            System.out.println(order);
        }
    }

    private static Validator getValidator(){
        Configuration<?> config = Validation.byDefaultProvider().configure();
        ValidatorFactory factory = config.buildValidatorFactory();
        Validator validator = factory.getValidator();
        factory.close();
        return validator;
    }

    private static void printError (
                        ConstraintViolation<Order> violation) {
        System.out.println(violation.getPropertyPath() + " " + violation.getMessage());
    }


    @Target({ElementType.CONSTRUCTOR, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Constraint(validatedBy = OrderValidator.class)
    @Documented
    public static @interface ValidOrder {
        String message () default "total price must be 50 or greater for online order. " +
                            "Found: ${validatedValue.totalPrice}";

        Class<?>[] groups () default {};

        Class<? extends Payload>[] payload () default {};
    }


    public static class OrderValidator implements ConstraintValidator<ValidOrder, Order> {
        @Override
        public void initialize (ValidOrder constraintAnnotation) {
        }

        @Override
        public boolean isValid (Order order, ConstraintValidatorContext context) {
            if (order.getPrice() == null || order.getQuantity() == null) {
                return false;
            }
            return order.getTotalPrice()
                        .compareTo(new BigDecimal(50)) >= 0;

        }
    }
}

package com.logicbig.example;

import javax.validation.*;
import javax.validation.constraints.Size;
import javax.validation.executable.ExecutableValidator;
import java.beans.IntrospectionException;
import java.lang.reflect.Method;
import java.util.Set;

public class MethodReturnValidationExample {

    private static class TestBean {
        @Size(min = 5)
        public int[] findNumbers () {
            return new int[]{1, 2, 3};
        }
    }

    public static void main (String[] args) throws NoSuchMethodException, IntrospectionException {
        TestBean test = new TestBean();
        int[] testNumbers = test.findNumbers();

        Method method = TestBean.class.getDeclaredMethod("findNumbers");

        Validator validator = getValidator();
        ExecutableValidator executableValidator = validator.forExecutables();
        Set<ConstraintViolation<TestBean>> violations =
                            executableValidator.validateReturnValue(test,
                                                method, testNumbers);


        if (violations.size() > 0) {
            violations.stream().forEach(MethodReturnValidationExample::printError);
        } else {
            //proceed using Order object
        }
    }

    private static Validator getValidator(){
        Configuration<?> config = Validation.byDefaultProvider().configure();
        ValidatorFactory factory = config.buildValidatorFactory();
        Validator validator = factory.getValidator();
        factory.close();
        return validator;
    }

    private static void printError (
                        ConstraintViolation<TestBean> violation) {
        System.out.println(violation.getPropertyPath() + " " + violation.getMessage());
    }
}