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

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 中项目的顺序以及应如何分配它们的数组，而是将输入 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 字段的外观，您甚至可以使用反射并在循环中分配值。