泛型接口工厂答案

【问题标题】：Factory of generic type interfaces泛型接口工厂
【发布时间】：2020-12-25 17:46:52
【问题描述】：

我正在寻求一些帮助来设计通用接口的具体实现工厂。 Java版本7，8+不能用

给定这样的接口和抽象类：

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;
    }
}

我想要这样的接口的多个实现，例如：

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;
    }
}

理想情况下，工厂将根据预定义的枚举（接口，必须跨平台统一）决定ValidationStrategy。这些问题是泛型的，我无法真正解决它们，也没有遇到任何可以解决我的问题的问题

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();
    }

}

这显然会导致我无法正确实现 ValidationStrategy 接口的问题，因为我尝试使用 java 泛型的错误：

public boolean isValueUnique(CustomerValueValidationEnum type, Object value) {

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

    return false;
}

这显然不起作用，因为我无法以我想要的方式提供价值（value 可以是一切，String、Integer 或 List）。我知道我正在尝试将工厂模式和策略模式结合起来，并且我尽力将它们结合起来，我想这是一个糟糕的模式，但现在我真的不知道我还能如何创建只需要的易于扩展的验证机制我创建一个类。

编辑：根据要求，在多个服务之间共享的简单枚举类，它不应包含任何业务逻辑。

public enum CustomerValueValidationEnum {

    VALIDATE_DOCUMENT("validateDocumentNumber")
    ;

    private final String name;

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

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

【问题讨论】：

能否请您也提供CustomerValueValidationEnum 的代码？也许将 ValidationStrategy 创建和验证枚举结合起来会更好。
我想在CustomerValueValidationEnum 中创建对象，但这来自接口包，它不得包含任何业务逻辑。此枚举位于 interface 包中，它看不到任何 ValidationStrategy 类。
“这显然行不通，因为我无法以我想要的方式提供价值”；那么问题是您希望每个 ValidationStrategy 都支持所有类型的值，还是希望类型安全，因此您只能使用 ValidationStrategy 接受的相应值调用 isValueUnique？
我希望 ValidationStrategy 肯定支持所有类型的值，但我不明白关于类型安全的问题的第二部分。
由于enum 不支持每个常量有不同的类型参数，这不起作用。有 a JEP suggesting such a support，但对于 Java 7（以及当前 14 之前的所有其他版本），你就不走运了。

标签： java generics reflection factory-pattern raw-types

【解决方案1】：

不可能动态键入任何泛型类型，因为它是在编译期间检查的。我建议你在你的枚举上设置你的工厂开关（使用/或不使用地图）。

没有地图的实现：

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;
    }
}

使用地图实现：

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());
    }
}

您不能通过enum 使用泛型类型（不实现接口）：Post
您不能动态输入任何泛型类型：Post

【讨论】：

OP 说“不能使用 8+”，所以 default 方法不占位。
是的，谢谢，这并不重要，因为它可能在抽象类中实现:)

【解决方案2】：

一种解决方法是使用一种方法来获取每个泛型类型策略，并使用从单独映射中获取的单独方法。

各种策略泛型的数量越少，这种方式越合适。

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> { ... }

优势：

将始终推断出泛型类型：StrategyFactory.integerStrategy(null).withValue(1);，这意味着用户调用非常舒适。
使用少量泛型类型进行扩展：2 种泛型策略类型 -> 2 种地图 -> 2 种方法。

缺点：

用户必须知道是请求String-type 还是Integer-type。
无法使用大量泛型类型进行扩展：如果每个策略都有自定义类型，那么此解决方案对您毫无帮助。

特点：

不是空安全的，地图可以返回null（我会使用空对象模式来保证安全行为）。即使在您的任何解决方案中，这都会成为问题

【讨论】：