用 Java 设计一个智能的自定义类 csv 解析器

Question

问题描述

我想重构一个解析器，使其具有灵活的类似 csv 格式的格式，该格式描述了第一行中的列。根据这些信息，我希望解析器构建具有简单属性但也具有复杂属性的对象，例如 List<String>（空格分隔），例如 Things：

示例数据类型

import java.util.List;

public class Thing {
    protected int           foo;
    protected String        bar
    protected List<String>  baz;

    public Thing(int foo, String bar, List<String> baz) {
        this.foo = foo;
        this.bar = bar;
        this.baz = baz;
    }

    public String toString() {
        return "foo: " + foo + ", bar: " + bar + ", baz: " + baz;
    }
}

解析器的输入将是文本文件，第一行有列行（逗号分隔），下一行有n 中的数据（逗号分隔）。为了简化测试，我将使用Iterator<String> 作为输入行。这个简单的测试应该说明我想要构建什么：

JUnit 测试

// prepare example string iterator
List<String> lines = new ArrayList<String>();
lines.add("bar,baz,foo");
lines.add("yay,quux quuux,17");
lines.add("hey,qaax qaaax,42");

// test parsed things
List<Thing> things = ThingBuilder.buildThings(lines.iterator());
assertNotNull(things);
assertEquals(2, things.size());
assertEquals("foo: 17, bar: yay, baz: [quux, quuux]", things.get(0).toString());
assertEquals("foo: 42, bar: hey, baz: [qaax, qaaax]", things.get(1).toString());

最简单的方法

1. 读取第一行并将其拆分为列名
2. 阅读所有其他行并对其执行以下操作：
   • 用标记分割行
   • 循环遍历它们：
     • 对于令牌i 做一个大的switch/else if 列名i 到
     • 转换令牌i
     • 将提取的值存储在某处
   • 收集一切并建立一个Thing
3. 完成。

我对这种方法的问题是内部开关。处理完第一行，应该就清楚如何解析行了。

我想要什么

在带有闭包的语言中，我会尝试以下方法：

1. 读取第一行并将其拆分为列名
2. 为每个列名创建一个闭包，为给定标记设置正确的值并将其添加到 解析器闭包数组
3. 阅读所有其他行并对其执行以下操作：
   • 用标记分割行
   • 循环遍历它们：
     • 使用令牌i调用解析器闭包i
   • 收集一切并建立一个Thing
4. 完成。

我尝试了什么

我为所有三个令牌解析器提供了一个简单的接口。他们应该获得一个令牌并将生成的值注入给定的ThingBuilder 的缓存中：

public interface TokenParser {
    public void parse(String token, ThingBuilder builder);
}

public class FooParser implements TokenParser {
    @Override public void parse(String token, ThingBuilder builder) {
        builder.setFoo(Integer.parseInt(token));
    }
}

public class BarParser implements TokenParser {
    @Override public void parse(String token, ThingBuilder builder) {
        builder.setBar(token);
    }
}

import java.util.ArrayList;
import java.util.List;
public class BazParser implements TokenParser {
    @Override public void parse(String token, ThingBuilder builder) {
        List<String> baz = new ArrayList<String>();
        for (String s : token.split(" ")) baz.add(s);
        builder.setBaz(baz);
    }
}

我的ThingBuilder 的buildThings 方法是静态的，并在内部创建一个ThingBuilder 对象，构造函数获取第一（列）行。这也是填充令牌解析器列表的地方。在此之后隐藏的ThingBuilder 对象已准备就绪，并使用以下输入行重复调用buildThing 方法以创建Things 列表：

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

public class ThingBuilder {

    // single column parsers
    protected List<TokenParser> columnParsers;

    // thing attribute cache
    protected int           fooCache;
    protected String        barCache;
    protected List<String>  bazCache;

    // thing attribute cache setter
    public void setFoo(int          foo) { fooCache = foo; }
    public void setBar(String       bar) { barCache = bar; }
    public void setBaz(List<String> baz) { bazCache = baz; }

    // cleanup helper method
    protected void cleanup() {
        setFoo(0); setBar(null); setBaz(null);
    }

    // statically build a list of things from given lines
    public static List<Thing> buildThings(Iterator<String> lines) {

        // prepare builder with the first line
        ThingBuilder builder = new ThingBuilder(lines.next());

        // parse things
        List<Thing> things = new ArrayList<Thing>();
        while (lines.hasNext()) {
            things.add(builder.buildThing(lines.next()));
        }
        return things;
    }

    // prepares a builder to parse thing lines
    protected ThingBuilder(String columnLine) {

        // split line into columns
        String[] columns = columnLine.split(",");

        // prepare a parser for each column
        columnParsers = new ArrayList<TokenParser>();
        for (String column : columns) {
            TokenParser parser;
            if      (column.equals("foo")) parser = new FooParser();
            else if (column.equals("bar")) parser = new BarParser();
            else if (column.equals("baz")) parser = new BazParser();
            else throw new RuntimeException("unknown column: " + column);
            columnParsers.add(parser);
        }
    }

    // builds a thing from a string
    protected Thing buildThing(String line) {

        // split the line in tokens
        String[] tokens = line.split(",");

        // let the parsers do the work
        for (int i = 0; i < tokens.length; i++) {
            columnParsers.get(i).parse(tokens[i], this);
        }

        // hopefully they're done
        Thing thing = new Thing(fooCache, barCache, bazCache);
        cleanup();
        return thing;
    }
}

这可行，但是：

我不喜欢我的解决方案的地方

• 感觉很复杂！
• 公共缓存设置器。应该只允许 TokenParsers 填充构建器缓存。
• 如果我有多个包含int 的列怎么办？我必须为每一列构建一个解析器类还是可以多次使用 IntegerParser 类？这里的问题是，解析器必须调用正确的缓存设置方法。

提前感谢您的提示！

Answer 1

就个人而言，我不会走这条路。有一些通用框架可以很好地完成这类事情，并允许自定义扩展点。

例如，考虑流行的OpenCSV 项目：

http://opencsv.sourceforge.net/#javabean-integration

或者，如果您需要注释，请考虑 JFileHelpers

http://jfilehelpers.com/index_en.php

或JSefa

http://jsefa.sourceforge.net/quick-tutorial.html#CSV

Answer 2

我同意@btiernay 的回答，但如果您想推出自己的实现，请继续阅读...

---

公共缓存设置器。应该只允许 TokenParsers 填充构建器缓存。

是的。这是TokenParser API 的结果，以及它通过在ThingBuilder 上调用setter 来“返回”值的方式。事实上，这比你已经确定的后果更糟。也就是说：您的TokenParser API 和所有TokenParser 类都特定于一个且只有一个ThingBuilder 类。它们不可重复使用...

我认为使用这样的 API 会更好：

  public interface TokenParser<T> {
      public T parse(String token);
  }

如果我有多个包含 int 的列怎么办？我是否必须为每列构建一个解析器类，或者是否可以多次使用 IntegerParser 类？这里的问题是，解析器必须调用正确的缓存设置方法。

是的。

接下来创建一个 RowBuilder 接口：

  public interface RowBuilder<R>
      public R buildRow(List<String> tokens);
  }

这里有一个棘手的地方 --- 创建一个看起来像这样的通用 RowBuilder 类：

  public class GenericRowBuilder<R> implements RowBuilder<R> {
      public GenericRowBuilder(Class<R> clazz, TokenParser<?>[] parsers) {
          // Extract the return types of the reified parse objects' `parse` 
          // methods, and use this to locate a matching `Constructor<R>` in 
          // `clazz`.  If there isn't one, throw an exception.
          this.clazz = clazz;
          this.parsers = parsers;
      }
      public R parse(List<String> tokens) {
          // Check number of tokens matches number of parsers.
          // Parse each token with corresponding parsers.
          // Use the `Constructor<R>` found above to create the instance of `R`
      }
  }

现在这一切都相当复杂......并且需要对你有很好的理解才能使用 Java 的反射 API......但最终结果是你可以像这样为你的类实例化一个 RowBuilder：

  RowBuilder<MyRow> rb = new GenericRowBuilder<MyRow>(MyRow.class,
      new TokenParser<?>[]{
          new IntTokenParser(), new FloatTokenParser(), new CustomTokenParser});

你有一些东西会：

• 检查是否为正确的字段使用了正确的类型，
• 检查每行中的值的数量，并为每列值使用正确的解析器，并且
• 使用任何行类R，只要它有合适的构造函数。