Question

我具有以下格式的数据/块：

零件>子零件>部分>子部分

其中“ A> B”表示A包含列表B（组成，不继承）。我为每个“级别”编写了不可变的类：

Part.java
SubPart.java
Section.java
摘要 SubSection.java（有许多特定的SubSections可用，我也为它们编写了不可变的类：SubSectionTypeA，SubSectionTypeB，...）

这些数据可以在不同的（大）文件中以特定格式使用，这些文件遵循我刚才给出的结构。我必须在我的API中提供方便的方法/类来解析这些文件，并创建不可变部件（由由Section等组成的SubPart组成）的单个/多个实例。随之而来的问题是：

我应该如何根据这些需求来组织课程？

我尝试了两种方法，但是它们似乎很有限（我写它们来说明我的需求）：

第一种方法

提供仅包含一个公共方法和许多私有方法的Utility类来解析文件并实例化不可变Part类：

public final class Parser {
/**
 * No Parser instance
 */
private Parser() {}

/**
 * Parsing method
 */
public static Part parse(Path path) throws IOException
{
    //Get reader
    BufferedReader br = Files.newBufferedReader(path);
    //Some parsing methods for Part with br.readLine()
    List<SubPart> subParts = new ArrayList<>();
    while (condition) {
        subParts.add(parseSubPart(br));
    }
    return new Part(subParts);
}

private static SubPart parseSubPart(BufferedReader br)
{
    //...
    //Parsing with same loop for Section
    while (condition) {
        sections.add(parseSection(br))
    }
    return new SubPart(sections);
}

private static Section parseSection(BufferedReader br)
{
    //...
    //Parsing subSections
    while (condition) {
        switch (value) {
            case A:
                subSections.add(parseSectionTypeA(br));
                break;
            case B:
                subSections.add(parseSectionTypeB(br));
                break;
            //...
        }
    }
    return new Section(subSections);
}

//A good amount of convenient method for parsing each subSectionType (~100)
private static SubSectionTypeA parseSubSectionTypeA(BufferedReader br)
{
    //...
}

private static SubSectionTypeB parseSubSectionTypeB(BufferedReader br)
{
    //...
}

//and so on
}


}

这种方法的主要问题是，它提供了一个巨大的（静态）类，而且我知道如果结构的任何“块”的格式发生更改，维护此类都将遇到很多困难。

第二种方法

提供许多实用程序类（每个实用程序类仅处理一种类型的“块”）

//---File PartParser.java---
public final class PartParser
{
    /**No instance*/
    private PartParser(){}
    /** Parsing method*/
    public static Part parse(BufferedReader br)
    {
        //...
        //Parsing
        while (condition) {
        subParts.add(SubPartParser.parse(br));
        }
        return new Part(subParts);
    }
}
//---File SubPartParser.java---
public final class SubPartParser
{
    /**No instance*/
    private SubPartParser(){}
    /**Parsing method*/
    public static SubPart parse(BufferedReader br)
    {
        //Parsing with call for SectionParser.parse(br)
        return new SubPart(sections)
    }
}
//--- File SectionParser.java---
// and so on

这种方法的主要问题是它提供了100多个实用程序类。第二个问题，如果在解析subsection时使用一种方法来解析任何subsectiontype，则无法使用继承定义每个SubSectionParser所通用的方法（为此，我考虑将这些类重构为单身人士，但这似乎是一个过大的杀伤力，我敢肯定这不是个好方法。

最终，每种方法的结构都较差，如果我必须添加一个新的“块”，那么这很容易出错（我会错过subSection开关中的一个，在2年的时间里，我不会记得必须创建一个不变的类和此块的（静态？）解析器类，...）。

您能帮我找到适合我需求的图案/结构吗？谢谢

如何组织类：不可变的实例/解析器？

0 个答案: