泛型类型接口的工厂

Factory of generic type interfaces

提问人：Lisek 提问时间：9/7/2020 最后编辑：Lisek 更新时间：9/9/2020 访问量：337

问：

我正在寻找一些帮助来设计通用接口的具体实现工厂。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();
    }

}

这显然会导致一些问题，即由于我对 java 泛型的不当使用，我无法创建接口的正确实现，我尝试：ValidationStrategy

public boolean isValueUnique(CustomerValueValidationEnum type, Object value) {

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

    return false;
}

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

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

public enum CustomerValueValidationEnum {

    VALIDATE_DOCUMENT("validateDocumentNumber")
    ;

    private final String name;

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

    @ValueMapKey
    public String getName() {
        return this.name;
    }
}
java 泛型 反射 工厂模式 原始类型

评论

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

答：

0赞 IQbrod 9/9/2020 #1

不可能动态键入任何泛型类型，因为它在编译过程中会进行检查。我建议你让你的工厂打开你的枚举（使用/或不使用Map）。

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

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

你不能通过（没有实现接口）使用泛型类型：Post 你不能动态键入任何泛型类型：Post
enum

评论

1赞 Nikolas Charalambidis 9/9/2020
OP说“不能使用8+”，所以方法不占一席之地。default
1赞 IQbrod 9/9/2020
是的，谢谢，这并不重要，因为它可能在抽象类中实现:)
0赞 Nikolas Charalambidis 9/9/2020 #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 个方法。

缺点：

  • 用户必须知道是请求 -type 还是 -type。StringInteger
  • 不能使用大量泛型类型进行扩展：如果每个策略都有自定义类型，那么此解决方案根本无济于事。

特点：

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

上一个：Kotlin 嵌套多泛型类型类到 Java 嵌套原始类型

下一个：简单的面试问题变得更难：给定数字 1..100，找到正好给定 k 的缺失数字