Factory of generic type interfaces

Question

I am looking for some help in designing the factory of concrete implementations of a generic interface. Java version 7, can not use 8+

Given such interface and abstract class:

public interface ValidationStrategy<T> {

    String getNativeQuery();
    ValidationStrategy<T> withValue(T value);
}

public abstract class AbstractValidationStrategy<T> implements ValidationStrategy<T> {

    protected T value;

    public void setValue(T value) {
        this.value = value;
    }
}

I want to have multiple implementations of such interface like:

public class DocumentValidationStrategy extends AbstractValidationStrategy<String> {
    @Override
    public String getNativeQuery() {
        // here goes customer native query
        return null;
    }

    @Override
    public ValidationStrategy<String> withValue(String value) {
        setValue(value);
        return this;
    }
}

The ValidationStrategy would be decided upon predefined enum (interface, has to be cross-platform unified) by the, ideally, a factory. The problems are generics and I can not really go around them with nor I haven't crossed any question that would address my problem

public class ValidationStrategyFactory {

    private static final Map<CustomerValueValidationEnum, Class<? extends ValidationStrategy<?>>> validationStrategiesMap = new HashMap<>();

    {
        validationStrategiesMap.put(CustomerValueValidationEnum.VALIDATE_DOCUMENT, DocumentValidationStrategy.class);

    }

    private static Class<? extends ValidationStrategy<?>> getInstance(CustomerValueValidationEnum validationEnum) {
        return validationStrategiesMap.get(validationEnum);
    }

    public static ValidationStrategy<?> createInstance(CustomerValueValidationEnum validationEnum)
            throws IllegalAccessException, InstantiationException {
        return getInstance(validationEnum).newInstance();
    }

}

This obviously leads to problems where I can not create the proper implemntation of the ValidationStrategy interface due to my bad usage of java generics where I try to:

public boolean isValueUnique(CustomerValueValidationEnum type, Object value) {

    try {
        ValidationStrategyFactory.createInstance(type).withValue(value);
    } catch (IllegalAccessException | InstantiationException e) {
        throw new UnsupportedOperationException();
    }

    return false;
}

which obviously does not work as I can not feed value the way I want (value can be everything, a String, Integer or a List). I know that I am trying to combine factory and strategy patterns and I tried my best to combine both of them, I guess it is a bad pattern but now I do not really know how else can I create easily extensible validation mechanism that would only require me to create a single class.

EDIT: as requested, simple enum class that is shared between multiple services and it should not contain any business logic.

public enum CustomerValueValidationEnum {

    VALIDATE_DOCUMENT("validateDocumentNumber")
    ;

    private final String name;

    private CustomerValueValidationEnum(String name) {
        this.name = name;
    }

    @ValueMapKey
    public String getName() {
        return this.name;
    }
}

Answer 1

One workaround is using a way to get each generic type strategy with a separate method getting from a separate map.

The lower number of various strategy generic types, the more appropriate this way is.

public class StrategyFactory {
        
    static final Map<CustomerValueValidationEnum, ValidationStrategy<String>> validationStringStrategiesMap = new HashMap<>() {{
        validationStringStrategiesMap.put(CustomerValueValidationEnum.VALIDATE_DOCUMENT_STRING, new DocumentStringValidationStrategy());
    }};

    static final Map<CustomerValueValidationEnum, ValidationStrategy<Integer>> validationIntegerStrategiesMap = new HashMap<>() {{
        validationIntegerStrategiesMap.put(CustomerValueValidationEnum.VALIDATE_DOCUMENT_INTEGER, new DocumentIntegerValidationStrategy());
    }};   
     
    public static ValidationStrategy<String> stringStrategy(CustomerValueValidationEnum e) {
        return validationStringStrategiesMap.get(e);
    }

    public static ValidationStrategy<Integer> integerStrategy(CustomerValueValidationEnum e) {
        return validationIntegerStrategiesMap.get(e);
    }
}

public class DocumentStringValidationStrategy extends AbstractValidationStrategy<String> { ... }

public class DocumentIntegerValidationStrategy extends AbstractValidationStrategy<Integer> { ... }

Advantages:

• The generic type will be always inferred: StrategyFactory.integerStrategy(null).withValue(1); which means the user-call is very comfortable.
• Scales with a low number of generic types: 2 generic type of strategies -> 2 maps -> 2 methods.

Disadvantage:

• The user must know if the String-type or Integer-type is to be requested.
• Doesn't scale with a high number of generic types: if each strategy has a custom type, then this solution will not help you at all.

Characteristics:

• Not null-safe, the map can return null (I'd use null-object pattern for safe behavior). This would be issue even in any of your solutions

Answer 2

It is impossible to type dynamically any generic type as it's checked during compilation. I suggest you to make your factory switch on your enum (using/or not a Map).

Implementation without Map :

enum CustomerValueValidationEnum { // Not provided by OP
    VALIDATE_DOCUMENT,
    VALIDATE_NUMBER
}

interface ValidationStrategy<T> {
    String getNativeQuery();
    ValidationStrategy<T> withValue(T value);
}

abstract class AbstractValidationStrategy<T> implements ValidationStrategy<T> {
    protected T value;

    public void setValue(T value) {
        this.value = value;
    }
 
    @Override
    public String getNativeQuery() {
        return null;
    }

    @Override
    public ValidationStrategy<T> withValue(T value) {
        setValue(value);
        return this;
    }
}

class DocumentValidationStrategy<T> extends AbstractValidationStrategy<T> {
    @Override
    public String getNativeQuery() {
        return "Customer Query";
    }
}

class ValidationStrategyFactory {

    // Generic types are checked during compilation time, can't type it dynamically
    public static ValidationStrategy<?> createInstance(CustomerValueValidationEnum validationEnum) {
        ValidationStrategy valStrat = null;
        switch(validationEnum) {
            case VALIDATE_DOCUMENT:
                valStrat = new DocumentValidationStrategy<String>();
            case VALIDATE_NUMBER:
                valStrat = new DocumentValidationStrategy<Integer>();
        }
        return valStrat;
    }
}

Implementation with Map :

import java.util.HashMap;
import java.util.Map;

enum CustomerValueValidationEnum { // Not provided by OP
    VALIDATE_DOCUMENT(String.class),
    VALIDATE_NUMBER(Integer.class);

    private Class validationType;
    CustomerValueValidationEnum(Class cls) {
        validationType = cls;
    }

    public Class getValidationType() {
        return validationType;
    }
}

interface ValidationStrategy<T> {
    String getNativeQuery();
    ValidationStrategy<T> withValue(T value);
}

abstract class AbstractValidationStrategy<T> implements ValidationStrategy<T> {
    protected T value;

    public void setValue(T value) {
        this.value = value;
    }

    @Override
    public String getNativeQuery() {
        return null;
    }

    @Override
    public ValidationStrategy<T> withValue(T value) {
        setValue(value);
        return this;
    }
}

class DocumentValidationStrategy<T> extends AbstractValidationStrategy<T> {
    @Override
    public String getNativeQuery() {
        return "Customer Query";
    }
}

class ValidationStrategyFactory {
    private static final Map<Class, ValidationStrategy> validationStrategiesMap = new HashMap<>();
    {
        validationStrategiesMap.put(String.class, new DocumentValidationStrategy<String>());
        validationStrategiesMap.put(Integer.class, new DocumentValidationStrategy<Integer>());
    }

    private static ValidationStrategy<?> getInstance(CustomerValueValidationEnum validationEnum) {
        return validationStrategiesMap.get(validationEnum.getValidationType());
    }
}

You can't use generic type through enum (without implementing an interface) : Post
You can't type dynamically any generic type : Post