Java 基础：MapStruct 使用指南与原理剖析

更底层来看，Java 编译器对源码进行编译，生成抽象语法树（AST）。实现了 JSR 269 API 的程序（即 Annotation Processor）会在编译期间被调用，修改 AST 并插入自己的实现逻辑，最后生成字节码。

想要深入了解其原理，可以从 MapStruct 的源码入手。主要有以下几个步骤：

1. 继承 AbstractProcessor 类，并且重写 process 方法，在 process 方法中实现自己的注解处理逻辑。
2. 在 META-INF/services 目录下创建 javax.annotation.processing.Processor 文件注册自己实现的 Annotation Processor。

在 MapStruct 的两个核心 jar 包中，通过根据 JSR 269 可以知道 MappingProcessor 就是 MapStruct 的入口。com.sun.tools.javac.main.JavaCompiler#compile 方法的有段代码在编译的时候会调用到 MappingProcessor。

ModelElementProcessor 的实现类有多个，每个实现类有不同的作用，并且每个实现类都有一个 priority，达到执行顺序的效果，实现类大致有如下几个：

1. MethodRetrievalProcessor：解析元素的方法等基本信息。priority=1。
2. MapperCreationProcessor：初始化 MapperReference，解析出 Mapper。priority=1000。
3. AnnotationBasedComponentModelProcessor：处理 ComponentModel 相关逻辑。主要用于实现 JSR330、Spring component 及 CDI 组件等功能。
4. MapperRenderingProcessor：创建接口的具体实现类，比如 UserConverter 接口，则生成 UserConverterImpl 类。priority=9999。
5. MapperServiceProcessor：处理 spi 和 META-INF/services/下的相关逻辑。priority=10000。

从 MapperRenderingProcessor 类里可以看到有个 createSourceFile 方法，该方法会创建实现类，并写到特定目录下。这样就生成了接口的实现类，里面有所有方法。

IDEA 调试技巧

如果想要在 IDEA 中调试 MapStruct 的编译过程，可以参考以下步骤：

1. 在终端里将路径切换到 pom 所在路径。例如：cd /User/zhangsan/test/。
2. 在终端执行 mvnDebug compile。执行该命令后，终端会提示已经监听了 8000 端口。（注意：执行 mvnDebug 之前得先配置 maven 的环境变量，否则无法识别这个命令）
3. 在 IDEA 中创建添加 Remote JVM Debug，端口号是 8000。
4. 在 JavaCompiler 里的 compile 方法打断点，再在 AbstractProcessor#init 和 MappingProcessor#init 打断点。然后在 IDEA 点击 debug 按钮进行 debug。（注意：如果本地编译的 class 已经是最近编译的，则点击 debug 后无法进入调试，需要修改下代码，如修改下 Dto 里的属性，再点击 debug 按钮）

通过调试，可以看到执行的步骤是这样的：JavaCompiler#compile -> AbstractProcessor#init -> MappingProcessor#init -> MappingProcessor#process。

MapStruct 使用方法

1. 添加依赖

这里使用 JDK8，IDEA 来编写程序，Maven 解决依赖。先在 pom 文件引入依赖：

<properties>
    <org.mapstruct.version>1.6.0</org.mapstruct.version>
</properties>

<!-- mapStruct 依赖 高性能对象映射 -->
<!-- mapstruct 核心 -->
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct</artifactId>
    <version>${org.mapstruct.version}</version>
</dependency>
<!-- mapstruct 编译 -->
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>${org.mapstruct.version}</version>
</dependency>

2. 准备 DTO 与 VO

为了演示方便，我们准备了一些示例类。CatDto 继承自 AnimalDto，同时拥有 AnotherDto 属性；CatVo 继承自 AnimalVo，结构类似但部分属性名不一致。

@Data
@AllArgsConstructor
@NoArgsConstructor
@SuperBuilder(builderMethodName = "myBuilder")
public class AnimalDto implements Serializable {
    private long serializable = 1L;
    String name;
    int age;
    private String id;
    private BigDecimal source;
    private double height;
    private Date createTime;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ToString(callSuper = true)
public class CatDto extends AnimalDto {
    private long serializable = 1L;
    String nickName;
    CatType catType;
    AnotherDto anotherDto;
    private String fullInfo;
    private LocalDate birthday;
    String paName;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class AnotherDto {
    int anotherId;
    String anotherName;
}

对应的 VO 类：

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder(builderMethodName = "myBuilder")
public class AnimalVo implements Serializable {
    private long serializable = 1L;
    String name;
    int age;
    private String id;
    private BigDecimal source;
    private double height;
    private Date createTime;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ToString(callSuper = true)
public class CatVo extends AnimalVo {
    private long serializable = 1L;
    String nick; // 注意字段名差异
    CatType catType;
    AnotherVo anotherVo;
    private String fullInfo;
    private String birthday; // 类型差异
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class AnotherVo {
    int anotherId;
    String anotherName;
}

3. 编写 Mapper 接口

Test Case 1：基本映射

基本映射使用 MapStruct，可以轻松实现两个 Java Bean 对象之间的基本映射。只需定义一个映射器接口，并使用注解指定源类和目标类，MapStruct 会在编译期生成实现类。

@Mapper
public interface CatMapper {
    CatMapper INSTANCE = Mappers.getMapper(CatMapper.class);

    @Mapping(source = "nick", target = "nickName") // 字段名不一样的单独指定映射关系
    CatDto catVoToCatDto(CatVo catVo);

    @Mapping(source = "nickName", target = "nick")
    CatVo catDtoToCatVo(CatDto catDto);
}

Test Case 2：复杂类型映射

当对象中包含嵌套对象时，MapStruct 也能自动处理递归映射。

@Mapper
public interface CatMapper2 {
    CatMapper2 INSTANCE = Mappers.getMapper(CatMapper2.class);

    @Mapping(source = "nick", target = "nickName")
    @Mapping(source = "anotherVo", target = "anotherDto")
    CatDto catVoToCatDto(CatVo catVo);

    @Mapping(source = "nickName", target = "nick")
    @Mapping(source = "anotherDto", target = "anotherVo")
    CatVo catDtoToCatVo(CatDto catDto);
}

Test Case 3：使用 Java 表达式

MapStruct 支持在映射器中使用表达式。通过编写 Lambda 表达式或方法引用，可以实现复杂的映射逻辑。

@Mapper
public interface CatMapper3 {
    CatMapper3 INSTANCE = Mappers.getMapper(CatMapper3.class);

    @Mapping(source = "nick", target = "nickName")
    @Mapping(source = "anotherVo", target = "anotherDto")
    @Mapping(expression = "java(catVo.getNick() + ' ' + catVo.getCatType())", target = "fullInfo")
    CatDto catVoToCatDto(CatVo catVo);

    @Mapping(source = "nickName", target = "nick")
    @Mapping(source = "anotherDto", target = "anotherVo")
    @Mapping(expression = "java(catDto.getNickName() + ' ' + catDto.getCatType())", target = "fullInfo")
    CatVo catDtoToCatVo(CatDto catDto);
}

Test Case 4：使用自定义方法

MapStruct 允许在映射器中定义自定义方法，实现复杂的映射逻辑。例如，可以定义一个方法，将源对象中的某个字段进行转换后赋值给目标对象。

@Mapper
public interface CatMapper4 {
    CatMapper4 INSTANCE = Mappers.getMapper(CatMapper4.class);

    @Mapping(source = "nick", target = "nickName")
    @Mapping(source = "anotherVo", target = "anotherDto")
    @Mapping(expression = "java(catVo.getNick() + ' ' + catVo.getCatType())", target = "fullInfo")
    @Mapping(source = "birthday", target = "birthday", qualifiedByName = "stringToLocalDate")
    CatDto catVoToCatDto(CatVo catVo);

    @Mapping(source = "nickName", target = "nick")
    @Mapping(source = "anotherDto", target = "anotherVo")
    @Mapping(expression = "java(catDto.getNickName() + ' ' + catDto.getCatType())", target = "fullInfo")
    @Mapping(source = "birthday", target = "birthday", qualifiedByName = "localDateString")
    CatVo catDtoToCatVo(CatDto catDto);

    @Named("stringToLocalDate")
    default LocalDate stringToLocalDate(String date) {
        return LocalDate.parse(date, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }

    @Named("localDateString")
    default String localDateString(LocalDate date) {
        return DateTimeFormatter.ofPattern("yyyy-MM-dd").format(date);
    }
}

Test Case 5：集合映射

处理 List 类型的映射也非常简单，MapStruct 会自动遍历集合。

@Mapper
public interface CatMapper5 {
    CatMapper5 INSTANCE = Mappers.getMapper(CatMapper5.class);

    @Mapping(source = "nick", target = "nickName")
    CatDto catVoToCatDto(CatVo catVo);

    @Mapping(source = "nickName", target = "nick")
    CatVo catDtoToCatVo(CatDto catDto);

    @Mapping(source = "nick", target = "nickName")
    List<CatDto> catVoToCatDtos(List<CatVo> catVo);

    @Mapping(source = "nickName", target = "nick")
    List<CatVo> catDtoToCatVos(List<CatDto> catDto);
}

Test Case 6：使用依赖注入

MapStruct 支持依赖注入，可以在映射器中使用第三方库或框架。这方便了在对象映射过程中使用其他组件。

@Mapper(componentModel = MappingConstants.ComponentModel.SPRING)
public interface CatMapper6 {
    CatMapper6 INSTANCE = Mappers.getMapper(CatMapper6.class);

    @Mapping(source = "nick", target = "nickName")
    CatDto catVoToCatDto(CatVo catVo);

    @Mapping(source = "nickName", target = "nick")
    CatVo catDtoToCatVo(CatDto catDto);
}

Test Case 7：更新现有对象

有时候我们需要直接更新目标对象，而不是创建新实例。这时可以使用 @MappingTarget。

@Mapper
public interface CatMapper7 {
    CatMapper7 INSTANCE = Mappers.getMapper(CatMapper7.class);

    @Mapping(source = "nickName", target = "nick")
    void updateCatFromDTO(CatDto catDto, @MappingTarget CatVo catVo);

    @Mapping(source = "nick", target = "nickName")
    void updateCatFromVO(CatVo catVo, @MappingTarget CatDto catDto);
}

Test Case 8：多源映射

MapStruct 支持多态映射。通过定义一个映射器接口，可以实现多个子类对象映射到一个父类对象。这在处理继承关系复杂的对象映射时非常有用。

@Mapper
public interface CatMapper8 {
    CatMapper8 INSTANCE = Mappers.getMapper(CatMapper8.class);

    @Mapping(source = "anotherVo.anotherName", target = "paName")
    @Mapping(source = "catVo.nick", target = "nickName")
    CatDto catVoToCatDto(CatVo catVo, AnotherVo anotherVo);

    @Mapping(source = "nickName", target = "nick")
    CatVo catDtoToCatVo(CatDto catDto);
}

4. 测试验证

我们可以编写一个测试类入口来验证上述功能：

public class Test {
    public static void main(String[] args) {
        testBasicTypeConvert();
        System.out.println("--------------------1----------------------");
        testComplexConvert();
        System.out.println("--------------------2----------------------");
        testExpressConvert();
        System.out.println("--------------------3----------------------");
        testCustomConvert();
        System.out.println("--------------------4----------------------");
        testCollectionConvert();
        System.out.println("--------------------5----------------------");
        testBasicTypeConvert4CatMapper6();
        System.out.println("--------------------6----------------------");
        testUpdate();
        System.out.println("--------------------7----------------------");
        testMultiSourceConvert();
        System.out.println("--------------------8----------------------");
    }

    // 基本类型映射
    public static void testBasicTypeConvert() {
        CatVo catVo = CatVo.builder().nick("NoNo").catType(CatType.LiHuaMao).build();
        catVo.setName("Tom");
        catVo.setAge(1);
        catVo.setCreateTime(new Date());
        catVo.setHeight(1.25);

        CatDto catDto = CatMapper.INSTANCE.catVoToCatDto(catVo);
        System.out.printf("testBasicTypeConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        catDto.setNickName("HaHa");
        catDto.setCatType(CatType.DaJuMao);
        System.out.printf("testBasicTypeConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        CatVo catVo2 = CatMapper.INSTANCE.catDtoToCatVo(catDto);
        System.out.printf("testBasicTypeConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo2.getClass().getName(), catVo2, catVo2.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());
    }

    // 复杂类型映射
    public static void testComplexConvert() {
        CatVo catVo = CatVo.builder().nick("NoNo").catType(CatType.LiHuaMao).build();
        catVo.setName("Tom");
        catVo.setAge(1);
        catVo.setCreateTime(new Date());
        catVo.setHeight(1.25);
        catVo.setAnotherVo(AnotherVo.builder().anotherId(100).anotherName("Tony").build());

        CatDto catDto = CatMapper2.INSTANCE.catVoToCatDto(catVo);
        System.out.printf("testComplexConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        catDto.setNickName("HaHa");
        AnotherDto tmp = catDto.getAnotherDto();
        tmp.setAnotherName("XXXX");
        catDto.setAnotherDto(tmp);
        catDto.setCatType(CatType.DaJuMao);
        System.out.printf("testComplexConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        CatVo catVo2 = CatMapper2.INSTANCE.catDtoToCatVo(catDto);
        System.out.printf("testComplexConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo2.getClass().getName(), catVo2, catVo2.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());
    }

    // Java 表达式
    public static void testExpressConvert() {
        CatVo catVo = CatVo.builder().nick("NoNo").catType(CatType.LiHuaMao).build();
        catVo.setName("Tom");
        catVo.setAge(1);
        catVo.setCreateTime(new Date());
        catVo.setHeight(1.25);
        catVo.setAnotherVo(AnotherVo.builder().anotherId(100).anotherName("Tony").build());

        CatDto catDto = CatMapper3.INSTANCE.catVoToCatDto(catVo);
        System.out.printf("testExpressConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        catDto.setNickName("HaHa");
        AnotherDto tmp = catDto.getAnotherDto();
        tmp.setAnotherName("XXXX");
        catDto.setAnotherDto(tmp);
        catDto.setCatType(CatType.DaJuMao);
        System.out.printf("testExpressConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        CatVo catVo2 = CatMapper3.INSTANCE.catDtoToCatVo(catDto);
        System.out.printf("testExpressConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo2.getClass().getName(), catVo2, catVo2.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());
    }

    // 使用自定义方法
    public static void testCustomConvert() {
        CatVo catVo = CatVo.builder().nick("NoNo").catType(CatType.LiHuaMao).build();
        catVo.setName("Tom");
        catVo.setAge(1);
        catVo.setCreateTime(new Date());
        catVo.setHeight(1.25);
        catVo.setAnotherVo(AnotherVo.builder().anotherId(100).anotherName("Tony").build());
        catVo.setBirthday("2049-10-01");

        CatDto catDto = CatMapper4.INSTANCE.catVoToCatDto(catVo);
        System.out.printf("testCustomConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        catDto.setNickName("HaHa");
        AnotherDto tmp = catDto.getAnotherDto();
        tmp.setAnotherName("XXXX");
        catDto.setAnotherDto(tmp);
        catDto.setCatType(CatType.DaJuMao);
        catDto.setBirthday(LocalDateTime.now().toLocalDate());
        System.out.printf("testCustomConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        CatVo catVo2 = CatMapper4.INSTANCE.catDtoToCatVo(catDto);
        System.out.printf("testCustomConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo2.getClass().getName(), catVo2, catVo2.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());
    }

    // 集合映射
    public static void testCollectionConvert() {
        CatVo catVo = CatVo.builder().nick("NoNo").catType(CatType.LiHuaMao).build();
        catVo.setName("Tom");
        catVo.setAge(1);
        catVo.setCreateTime(new Date());
        catVo.setHeight(1.25);
        catVo.setAnotherVo(AnotherVo.builder().anotherId(100).anotherName("Tony").build());
        catVo.setBirthday("2049-10-01");

        CatVo catVo2 = CatVo.builder().nick("NoNo2").catType(CatType.LiHuaMao).build();
        catVo2.setName("Tom2");
        catVo2.setAge(2);
        catVo2.setCreateTime(new Date());
        catVo2.setHeight(2.25);
        catVo2.setAnotherVo(AnotherVo.builder().anotherId(1002).anotherName("Tony2").build());
        catVo2.setBirthday("2049-10-01");

        List<CatVo> catVoList = new ArrayList<>();
        catVoList.add(catVo);
        catVoList.add(catVo2);

        List<CatDto> catDtoList = CatMapper5.INSTANCE.catVoToCatDtos(catVoList);
        System.out.printf("testCollectionConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVoList.getClass().getName(), catVoList, catVoList.hashCode(),
                catDtoList.getClass().getName(), catDtoList, catDtoList.hashCode());

        for (CatDto dto : catDtoList) {
            dto.setNickName("HeHe");
            dto.setBirthday(LocalDateTime.now().toLocalDate());
        }
        System.out.printf("testCollectionConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVoList.getClass().getName(), catVoList, catVoList.hashCode(),
                catDtoList.getClass().getName(), catDtoList, catDtoList.hashCode());

        List<CatVo> catVoList2 = CatMapper5.INSTANCE.catDtoToCatVos(catDtoList);
        System.out.printf("testCollectionConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVoList2.getClass().getName(), catVoList2, catVoList2.hashCode(),
                catDtoList.getClass().getName(), catDtoList, catDtoList.hashCode());
    }

    // 使用依赖注入
    public static void testBasicTypeConvert4CatMapper6() {
        CatVo catVo = CatVo.builder().nick("NoNo").catType(CatType.LiHuaMao).build();
        catVo.setName("Tom");
        catVo.setAge(1);
        catVo.setCreateTime(new Date());
        catVo.setHeight(1.25);

        CatDto catDto = CatMapper6.INSTANCE.catVoToCatDto(catVo);
        System.out.printf("testBasicTypeConvert4CatMapper6==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        catDto.setNickName("HaHa");
        catDto.setCatType(CatType.DaJuMao);
        System.out.printf("testBasicTypeConvert4CatMapper6==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        CatVo catVo2 = CatMapper6.INSTANCE.catDtoToCatVo(catDto);
        System.out.printf("testBasicTypeConvert4CatMapper6==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo2.getClass().getName(), catVo2, catVo2.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());
    }

    // 更新对象
    public static void testUpdate() {
        CatVo catVo = CatVo.builder().nick("NoNo").catType(CatType.LiHuaMao).build();
        catVo.setName("Tom");
        catVo.setAge(1);
        catVo.setCreateTime(new Date());
        catVo.setHeight(1.25);

        CatDto catDto = CatDto.builder().nickName("HeHe").catType(CatType.LanMao).build();
        catDto.setName("Tom2");
        catDto.setAge(2);
        catDto.setCreateTime(new Date());
        catDto.setHeight(1.25);
        System.out.printf("testUpdate==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        CatMapper7.INSTANCE.updateCatFromDTO(catDto, catVo);
        System.out.printf("testUpdate==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        catDto.setNickName("HaHa");
        catDto.setCatType(CatType.DaJuMao);
        System.out.printf("testUpdate==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        catVo.setNick("HaHa123");
        catVo.setCatType(CatType.DaJuMao);
        System.out.printf("testUpdate==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());
        CatMapper7.INSTANCE.updateCatFromVO(catVo, catDto);
        System.out.printf("testUpdate==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());
    }

    // 多源映射
    public static void testMultiSourceConvert() {
        CatVo catVo = CatVo.builder().nick("NoNo").catType(CatType.LiHuaMao).build();
        catVo.setName("Tom");
        catVo.setAge(1);
        catVo.setCreateTime(new Date());
        catVo.setHeight(1.25);

        AnotherVo anotherVo = AnotherVo.builder().anotherId(100).anotherName("Tony").build();
        catVo.setAnotherVo(anotherVo);

        CatDto catDto = CatMapper8.INSTANCE.catVoToCatDto(catVo, anotherVo);
        System.out.printf("testMultiSourceConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        catDto.setNickName("HaHa");
        catDto.setCatType(CatType.DaJuMao);
        System.out.printf("testMultiSourceConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo.getClass().getName(), catVo, catVo.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());

        CatVo catVo2 = CatMapper8.INSTANCE.catDtoToCatVo(catDto);
        System.out.printf("testMultiSourceConvert==={%s}={%s}{%s}<--->{%s}={%s}{%s}\n",
                catVo2.getClass().getName(), catVo2, catVo2.hashCode(),
                catDto.getClass().getName(), catDto, catDto.hashCode());
    }
}

运行后的控制台输出验证了映射的正确性，所有字段均按预期转换，包括嵌套对象、集合以及自定义逻辑处理。