Jackson多态序列化：自定义标签输出技巧

挑战：Jackson XML多态序列化的默认行为

在Jackson中，当我们将一个包含多态列表的Java对象序列化为XML时，默认行为通常不会为列表中的每个多态子类实例生成其特有的XML根标签。例如，考虑以下类结构：

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import java.util.ArrayList;
import java.util.List;

// 抽象父类
abstract class Animal {}

// 具体的子类，指定XML根元素名称
@JacksonXmlRootElement(localName = "Dog")
class Dog extends Animal {}

@JacksonXmlRootElement(localName = "Cat")
class Cat extends Animal {}

// 包含多态列表的类
@JacksonXmlRootElement(localName = "Zoo")
public class Zoo {
  @JacksonXmlProperty
  @JacksonXmlElementWrapper(useWrapping = false) // 不包裹列表元素
  List<Animal> animals = new ArrayList<>();
}

当我们尝试序列化一个Zoo实例时：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

public class Main {
  public static void main(String[] args) throws JsonProcessingException {
    Zoo zoo = new Zoo();
    zoo.animals.add(new Dog());
    zoo.animals.add(new Cat());
    zoo.animals.add(new Dog());

    XmlMapper mapper = new XmlMapper();
    String xml = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(zoo);
    System.out.println(xml);
  }
}

我们期望的输出是：

<Zoo>
  <Dog/>
  <Cat/>
  <Dog/>
</Zoo>

然而，实际的输出却可能如下所示：

<Zoo>
  <animals/>
  <animals/>
  <animals/>
</Zoo>

尽管使用了@JacksonXmlElementWrapper(useWrapping = false)来取消列表的包裹，Jackson仍然无法根据列表元素的具体运行时类型来生成对应的XML标签。这是因为Jackson在没有明确类型信息（如@JsonTypeInfo）的情况下，通常会使用字段名或其默认的类型处理方式。

解决方案：实现自定义Jackson序列化器

为了实现每个多态子类实例拥有其特定XML根标签的需求，我们可以为包含多态列表的父类（在本例中是Zoo类）实现一个自定义的Jackson序列化器。这种方法允许我们完全控制XML的生成过程。

1. 标记需要自定义序列化的类

首先，我们需要在Zoo类上使用@JsonSerialize注解，指定我们将要创建的自定义序列化器。

import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import java.util.ArrayList;
import java.util.List;

// 抽象父类和子类保持不变
abstract class Animal {}
@JacksonXmlRootElement(localName = "Dog")
class Dog extends Animal {}
@JacksonXmlRootElement(localName = "Cat")
class Cat extends Animal {}

// Zoo类现在使用自定义序列化器
@JsonSerialize(using = ZooSerializer.class) // 指定自定义序列化器
@JacksonXmlRootElement(localName = "Zoo") // 保持Zoo的根元素名称
public class Zoo {
  // 这里的注解可以保留，但最终由自定义序列化器控制输出
  @JacksonXmlProperty
  @JacksonXmlElementWrapper(useWrapping = false)
  List<Animal> animals = new ArrayList<>();
}

2. 创建自定义序列化器 ZooSerializer

接下来，我们需要创建一个继承自com.fasterxml.jackson.databind.ser.std.StdSerializer的自定义序列化器。在这个序列化器中，我们将手动遍历animals列表，并为每个Animal子类实例生成对应的XML标签。

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import java.io.IOException;

public class ZooSerializer extends StdSerializer<Zoo> {

    // 构造函数，Jackson会调用无参构造函数
    public ZooSerializer() {
        this(null);
    }

    public ZooSerializer(Class<Zoo> t) {
        super(t);
    }

    @Override
    public void serialize(Zoo zoo, JsonGenerator jg, SerializerProvider sp) throws IOException {
        // 开始写入Zoo对象的根元素
        // 注意：JacksonXmlRootElement(localName = "Zoo") 已经处理了 <Zoo> 标签的开始和结束
        // 如果Zoo类没有@JacksonXmlRootElement，则需要在这里手动写 jg.writeStartObject() 和 jg.writeEndObject()
        // 但为了保持与原有结构兼容，我们假设Jackson会处理Zoo的根标签。
        // 对于列表元素，我们通过迭代来控制。

        // Jackson的XmlMapper在处理根元素时，会先写入<Zoo>标签。
        // 在serialize方法内部，我们只需要处理Zoo的属性。
        // 对于本例，Zoo只有一个animals列表，我们直接写入列表元素。

        // 遍历动物列表
        for (Animal animal : zoo.animals) {
            // 获取动物类的简单名称（如 "Dog", "Cat"）作为XML标签名
            String tagName = animal.getClass().getSimpleName();
            // 写入一个空字段，Jackson的XmlMapper会将其转换为自闭合标签，如 <Dog/>
            jg.writeNullField(tagName);
        }
        // 不需要在这里写 jg.writeStartObject() 和 jg.writeEndObject()
        // 因为Zoo的根标签由Jackson的XmlMapper和@JacksonXmlRootElement处理
    }
}

重要说明： 在serialize方法中，我们没有手动调用jg.writeStartObject()和jg.writeEndObject()来包裹Zoo的根标签。这是因为当XmlMapper处理一个带有@JacksonXmlRootElement注解的根对象时，它会负责写入外部的和标签。我们的自定义序列化器只需要处理Zoo对象内部的字段（即animals列表的元素）如何被序列化。jg.writeNullField(tagName)是生成自闭合标签的关键。

3. 运行测试

现在，再次运行Main类，你将得到期望的XML输出：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

public class Main {
  public static void main(String[] args) throws JsonProcessingException {
    Zoo zoo = new Zoo();
    zoo.animals.add(new Dog());
    zoo.animals.add(new Cat());
    zoo.animals.add(new Dog());

    XmlMapper mapper = new XmlMapper();
    String xml = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(zoo);
    System.out.println(xml);
  }
}

输出：

<Zoo>
  <Dog/>
  <Cat/>
  <Dog/>
</Zoo>

考量与权衡

使用自定义序列化器虽然能够实现精确的XML输出格式，但它也伴随着重要的权衡：

1. 失去Jackson内置的多态支持：

   • Jackson提供了@JsonTypeInfo和@JsonSubTypes等注解，用于在序列化时嵌入类型信息（例如，作为XML属性xsi:type或额外的子元素），并在反序列化时自动识别并实例化正确的子类型。
   • 通过自定义序列化器，我们实际上绕过了Jackson的这一自动化机制。这意味着，如果需要将上述XML反序列化回Java对象，Jackson将无法自动识别和标签对应的具体Java类型，你将需要编写一个自定义的JsonDeserializer来处理反序列化过程。这会增加代码的复杂性。

2. 手动控制与自动化：

   • 优点： 提供了对XML输出格式的极致控制，适用于XML结构有严格且非标准要求的场景。
   • 缺点： 增加了代码量和维护成本。当多态类型数量众多或类结构频繁变动时，手动维护序列化器可能会变得繁琐。

3. 适用场景：

   • 当XML输出格式是外部系统严格规定的，且不包含Jackson默认的多态类型识别信息（如xsi:type）时，自定义序列化器是有效的解决方案。
   • 当序列化是单向操作，或者反序列化逻辑可以独立于Jackson的自动机制手动处理时。

总结

通过实现自定义的Jackson JsonSerializer，我们可以精确地控制多态列表元素在XML序列化时的标签名称，从而满足特定的XML格式要求。这种方法提供了高度的灵活性和控制力，但其代价是放弃了Jackson内置的多态类型识别和自动反序列化的便利性。在选择此方案时，开发者需要充分权衡项目对XML格式的严格要求与代码维护复杂性之间的利弊，并考虑是否需要为反序列化编写相应的自定义逻辑。

到这里，我们也就讲完了《Jackson多态序列化：自定义标签输出技巧》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！