帮助重构：引入参数对象？

Question

我有一些相同的代码，除了特定的分配顺序以稍微不同的顺序发生之外。

很容易将其分解为 int[] 类型的方法参数，它表示顺序。

然而，我发现这并不是最清楚的。

另一种选择是将它们分解为 AssignmentOrders 类型的对象。我还可以对对象构造函数中的值进行验证，而我无法对数组进行验证。这就是《重构》一书中的“引入参数对象”重构。

我想知道这种特殊的重构是否过度，我应该坚持使用 int[] 吗？

代码：

原始的三个示例：

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections) 
            throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[0].trim();
        String value2 = sections[1].trim();
        String value3 = sections[4].trim();
        String value4 = sections[2].trim();
        String value5 = sections[3].trim();

        //........
    }

private static PersonDetails parseLine(String line, String deliminator) 
            throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[1].trim();
        String value2 = sections[0].trim();
        String value3 = sections[2].trim();
        String value4 = sections[3].trim();
        String value5 = sections[4].trim();

        //........
    }

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections)


        throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[0].trim();
        String value2 = sections[1].trim();
        String value3 = sections[2].trim();
        String value4 = sections[4].trim();
        String value5 = sections[5].trim();

        //........
    }

我如何将上述 3 个重构为：

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections) 
            throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[orderOfSections[0]].trim();
        String value2 = sections[orderOfSections[1]].trim();
        String value3 = sections[orderOfSections[2]].trim();
        String value4 = sections[orderOfSections[3]].trim();
        String value5 = sections[orderOfSections[4]].trim();

        //........
    }

理论上我如何将其重构为参数对象：

private static PersonDetails parseLine(String line, String deliminator, OrderOfSections order) 
        throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[order.getValue1Idx].trim();
        String value2 = sections[order.getValue2Idx].trim();
        String value3 = sections[order.getValue3Idx].trim();
        String value4 = sections[order.getValue4Idx].trim();
        String value5 = sections[order.getValue5Idx].trim();

        //........
    }

我想做的是创建一个特定的类，而不是使用 int[]...但想知道这是否太过分了。

好处是它会更具可读性。它可能不是 orderOfSections[0]，而是 orderOfSections.value1SectionIdx...我还可以将一些验证代码放入类中。

我相信这就是 Martin Fowler 所说的引入参数对象。

编辑：

另一种选择是使用字典。比新类更轻量，但更具描述性...然后我可以使用类似 orderOfSections["value1"]

Answer 1

我将委托解析输入Class或数组来简单地指示原始String中项目的顺序以及它们应该如何分配，而不是传递Class或数组。 code>line 到这个Class。执行以下操作会更具可读性：

private static PersonDetails parseLine(String line, String deliminator, 
                         SectionsReader reader) throws Exception 
{
    reader.setLine(line);
    String value1 = reader.getValue1();
    String value2 = reader.getValue2();
    String value3 = reader.getValue3();
    String value4 = reader.getValue4();
    String value5 = reader.getValue5();

    //........
}

最后，这不会太过分，3 个月后，当您返回此代码并发现它更容易理解时，您会感谢自己。

Answer 2

恕我直言，最简单、最易读的方法是传递映射而不是 int 数组。

根据 PersonDetails 字段的外观，您甚至可以使用反射并在循环中分配值。