MapStruct递归序列化方法详解

在IT行业这个发展更新速度很快的行业，只有不停止的学习，才不会被行业所淘汰。如果你是文章学习者，那么本文《MapStruct处理Java递归序列化方法》就很适合你！本篇内容主要包括##content_title##，希望对大家的知识积累有所帮助，助力实战开发！

本文将介绍如何使用 MapStruct 优雅地处理 Java 中包含递归结构的对象的序列化。通过定义多个 Mapper 接口，并结合 MapStruct 的自动映射功能，可以轻松地将具有嵌套关系的实体类转换为对应的响应类，从而简化 API 开发过程，并提高代码的可维护性。

在开发 Java Web 应用时，经常需要将内部模型（Entity）转换为外部模型（Response），以便通过 API 返回给客户端。当模型中存在递归结构时，例如树形结构，手动编写转换逻辑会变得繁琐且容易出错。MapStruct 是一个强大的 Java Bean 映射器，可以自动生成类型安全的映射代码，极大地简化了开发过程。本文将以一个简单的树形结构为例，演示如何使用 MapStruct 处理递归序列化。

示例：树形结构的序列化

假设我们有以下实体类：

import lombok.*;
import lombok.experimental.FieldDefaults;

import java.util.List;

import static lombok.AccessLevel.PUBLIC;

@Builder
@Getter
@AllArgsConstructor
@FieldDefaults(level = PUBLIC)
public class Tree {
    String name;
    List<Leaf> leafs;
}

import lombok.*;
import lombok.experimental.FieldDefaults;

import java.util.List;

import static lombok.AccessLevel.PUBLIC;

@Builder
@Getter
@AllArgsConstructor
@FieldDefaults(level = PUBLIC)
public class Leaf {
    String name;
    List<Leaf> children;
}

我们希望将 Tree 和 Leaf 转换为以下响应类：

import lombok.Getter;
import lombok.Setter;
import lombok.experimental.FieldDefaults;

import java.util.List;

import static lombok.AccessLevel.PUBLIC;

@Getter
@Setter
@FieldDefaults(level = PUBLIC)
public class TreeResponse {
    String name;
    List<LeafResponse> leafs;
}

import lombok.Getter;
import lombok.Setter;
import lombok.experimental.FieldDefaults;

import java.util.List;

import static lombok.AccessLevel.PUBLIC;

@Getter
@Setter
@FieldDefaults(level = PUBLIC)
public class LeafResponse {
    String name;
    List<LeafResponse> children;
}

定义 MapStruct Mapper

为了实现上述转换，我们需要定义两个 MapStruct Mapper 接口：

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;

@Mapper
public interface TreeMapper {

    @Mapping(target = "name", source = "entity.name")
    TreeResponse map(Tree entity);
}

import org.mapstruct.Mapper;

import java.util.List;

@Mapper
public interface LeafMapperSecond {
    LeafResponse map(Leaf entity);

    List<LeafResponse> map(List<Leaf> entity);
}

TreeMapper 负责将 Tree 转换为 TreeResponse，并指定 name 属性的映射关系。LeafMapperSecond 负责将 Leaf 转换为 LeafResponse，并提供将 List 转换为 List 的方法。 注意，这里使用了两个Mapper，LeafMapperSecond是为了避免循环依赖的问题，如果使用同一个Mapper，MapStruct可能会因为递归调用而无法生成正确的代码。

编写测试用例

为了验证映射是否正确，我们可以编写一个简单的测试用例：

import org.junit.jupiter.api.Test;
import org.mapstruct.factory.Mappers;

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

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;

public class MapstructTest {

    private TreeMapper treeMapper = Mappers.getMapper(TreeMapper.class);

    @Test
    public void test() {
        List<Leaf> leafs = new ArrayList<>();
        leafs.add(Leaf.builder().name("Leaf 1").build());

        leafs.add(
                Leaf.builder()
                        .name("Leaf 2")
                        .children(
                                Arrays.asList(
                                        Leaf.builder()
                                                .name("Leaf Children 1")
                                                .children(
                                                        Arrays.asList(
                                                                Leaf.builder()
                                                                        .name("Leaf Children 1.1")
                                                                        .build(),
                                                                Leaf.builder()
                                                                        .name("Leaf Children 1.2")
                                                                        .build()))
                                                .build(),
                                        Leaf.builder().name("Leaf Children 2").build()))
                        .build());

        Tree tree = Tree.builder().name("tree name").leafs(leafs).build();

        TreeResponse treeResponse = treeMapper.map(tree);

        assertEquals(treeResponse.name, "tree name");
        assertEquals(treeResponse.leafs.size(), 2);

        LeafResponse leafWithChildren =
                treeResponse.leafs.stream()
                        .filter(l -> l.name.equals("Leaf 2"))
                        .findFirst()
                        .orElse(null);
        assertNotNull(leafWithChildren);
        assertEquals(leafWithChildren.getChildren().size(), 2);

        LeafResponse leafWithSubChildren =
                leafWithChildren.children.stream()
                        .filter(l -> l.name.equals("Leaf Children 1"))
                        .findFirst()
                        .orElse(null);

        assertNotNull(leafWithSubChildren);
        assertEquals(leafWithChildren.getChildren().size(), 2);
    }
}

在这个测试用例中，我们创建了一个包含嵌套 Leaf 对象的 Tree 对象，然后使用 TreeMapper 将其转换为 TreeResponse。最后，我们断言转换后的 TreeResponse 对象的属性值是否与预期一致。

注意事项

• 确保在项目中添加 MapStruct 的依赖。
• 如果遇到循环依赖的问题，可以考虑使用多个 Mapper 接口来解决。
• MapStruct 会自动生成映射代码，因此无需手动编写大量的转换逻辑。

总结

通过使用 MapStruct，我们可以轻松地处理 Java 中包含递归结构的对象的序列化。这种方法不仅简化了开发过程，还提高了代码的可维护性和可读性。在实际项目中，可以根据具体的业务需求，灵活地使用 MapStruct 的各种特性，从而实现高效、可靠的数据转换。

理论要掌握，实操不能落！以上关于《MapStruct递归序列化方法详解》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！