Java 基于模板的字符串构造工具

Question

我正在尝试重构一些遗留代码。这里的任务是根据一些预定义的模板构建冗长的 messages/strings，如下所示：

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

然后我收到了一个包含所有这些字段的 java 对象。这里需要做的只是从对象字段中获取数据，并使用它们根据模板构造一个long message/string。其中一些字段也可以根据一些简单的规则进行转换。例如：

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

因此我们需要不时检查这些字段的值。还有关于填充的规则（主要是在右侧添加空 space ）。所以构造的 message/string 可能看起来像这样：

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] 和 return 的值，用于这些 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;
    }
  }

我们不 return 映射器本身。 FieldToMessageMapper 提供了进行映射的方法 map。它 return 是一个 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是

A thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified.

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

让我展示一个使用 Stream 的替代方案，其中 return 是 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() return 映射器为其提供映射的 Constants 值。
使用此接口实现上述每个 MESSAGE_MAPPER。
添加具有构造函数 CommonMessageMapper(MessageMapper... messageMappers) 的 CommonMessageMapper。 messageMappers 必须放在 Map<String, BiFunction<MyObject, String, String>> mappers 中，例如：mappers.put(messageMapper.getKey(), messageMapper)。定义一个方法 String map(MyObject o, String fieldArray0, String fieldArray1)，它将使用 fieldArray0: MessageMapper mm = mappers.get(fieldArray0) 查找适当的 MessageMapper mm。然后调用 mm.map(o, feldArray1)。（你也可以在这里使用 Optional 来处理没有合适的映射器的情况。）
要使用 Spring 配置，所有 MessageMapper 和 CommonMessageMapper 必须注释为 Bean 或 Component。 CommonMessageMapper 的构造函数必须用 @Autowired.
定义一个 Spring 配置（使用 XML 或 @Configuration），它会将所需的 MessageMapper 注入到 CommonMessageMapper 中，并有一个工厂这种 CommonMessageMapper.
使用 CommonMessageMapper 代替上面的 FieldToMessageMapper。

Java 基于模板的字符串构造工具

Tools for Java template-based String construction

java

string

templates

construction