java - Jackson JSON 键名称映射

Question

我开始使用 Jackson ObjectMapper 将 JSON String 解析为 MongoDB BasicDBObject。

• 在 readValue 期间，我希望 Jackson 将字段名称中的任何保留字符替换为替代字符

• 在 writeValue 期间，我希望 Jackson 进行反向替换

这样做的原因是 Mongo DB 不支持 . 或 $ 作为 JSON 中键名称的一部分，而我有旧数据，但我不支持太热衷于转换，这样我就可以在没有特殊字符映射的情况下坚持它..

我正在寻找正确的集成点，在该集成点上我可以覆盖 readValue 期间生成的字段名称，以及将对象序列化回字符串时使用的集成点 (writeValue)。

我查看了 SimpleModule.addKeySerializer 和 SimpleModule.addKeyDeserializer，并实现了一个简单的映射。然而，这似乎只适用于我的嵌套 JSON 对象的第一层。任何嵌套对象的名称似乎都没有正确映射。

覆盖字段名称映射方式的正确集成点是什么？

Answer 1

我应该在序言中提到，我不是 Jackson 方面的专家，但我看到两个可能的地方可以集成此类功能:

• 自定义序列化器/反序列化器
• 一系列 POJO 为您进行映射

第一种方法可能有点繁琐，但您可以编写自定义 serializer和 deserializer (或多个。本例中我使用了其中一个)来处理键名中的字符替换。

举个例子，我正在使用一些包含一些句点和美元符号的 JSON，如下所示:

{\"username.\":\"testuser\",\"id\":\"12345\",\"$role\":{\"role\":\"admin\",\"roleId$\":\"999\"}}

并将替换“.”与“_”，“$”与“|”，然后再返回。我不太确定如何进一步浓缩这一点，所以请原谅这篇长文章。

使用类:

    public class User {

    private final String username;
    private final String id;
    private final RoleInfo role;

      public User(String username, String id, RoleInfo role) {
          this.username = username;
          this.id = id;
          this.role = role;
      }

      ...getters omitted
    }

    public class RoleInfo {

      private final String role;
      private final String roleId;

      public RoleInfo(String role, String roleId) {
          this.role = role;
          this.roleId = roleId;
      }
      ...getters omitted
  }

还有序列化器/反序列化器(假设是最新版本的 Jackson，您可能希望比我在本例中更仔细地处理节点的处理方式):

public class MyCustomDeserializer extends JsonDeserializer<User> {

    private final String period;
    private final String dollarSign;

    public MyCustomDeserializer(final String period, final String dollarSign){
        this.period = period;
        this.dollarSign = dollarSign;
    }

    @Override
    public User deserialize(JsonParser p, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {

        final TreeNode node = p.getCodec().readTree(p);

        final TextNode roleNode = (TextNode) node.get(this.dollarSign + "role").get("role");
        final TextNode roleIdNode = (TextNode) node.get(this.dollarSign + "role").get("roleId" + this.dollarSign);
        final String roleName = roleNode.asText();
        final String roleId = roleIdNode.asText();
        final RoleInfo roleInfo = new RoleInfo(roleName, roleId);



        final TextNode usernameNode = (TextNode) node.get("username" + period);
        final TextNode idNode = (TextNode) node.get("id");
        final String username = usernameNode.asText();
        final String userId = idNode.asText();

        final User user = new User(username, userId, roleInfo);

        return user;
    }

}

public class MyCustomSerializer extends JsonSerializer<User> {

    private final String period;
    private final String dollarSign;

    public MyCustomSerializer(final String period, final String dollarSign) {
        this.period = period;
        this.dollarSign = dollarSign;
    }

    @Override
    public void serialize(User user, JsonGenerator gen,
            SerializerProvider serializers) throws IOException,
            JsonProcessingException {

        gen.writeStartObject();
        gen.writeStringField("username" + this.period, user.getUsername());
        gen.writeStringField("id", user.getId());
        gen.writeFieldName(this.dollarSign + "role");
        gen.writeStartObject();
        gen.writeStringField("role", user.getRole().getRole());
        gen.writeStringField("roleId" + this.dollarSign, user.getRole()
                .getRoleId());
        gen.writeEndObject();
        gen.writeEndObject();

    }

}

序列化和反序列化:

final String testJson = "{\"username.\":\"testuser\",\"id\":\"12345\",\"$role\":{\"role\":\"admin\",\"roleId$\":\"999\"}}";

final ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addDeserializer(User.class, new MyCustomDeserializer(".", "$"));
module.addSerializer(User.class, new MyCustomSerializer("_", "|"));
mapper.registerModule(module);

final User user = mapper.readValue(testJson, User.class);
printUser(user);

final String convertedJson = mapper.writeValueAsString(user);
System.out.println(convertedJson);

System.out.println("");


final ObjectMapper mapper2 = new ObjectMapper();
SimpleModule module2 = new SimpleModule();
module2.addDeserializer(User.class, new MyCustomDeserializer("_", "|"));
module2.addSerializer(User.class, new MyCustomSerializer(".", "$"));
mapper2.registerModule(module2);

final User user2 = mapper2.readValue(convertedJson, User.class);
printUser(user2);

final String json2 = mapper2.writeValueAsString(user);
System.out.println(json2);

产品:

12345
testuser
admin
999
{"username_":"testuser","id":"12345","|role":{"role":"admin","roleId|":"999"}}

12345
testuser
admin
999
{"username.":"testuser","id":"12345","$role":{"role":"admin","roleId$":"999"}}

正如我所说，这相当繁琐，因此您也可以尝试创建一些 POJO 来为您进行映射。我不确定是否有更优雅的方法使用各种 json annotations and some POJOs 来解决这个问题，但我没有看到一种方法可以使用这种方法在一个 POJO 中使用两组替换字符进行序列化和反序列化。 DRCB's approach链接中的结果为我提供了序列化的两个属性。

我想您还可以考虑支持两组 POJOS，其中每个保留字符都在各自的注释中，并在您从各种来源读取/写入时在它们之间进行转换。类似于(伪代码):

ClassA{

    @JsonProperty("$user")
    private String user;

}

ClassB{

    @JsonProperty("#user")
    private String user;

}

ClassA a = ClassA.from(classB);

或者您可以结合这两种方法并编写自定义序列化程序，并使用具有多个 setter 注释的 POJO 进行反序列化。我认为解决方案会根据 JSON 和 POJO 的复杂性而有所不同。