使用 MapStruct 处理 Java 递归数据结构的序列化-java教程-PHP中文网

使用 MapStruct 处理 Java 递归数据结构的序列化

花韻仙語

发布： 2025-07-13 17:42:31

原创

981人浏览过

使用 mapstruct 处理 java 递归数据结构的序列化

本文将介绍如何使用 MapStruct 处理 Java 中包含递归结构的数据序列化，例如树形结构。我们将以一个 Tree 类及其包含的 Leaf 类为例，演示如何使用 MapStruct 将其转换为对应的 TreeResponse 和 LeafResponse 类。

首先，我们来看一下需要转换的实体类和目标响应类：

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

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

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

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

登录后复制

可以看到，Leaf 类包含一个 children 列表，该列表也是 Leaf 类型的，这就构成了一个递归结构。

为了使用 MapStruct 进行转换，我们需要定义两个 Mapper 接口：TreeMapper 和 LeafMapperSecond。

立即学习“Java免费学习笔记（深入）”；

@Mapper
public interface TreeMapper {

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

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

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

登录后复制

TreeMapper 负责将 Tree 对象转换为 TreeResponse 对象。LeafMapperSecond 负责将 Leaf 对象转换为 LeafResponse 对象，并且提供了一个用于转换 List<Leaf> 到 List<LeafResponse> 的方法。

关键点在于定义了两个 Mapper 接口，并且在 LeafMapperSecond 中定义了 List 转换方法。 MapStruct 会自动处理 List 的递归转换，无需手动编写复杂的递归逻辑。

Android创建和使用数据库详细指南中文WORD版

每个应用程序都要使用数据，Android应用程序也不例外，Android使用开源的、与操作系统无关的SQL数据库--SQLite，本文介绍的就是如何为你的Android应用程序创建和操作SQLite数据库。数据库支持每个应用程序无论大小的生命线，除非你的应用程序只处理简单的数据，那么就需要一个数据库系统存储你的结构化数据，Android使用SQLite数据库，它是一个开源的、支持多操作系统的SQL数据库，在许多领域广泛使用，如Mozilla FireFox就是使用SQLite来存储配置数据的，iPhon

查看详情

现在，我们可以编写一个测试用例来验证转换是否正确：

private TreeMapper treeMapper = Mappers.getMapper(TreeMapper.class);
private LeafMapperSecond leafMapper = Mappers.getMapper(LeafMapperSecond.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 注解标记 Mapper 接口。
对于递归结构，需要定义多个 Mapper 接口，并提供 List 转换方法。
MapStruct 会自动处理 List 的递归转换，无需手动编写复杂的递归逻辑。
如果需要自定义映射逻辑，可以使用 @Mapping 注解。

总结：

通过使用 MapStruct，我们可以轻松地处理包含递归结构的数据序列化。这种方法简洁、高效，并且易于维护。它避免了手动编写复杂的递归逻辑，提高了开发效率。这种方法特别适用于 API 开发，可以将复杂的内部数据结构转换为清晰的 JSON 响应。

以上就是使用 MapStruct 处理 Java 递归数据结构的序列化的详细内容，更多请关注php中文网其它相关文章！