Question

我正在尝试重构一些旧代码。这里的任务是根据一些类似于以下内容的预定义模板构造冗长的消息/字符串：

field1,8,String
filed2,5,Integer
field3,12,String
......

然后，我将获得具有所有这些字段的java对象。这里要做的只是从对象字段中获取数据，并使用它们基于模板构造长消息/字符串。这些字段中的某些字段也可以根据一些简单规则进行转换。例如：

abc => a
def => d
ghi => g

因此，我们需要不时检查这些字段的值。还有关于填充的规则（通常在右侧添加空白空间）。因此，构造的消息/字符串可能如下所示：

uater   4751 enterprise  ......

当前，我们只是在使用野蛮力量来完成这项工作。首先，我们将模板输入到ArrayList中，每个元素都是一行，例如“ field1,8，String”。在实际的消息构造过程中，我们遍历此ArrayList，然后将数据填充到StringBuffer中。这是一些示例片段

StringBuffer message = new StringBuffer(1000);
for (String field : templateFields) {
    String[] fieldArray = field.split(Constants.SEPARATOR);
    if (fieldArray[0].equalsIgnoreCase(Constants.WORKFLOW)) {
        message.append(rightPad(object.getFieldOne(), Integer.parseInt(fieldArray[1])));
    } else if (fieldArray[0].equalsIgnoreCase(Constants.WORKVOLUME)) {
        message.append(rightPad(object.getFieldTwo(), Integer.parseInt(fieldArray[1]));
    } else if (fieldArray[0].equalsIgnoreCase(Constants.WORKTYPE)) {
        if (object.getFieldThree().equalsIgnoreCase("abc")) {
             message.append(rightPad("a", Integer.parseInt(fieldArray[1]));
        } else if (object.getFieldThree().equalsIgnoreCase("def")) {
             message.append(rightPad("d", Integer.parseInt(fieldArray[1]));
        } else {
            message.append(rightPad("g", Integer.parseInt(fieldArray[1]));
        }
    } else if ......
}

正如您所看到的那样，它虽然很荒谬，却能完成工作。但是，这样的代码容易出错，并且难以维护。我想知道你们是否有推荐的任何工具或库或一些优雅的解决方案。
非常感谢！华

Answer 1

如果我正确理解您的问题，则可以采用一种方法来遍历可能的templateFields。没必要。

由于将每个fieldArray[0]与某些Constants值进行了比较，并且在进一步处理匹配项的情况下，我们可以用Map替换for循环。它的键是可能的Constants值，而它的值是映射器。映射器是BiFunction，它使用object和值fieldArray[1]，并为它们返回类型为String的消息。

让我们从映射器开始：

public class FieldToMessageMapper {

    private static final Map<String, Function<String, String>> WORKINGTYPE_MESSAGE_MAPPER = new HashMap<>();
    static {
      WORKINGTYPE_MESSAGE_MAPPER.put("abc", fieldArray1 -> rightPad("a", Integer.parseInt(fieldArray1)));
      WORKINGTYPE_MESSAGE_MAPPER.put("def", fieldArray1 -> rightPad("d", Integer.parseInt(fieldArray1)));
      WORKINGTYPE_MESSAGE_MAPPER.put("DEFAULT", fieldArray1 -> rightPad("g", Integer.parseInt(fieldArray1)));
    }

    private static Map<String, BiFunction<MyObject, String, String>> MESSAGE_MAPPER = new HashMap<>();
    static {
      MESSAGE_MAPPER.put(Constants.WORKFLOW, (o, fieldArray1) -> rightPad(o.getFieldOne(), Integer.parseInt(fieldArray1)));
      MESSAGE_MAPPER.put(Constants.WORKVOLUME, (o, fieldArray1) -> rightPad(o.getFieldTwo(), Integer.parseInt(fieldArray1)));
      MESSAGE_MAPPER.put(Constants.WORKTYPE,
        (o, fieldArray1) -> WORKINGTYPE_MESSAGE_MAPPER.getOrDefault(o.getFieldThree().toLowerCase(), WORKINGTYPE_MESSAGE_MAPPER.get("DEFAULT")).apply(fieldArray1));
    }

    public static Optional<String> map(MyObject o, String fieldArray0, String fieldArray1) {
      return Optional.ofNullable(MESSAGE_MAPPER.get(fieldArray0.toLowerCase()))
        .map(mapper -> mapper.apply(o, fieldArray1));
    }

    private static String rightPad(String string, int pad) {
        // TODO right pad
        return string;
    }
  }

我们不返回映射器本身。 FieldToMessageMapper提供了进行映射的方法map。它返回一个Optional<String>，如果没有输入映射，则结果可能为空。
为确保获得独立于字符大小写的映射器，所有键均为String..toLowerCase()。

让我们继续进行总体处理：

  protected StringBuffer process(Collection<String> templateFields, MyObject object) {
    StringBuffer message = new StringBuffer(1000);
    for (String field : templateFields) {
      String[] fieldArray = field.split(Constants.SEPARATOR);
      String msg = FieldToMessageMapper.map(object, fieldArray[0], fieldArray[1])
        .orElseThrow(() -> new IllegalArgumentException(String.format("Unsupported field %s", field)));
      message.append(msg);
    }
    return message;
  }

我不知道您需要如何处理缺失的映射。我选择抛出异常来快速失败。

请注意：StringBuffer是

线程安全的可变字符序列。字符串缓冲区就像 String，但可以修改。

如果处理不是多线程的，则可以使用StringBuilder。如果结果没有进一步修改，则可以使用String。

让我展示使用Stream并返回String的另一种选择：

  protected String process(Collection<String> templateFields, MyObject object) {
    return templateFields.stream()
      .map(field -> field.split(Constants.SEPARATOR))
      .map(fieldArray -> FieldToMessageMapper.map(object, fieldArray[0], fieldArray[1])
        .orElseThrow(() -> new IllegalArgumentException(String.format("Unsupported field %s", Arrays.toString(fieldArray)))))
      .collect(Collectors.joining());
  }

如果我从正确的问题中获得了代码，则应该实现Constants的以下实现：

  public class Constants {
    public static final String SEPARATOR = ",";
    public static final String WORKFLOW = "field1";
    public static final String WORKVOLUME = "filed2";
    public static final String WORKTYPE = "field3";
  }

编辑：

如果您想使用一种配置方法，则可以进一步详细说明以下代码以使用Spring配置：

定义接口MessageMapper，该接口有两种方法：String getKey()和String map(MyObject o, String fieldArray1)。 getKey()返回映射器为其提供映射的Constants值。
使用此界面实施MESSAGE_MAPPER以上的内容。
添加一个具有构造函数CommonMessageMapper的{{1}}。 CommonMessageMapper(MessageMapper... messageMappers)必须放在messageMappers之类的Map<String, BiFunction<MyObject, String, String>> mappers中。定义方法mappers.put(messageMapper.getKey(), messageMapper)，该方法将使用String map(MyObject o, String fieldArray0, String fieldArray1)：MessageMapper mm查找适当的fieldArray0。然后调用MessageMapper mm = mappers.get(fieldArray0)。（您也可以在这里使用mm.map(o, feldArray1)来处理没有合适的映射器的情况。）
要使用Spring配置，所有Optional和MessageMapper都必须注释为CommonMessageMapper或Bean。 Component的构造函数必须用CommonMessageMapper注释。
定义一个Spring配置（使用XML或作为@Configuration），该配置会将所需的@Autowired注入到MessageMapper中，并具有用于这种CommonMessageMapper的工厂方法。
使用CommonMessageMapper代替上面的CommonMessageMapper。

Answer 2

在http://www.beanio.org处签出BeanIO，以创建固定宽度的文本文件。

基于Java模板的String构造工具

2 个答案: