Question

我的应用程序中有一个逻辑，它取决于参数的类型，现在它的工作方式如下：

   switch (parameter.getType()) {
                case DOUBLE:
                    countOfParameters = parameter.getDoubleValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), parameter.getDoubleValue(0));
                    } else if (countOfParameters > 1) {
                        Double[] doubleValues = new Double[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            doubleValues[kj] = parameter.getDoubleValue(kj);
                        }
                        propertiesBuilder.addProperty(parameter.getName(), doubleValues);
                    }
                    break;
                case BOOLEAN:
                    countOfParameters = parameter.getBoolValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), parameter.getBoolValue(0));
                    } else if (countOfParameters > 1) {
                        Boolean[] booleanValues = new Boolean[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            booleanValues[kj] = parameter.getBoolValue(kj);
                        }
                        propertiesBuilder.addProperty(parameter.getName(), booleanValues);
                    }
                    break;
                case STRING:
                    countOfParameters = parameter.getStringValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), parameter.getStringValue(0));
                    } else if (countOfParameters > 1) {
                        String[] stringValues = new String[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            stringValues[kj] = parameter.getStringValue(kj);
                        }
                        propertiesBuilder.addProperty(parameter.getName(), stringValues);
                        break;
                    }
                case INTEGER:
                    countOfParameters = parameter.getIntValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), parameter.getIntValue(0));
                    } else if (countOfParameters > 1) {
                        Integer[] integerValues = new Integer[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            integerValues[kj] = parameter.getIntValue(kj);
                        }
                        propertiesBuilder.addProperty(parameter.getName(), integerValues);
                    }
                    break;
                case LOCALDATE:
                    countOfParameters = parameter.getStringValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), DateHelper.parseDate(parameter.getStringValue(0)));
                    } else if (countOfParameters > 1) {
                        LocalDate[] dateValues = new LocalDate[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            dateValues[kj] = DateHelper.parseDate(parameter.getStringValue(kj));
                        }
                        propertiesBuilder.addProperty(parameter.getName(), dateValues);
                    }
                    break;
            }

如您所见，我有相同的逻辑，唯一改变的地方是解析值的方法。是否可以消除重复的代码？我想可以制作一些Map of Functional Interface Function，但是不确定如何完成。有什么建议吗？

Answer 1

如果我对您的理解正确，那么可能是这样的：

Map<Type, Consumer<Builder>> map = Map.of(
     BOOLEAN, x -> x.add(BOOLEAN.parseBool()),
     STRING, x -> x.add(STRING.parseString())
);


map.get(type).accept(builder);

Answer 2

不确定需要什么，但是可以使用通用类型。

public class Element<T> {
    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

您可以在函数中使用

public Object parse(Element t){
    if( t.get() instanceof Boolean )
        return parseBoolean(t);
    else if ( t.get() instanceof String )
        return parseString(t);
}

Answer 3

首先，可以在枚举中完成DOUBLE-to-Double映射等等。

enum ValueType {
    DOUBLE(Double.class), // Or Double[].class
    BOOLEAN(Boolean.class),
    ...;

    public final Class<?> type;

    ValueType(Class<?> type) {
        this.type = type;
    }
}

很明显，代码已经太专业了，而实际上确切的类型却无关紧要。在这个级别上，一个值可能只是一个对象，而一个可能有Object[]。

因此，一些深度重构将是理想的。

ValueType vt = parameter.getType();
Class<?> t = vt.type;

Object array = Array.newInstance(t, countOfParameters);
// Actuallly Double[] or such.

int countOfParameters = parameter.getValueCount();
if (countOfParameters == 1) {
    propertiesBuilder.addProperty(parameter.getName(), parameter.getValue(0));
} else if (countOfParameters > 1) {
    Object array = Array.newInstance(t, countOfParameters);
    Class<?> componentT = array.getClass().getComponentType(); // == t

    Object[] values = new Object[countOfParameters];
    for (int kj = 0; kj < countOfParameters; kj++) {
        Array.set(array, kj, parameter.getValue(kj));
        values[kj] = parameter.getValue(kj);
    }
    propertiesBuilder.addProperty(parameter.getName(), values); // or array
}

我添加了一些反映代码（Array），希望不需要。

带有开关盒的复杂方法的分解

3 个答案: