根据自定义验证规则验证Java Bean的最佳方法是什么？

Question

public class User {
    private String name;
    private Integer age;
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return this.age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

Here I want to validate these fields using custom rule set defined in database for each field.

eg validate length of name field - length validation can be different for different companies.

Scenario : For company x, max length of name field can be 20. For company y, max length of name field can be 30. How to apply this validation criteria runtime?

Answer 1

I see at least two approaches

BeanValidation

Annotate field of your domain object (one you need to validate, User in your case) with annotations from javax.validation.constraints package https://docs.oracle.com/javaee/7/api/javax/validation/constraints/package-summary.html

To perform validation ,you need to obtain instance of javax.validation.Validator and use it.

Sample code

void validate() {
        LocalValidatorFactoryBean localValidatorFactoryBean = new LocalValidatorFactoryBean();
        Set<ConstraintViolation<Msisdn>> violations = localValidatorFactoryBean.getValidator().validate(this);
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
    }

It requires Spring Framework. Note that constructing LocalValidatorFactoryBean is costly process.

Generally, LocalValidatorFactoryBean should be constructed once, at application startup.

javax.xml.validation.Validator should be @Autowired where needed.

Spring Framework+Spring Boot will manage all those details for you.

It is also possible to use java validation without Spring. Mandatory component is Validation Provider (JDK defines just interfaces, no implementation). Hibernate Validator is sample validation provider.

In this approach, you can perform your validation only in Spring-managed classes (services, controllers, etc).

This is not feasible solution for validating in constructor, in static methods.

Guava preconditions

I used that when I was in need to perform validation from constructor.

See Preconditions from Guava library https://github.com/google/guava/wiki/PreconditionsExplained

It exposes functions like

 Preconditions.checkNotNull(value, "value cannot be null");
 Preconditions.checkArgument(..)

You could validate arguments in setters, constructor, build() method in your builders- every time where object building is finished and invariants need to be checked.

In this scenario just Guava Library is required. It is not related to Java Validation API or implementation.

Conditional validation

If you want your validation to depend on the context (not just on the class you are validating) then validation rules shoud not be placed on the class you are validating.

In Spring you could write Validator as external class.

public class PersonValidator implements Validator {

    public boolean supports(Class clazz) {
        return Person.class.equals(clazz);
    }

    public void validate(Object obj, Errors e) {
        ValidationUtils.rejectIfEmpty(e, "name", "name.empty");
        Person p = (Person) obj;
        if (p.getAge() < 0) {
            e.rejectValue("age", "negativevalue");
        } else if (p.getAge() > 110) {
            e.rejectValue("age", "too.darn.old");
        }
    }
}

See http://docs.spring.io/spring/docs/current/spring-framework-reference/html/validation.html#validator for more details.

Same principle (external class with validation logic) could be applied for Guava.

Then in your business logic you will be able to choose and use correct Validator.