Different types of model validation
You could use the composite pattern to create a tree of Validator instances. Each node would validate its with its own Validator before delegating to children (if any). This way children don't need to check again what was already validated in parent nodes

public class ValidatorTree&lt;T&gt; implements Validator&lt;T&gt; {

    private Validator&lt;? super T&gt; node;
    private List&lt;Validator&lt;? super T&gt;&gt; children;

    // constructor etc. snipped for brevity

    @Override
    public void validate(T t) {
        node.validate(t);
        for (Validator&lt;? super T&gt; child : children) {
            child.validate(t);
        }
    }
}


This way you can bundle several validators into one (so only one root validator needs to be referenced). And validation order is guaranteed, so no need to perform duplicate checks.

Edit (in response to comment)

A Validator for Model1 may very well be different from a Validator for Model2. If Validators are to be reused for different models you can define interfaces that define the common parts to be validated.

e.g.

public interface Named {

    String getName();
}


and a matching NameNotNullValidator : 

public class NameNotNullValidator implements Validator&lt;Named&gt; {
    @Override
    public void validate(Named named) {
        if (named.getName() == null) {
            throw new ValidationException(/* appropriate message here */);
        }
    }
}


And this Validator can be reused in validator trees for all models that implement Named. Note that I adapted the generics in ValidatorTree for this.