Jackson 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 {}

// 子类Dog，期望序列化为<Dog/>
@JacksonXmlRootElement(localName = "Dog")
class Dog extends Animal {}

// 子类Cat，期望序列化为<Cat/>
@JacksonXmlRootElement(localName = "Cat")
class Cat extends Animal {}

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

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

public class SerializationDemo {
    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("实际输出:\n" + xml);
    }
}

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

import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;

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

// 抽象父类
public abstract class Animal {}

// 子类Dog
public class Dog extends Animal {}

// 子类Cat
public class Cat extends Animal {}

// Zoo类，指定自定义序列化器
@JsonSerialize(using = ZooSerializer.class) // 关键：使用自定义序列化器
@JacksonXmlRootElement(localName = "Zoo") // Zoo根元素标签
public class Zoo {
    // 列表字段，不需要JacksonXmlProperty或JacksonXmlElementWrapper，因为自定义序列化器会处理
    List<Animal> animals = new ArrayList<>();

    // 示例：添加构造函数或方法方便测试
    public Zoo() {}

    public List<Animal> getAnimals() {
        return animals;
    }
}

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> {

    // 默认构造函数
    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")处理）
        // 在这里，我们只需要处理其内部的animals列表

        // 对于XML，Jackson的JsonGenerator会将writeStartObject()映射到根元素标签，
        // 但由于Zoo类本身有@JacksonXmlRootElement，这里的writeStartObject()会是其内部内容。
        // 为了确保Zoo标签内部直接是Dog/Cat，我们直接在jg上操作，而不是先writeStartObject()
        // 因为ZooSerializer是针对Zoo对象整体的，它会负责整个Zoo标签的内容。
        // 通常，@JsonSerialize在类级别，意味着你控制的是整个类的序列化。

        // Jackson的XmlMapper在处理@JsonSerialize注解时，会先写入被注解类的根元素，
        // 然后调用自定义序列化器的serialize方法来填充该根元素内部的内容。
        // 因此，我们不需要在这里手动写入<Zoo>标签。
        // 我们需要做的是，在Zoo标签内部，为每个Animal写入其对应的标签。

        // 遍历animals列表
        for (Animal animal : zoo.getAnimals()) {
            // 获取动物的简单类名作为XML标签名 (例如 "Dog", "Cat")
            String tagName = animal.getClass().getSimpleName();
            // 写入一个空字段，Jackson的XmlMapper会将其解释为一个空标签，如 <Dog/> 或 <Cat/>
            jg.writeNullField(tagName);
        }
        // 不需要jg.writeEndObject()，因为自定义序列化器是为整个Zoo对象服务的，
        // Jackson的XmlMapper会在调用完serialize方法后自动关闭Zoo标签。
    }
}

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

public class SerializationDemo {
    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("最终输出:\n" + xml);
    }
}

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.WRAPPER_OBJECT)
@JsonSubTypes({
    @JsonSubTypes.Type(value = Dog.class, name = "Dog"),
    @JsonSubTypes.Type(value = Cat.class, name = "Cat")
})
abstract class Animal {} // 这里的Animal需要是可序列化的，或者在父类上定义多态信息

// Zoo类中animals列表的定义可能需要调整，或者直接在Animal父类上定义多态信息
// ...

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

<Zoo>
  <Dog type="Dog"/>
  <Cat type="Cat"/>
  <Dog type="Dog"/>
</Zoo>