Jackson高级序列化：扁平化外部库嵌入对象的实践指南

@Value
@NoArgsConstructor(force = true, access = AccessLevel.PRIVATE)
@AllArgsConstructor(access = AccessLevel.PRIVATE)
@SuperBuilder(toBuilder = true)
@JsonDeserialize(builder = Article.ArticleBuilderImpl.class)
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class Article extends AbstractEntityBase {
    @NonNull
    UUID id;
    @JsonProperty("iNo")
    Integer iNo;
    boolean isValid;
    @NonNull
    LocalizedTexts designation; // LocalizedTexts类型
    @NonNull
    ReferenceArticleGroup articleGroup;
    Integer numberOfDecimalsSalesPrice;
    LocalizedTexts touchCaption; // LocalizedTexts类型
    LocalizedTexts printText; // LocalizedTexts类型
    LocalizedTexts productInformation; // LocalizedTexts类型
    @Singular
    List<String> codes;
    // ... 其他属性
}

@Builder(builderMethodName = "internalBuilder")
public class LocalizedTexts extends HashMap<Language, String> implements EntityBase {
    public LocalizedTexts() {}
    public LocalizedTexts(Map map) {
        putAll(map);
    }
}

public enum Language {
    AA("aa"), AB("ab"), AE("ae"), AF("af"), AK("ak"); // 简化示例
    private final String langName;
    Language(String langName) {
        this.langName = langName;
    }
    public String getLangName() { // 假设存在此方法
        return langName;
    }
}

{
    "id": "...",
    "iNo": 3,
    "isValid": true,
    "designation": {
        "de": "designation3DE ...",
        "en": "designation3EN ..."
    },
    "articleGroup": { /* ... */ },
    "touchCaption": {
        "de": "touchCaption3DE ...",
        "en": "touchCaption3EN ..."
    },
    "printText": { /* ... */ },
    "productInformation": {
        "de": "productInformation3DE ...",
        "en": "productInformation3EN ...",
        "es": "productInformation3ES ..."
    },
    "codes": [ /* ... */ ]
}

{
    "id": "...",
    "iNo": 3,
    "isValid": true,
    "articleGroup": { /* ... */ },
    "codes": [ /* ... */ ],
    "translation": [
        {
            "productInformation": "productInformation3DE localized productInformation3 productInformation",
            "language": "german"
        },
        {
            "productInformation": "productInformation3EN localized productInformation3 productInformation",
            "language": "english"
        },
        // ... 其他 productInformation 翻译
        {
            "touchCaption": "touchCaption3DE localized touchCaption3 touchCaption Bildbeschriftung",
            "language": "german"
        },
        // ... 其他 touchCaption 翻译
        {
            "designation": "designation3DE localized designation3 designation",
            "language": "german"
        }
        // ... 其他 translation 条目
    ]
}

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import lombok.NonNull;
import lombok.Singular; // 如果Article中使用了@Singular注解

import java.util.List;
import java.util.UUID;

@Builder
@Getter
@Setter
public class ArticleWrapper {
    @NonNull
    private UUID id;
    @JsonProperty("iNo")
    private Integer iNo;
    private boolean isValid;
    @NonNull
    private ReferenceArticleGroup articleGroup; // 假设ReferenceArticleGroup是Article中的一个类型
    private Integer numberOfDecimalsSalesPrice;
    @Singular
    private List<String> codes;

    // 所有LocalizedTexts的数据将被存储在这里
    private List<LanguageAttribute> translation; 
}

import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

import java.util.Map;

public record LanguageAttribute(
    @JsonAnyGetter // 将Map中的键值对直接作为当前对象的属性输出
    Map<String, String> map,
    @JsonProperty
    @JsonSerialize(converter = LanguageConverter.class) // 使用LanguageConverter序列化Language枚举
    Language language) {}

import com.fasterxml.jackson.databind.util.StdConverter;

public class LanguageConverter extends StdConverter<Language, String> {
    @Override
    public String convert(Language language) {
        // 假设Language枚举有一个方法可以获取其小写名称，例如getLangName()
        // 如果没有，可以使用 language.name().toLowerCase() 或根据实际枚举定义调整
        return language.getLangName(); // 示例：使用Language枚举中获取名称的方法
    }
}

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.util.StdConverter;

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Stream;

public class ArticleConverter extends StdConverter<Article, ArticleWrapper> {
    public ArticleConverter() {
        // 构造函数可以为空或进行初始化
    }

    @Override
    public ArticleWrapper convert(Article article) {
        // 1. 提取并扁平化所有LocalizedTexts属性
        List<LanguageAttribute> translations = getTranslations(article);

        // 2. 构建ArticleWrapper对象，复制Article的其他属性
        return ArticleWrapper.builder()
            .id(article.getId())
            .iNo(article.getINo()) // 假设getINo()是获取iNo属性的方法
            .isValid(article.isValid())
            .articleGroup(article.getArticleGroup())
            .numberOfDecimalsSalesPrice(article.getNumberOfDecimalsSalesPrice())
            .codes(article.getCodes()) // 假设getCodes()是获取codes属性的方法
            .translation(translations) // 将扁平化的翻译列表设置到translation字段
            .build();
    }

    /**
     * 从Article对象中提取所有LocalizedTexts属性，并将其转换为LanguageAttribute列表。
     * @param article Article对象
     * @return 扁平化的LanguageAttribute列表
     */
    private List<LanguageAttribute> getTranslations(Article article) {
        // 使用Stream.of将所有LocalizedTexts属性（及其对应的JSON键名）组合成一个Stream
        return Stream.of(
                toLanguageAttribute(article.getDesignation(), "designation"),
                toLanguageAttribute(article.getTouchCaption(), "touchCaption"),
                toLanguageAttribute(article.getPrintText(), "printText"),
                toLanguageAttribute(article.getProductInformation(), "productInformation")
            )
            // flatMap将每个属性转换成的Stream<LanguageAttribute>合并成一个单一的Stream
            .flatMap(Function.identity())
            .toList(); // 收集为List
    }

    /**
     * 将单个LocalizedTexts对象转换为Stream<LanguageAttribute>。
     * @param texts LocalizedTexts对象
     * @param attributeName 该LocalizedTexts对应的JSON属性名
     * @return 包含LanguageAttribute的Stream
     */
    private Stream<LanguageAttribute> toLanguageAttribute(LocalizedTexts texts, String attributeName) {
        if (texts == null || texts.isEmpty()) {
            return Stream.empty(); // 如果LocalizedTexts为空，则返回空Stream
        }
        return texts.entrySet().stream()
            .map(entry -> new LanguageAttribute(
                Map.of(attributeName, entry.getValue()), // 动态键值对
                entry.getKey()) // 对应的语言
            );
    }
}

import com.fasterxml.jackson.databind.annotation.JsonSerialize;

// ... 其他注解
@JsonSerialize(converter = ArticleConverter.class) // 应用自定义Converter
public class Article extends AbstractEntityBase {
    // ... 类定义
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

public class SerializationExample {
    public static void main(String[] args) throws JsonProcessingException {
        // 创建一个示例Article对象
        LocalizedTexts designation = new LocalizedTexts(Map.of(
            Language.DE, "designation3DE localized designation3 designation",
            Language.EN, "designation3EN localized designation3 designation"
        ));
        LocalizedTexts productInformation = new LocalizedTexts(Map.of(
            Language.DE, "productInformation3DE localized productInformation3 productInformation",
            Language.EN, "productInformation3EN localized productInformation3 productInformation",
            Language.ES, "productInformation3ES localized productInformation3 productInformation"
        ));

        Article article = Article.builder()
            .id(UUID.randomUUID())
            .iNo(3)
            .isValid(true)
            .designation(designation)
            .productInformation(productInformation)
            // ... 设置其他属性
            .build();

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT); // 美化输出

        String json = objectMapper.writeValueAsString(article);
        System.out.println(json);
    }
}