集合中具有不同通用值的类型安全

Question

Suppose I have an interface like this;

interface Validator<T>{
    void validate<T value>    
}

And these implementations ;

class StringValidator implements Validator<String>{
    void validate<String value>{}
}
class OrderValidator implements Validator<Order>{
    void validate<Order value>{}
}

In ValidatorRegisterer class I have a map;

class ValidationRegisterer{
    Map<String, Validator> validatorsForPath = new HashMap<String, Validator>();

    public Map<String, Validator> registerers(){
        return validatorsForPath;
    }

    public void register(String path, Validator validator){
        validatorsForPath.put(path, validator);
    }
}

What I want is to iterate over this map in ValidationManager class with type safety;

class ValidationManager<RootObject>{
    List<ValidationRegisterer> validationRegisterers;

    public ValidationManager(List<ValidationRegisterer> validationRegisterers){
        this.validationRegisterers = validationRegisterers;
    }

    public void validate(RootObject object){
        for(ValidationRegisterer validationRegisterer in validationRegisterers){

            for(String path : validationRegisterer.keySet()){

                Object value = object.getPath(path);
                Validator validator = validationRegisterer.get(path);
                validator.validate(value);
                //this line gets unchecked call to validate(T) warning and I want to get rid of it
                //the problem is validationRegisterers map can contain both StringValidator and OrderValidator, 
                //so the value can be a String or an Order
                //do I have to cast the value to the type of validator's T type?
            }
        }
    }

    Map<String, Validator> validatorsForPath = new HashMap<String, Validator>();
}

I tried to explain the situation in the last code sample comments.

Answer 1

Declare as follows to remove warnings :

Validator<Object> validator = validationRegisterer.get(path);

In this case you are declaring the validator reference that would work on Object type. later you can typecast to Order or String after doing an instanceof test.

Answer 2

You need to make ValidationRegisterer class generic like this:

class ValidationRegisterer<T extends Validator> {
    Map<String, T> validatorsForPath = new HashMap<String, T>();

    public Map<String, T> registerers(){
        return validatorsForPath;
    }

    public void register(String path, T validator){
        validatorsForPath.put(path, validator);
    }
}

And then maintain separate lists for these two types of ValidationRegisterer

class ValidationManager {
    List<ValidationRegisterer<StringValidator>> strValidationRegisterers;
    List<ValidationRegisterer<OrderValidator>> ordValidationRegisterers;
    ....  
}

Answer 3

I will assume that with "type safety" you mean that you want to be certain that the object returned for a certain path is really of the type that the associated Validator accepts.

One problem is that the type parameter for the Validator is not available at compile time since, as you say yourself, any kind of Validator can be in the map.

Also, object.getPath(path) will always return an Object which will always need casting at runtime, so the fact that the validate method limits its argument to type T is of little use.

So the best you can do is make validation fail fast in case the object is not of the correct type.

A solution would be to 1. store the Class object for the Validator , 2. let validate accept an Object as parameter and dynamically cast the object to the validator type at the beginning of the validate method. This can be done in an abstract base class.

Example:

interface Validator<T> {
    void validate(Object value);
    Class<T> getType();
}

abstract class BaseValidator<T> implements Validator<T> {
    private final Class<T> type;
    public BaseValidator(Class<T> type) {
        this.type = type;
    }

    public final void validate(Object o) {
       doValidate(type.cast(o)); // wrong type will fail fast here
    }

    public final Class<T> getType() {
        return type;
    }

    protected abstract void doValidate(T value);
}

class StringValidator extends BaseValidator<String> {
    public StringValidator() {
        super(String.class);
    }

    protected void doValidate(String value) {
        // do actual string validation here
    }
}

An alternative solution if you want to keep Object out of the Validator interface would be to let the path be resolved by a type parameterized object that has a reference the validator and performs the dynamic cast, and keep that in your registry map as value:

interface Validator<T> {
    void validate(final T value);
}

class PathValidator<T> {
    private final Class<T>     type;
    private final Validator<T> validator;

    public PathValidator(final Class<T> type, final Validator<T> validator) {
        this.type = type;
        this.validator = validator;
    }

    public void validate(final RootObject object, final String path) {
        T value = type.cast(object.getPath(path)); // throws ClassCastException here if not the correct type
        validator.validate(value);
    }
}

You would then have a Map<String, PathValidator<?> in your ValidationRegisterer class.

I'd personally prefer this alternative solution.