干掉BeanUtils！试试这款Bean自动映射工具，真心强大！！

开发背景

你有没有遇到过这样的开发场景?

服务通过接口对外提供数据，或者服务之间进行数据交互，首先查询数据库并映射成数据对象(XxxDO)。

正常情况下，接口是不允许直接以数据库数据对象 XxxDO 形式对外提供数据的，而是要再封装成数据传输对象(XxxDTO)提供出去。

为什么不能直接提供 DO?

1)根据单一设计原则，DO 只能对应数据实体对象，不能承担其他职责;

2)DO 可能包含表所有字段数据，不符合接口的参数定义，数据如果过大会影响传输速度，也不符合数据安全原则;

3)根据《阿里 Java 开发手册》分层领域模型规约，不能一个对象走天下，需要定义成 POJO/DO/BO/DTO/VO/Query 等数据对象，完整的定义可以参考阿里开发手册，关注公众号：Java技术栈，在后台回复：手册，可以获取最新高清完整版。

传统 DO -> DTO 做法

XxxDTO 可能包含 XxxDO 大部分数据，或者组合其他 DO 的部分数据，传统的做法有以下几种：

  • get/ set
  • 构造器
  • BeanUtils 工具类
  • Builder 模式

我相信大部分人的做法都是这样的，虽然很直接，但是普遍真的很 Low，耦合性又强，还经常丢参数，或者搞错参数值，在这个开发场景，我个人觉得这些都不是最佳的方式。

这种开发场景又实在是太常见了，那有没有一种 Java bean 自动映射工具?

没错——正是 MapStruct!!

MapStruct 简介

官网地址：

https://mapstruct.org/

开源地址：

https://github.com/mapstruct/mapstruct

Java bean mappings, the easy way!

以简单的方式进行 Java bean 映射。

MapStruct 是一个代码生成器，它和 Spring Boot、Maven 一样也是基于约定优于配置的理念，极大地简化了 Java bean 之间数据映射的实现。

MapStruct 的优势：

1、MapStruct 使用简单的方法调用生成映射代码，因此***速度非常快***;

2、类型安全，避免出错，只能映射相互映射的对象和属性，因此不会错误将用户实体错误地映射到订单 DTO;

3、只需要 JDK 1.8+，不用其他任何依赖，自包含所有代码;

4、易于调试;

5、易于理解;

支持的方式：

MapStruct 支持命令行编译，如：纯 javac 命令、Maven、Gradle、Ant 等等，也支持 Eclipse、IntelliJ IDEA 等 IDEs。

MapStruct 实战

本文栈长基于 IntelliJ IDEA、Spring Boot、Maven 进行演示。

基本准备

新增两个数据库 DO 类：

一个用户主类，一个用户扩展类。

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 微信公众号：Java技术栈 
    3.   
  
  
  
  3.  * @author 栈长 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. @Data 
    6.   
  
  
  
  6. public class UserDO { 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     private String name; 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     private int sex; 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     private int age; 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.     private Date birthday; 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.     private String phone; 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.     private boolean married; 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.     private Date regDate; 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.     private Date loginDate; 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.     private String memo; 
    25.   
  
  
  
  25.  
    26.   
  
  
  
  26.     private UserExtDO userExtDO; 
    27.   
  
  
  
  27.  
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29. } 
    30.  
 
 
 
 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 微信公众号：Java技术栈 
    3.   
  
  
  
  3.  * @author 栈长 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. @Data 
    6.   
  
  
  
  6. public class UserExtDO { 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     private String regSource; 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     private String favorite; 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     private String school; 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.     private int kids; 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.     private String memo; 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18. } 
    19.

新增一个数据传输 DTO 类：

用户展示类，包含用户主类、用户扩展类的部分数据。

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 微信公众号：Java技术栈 
    3.   
  
  
  
  3.  * @author 栈长 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. @Data 
    6.   
  
  
  
  6. public class UserShowDTO { 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     private String name; 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     private int sex; 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     private boolean married; 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.     private String birthday; 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.     private String regDate; 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.     private String registerSource; 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.     private String favorite; 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.     private String memo; 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24. } 
    25.

开始实战

重点来了，不要 get/set，不要 BeanUtils，怎么把两个用户对象的数据封装到 DTO 对象?

Spring Boot 基础这篇就不介绍了，系列基础教程和示例源码可以看这里：https://github.com/javastacks/spring-boot-best-practice

引入 MapStruct 依赖：

 
 
 
 
    
  
  
  
  
  1.  
    2.   
  
  
  
  2.      
    3.   
  
  
  
  3.         org.mapstruct 
    4.   
  
  
  
  4.         mapstruct 
    5.   
  
  
  
  5.         ${org.mapstruct.version} 
    6.   
  
  
  
  6.      
    7.   
  
  
  
  7.  
    8.

Maven 插件相关配置：

MapStruct 和 Lombok 结合使用会有版本冲突问题，注意以下配置。

 
 
 
 
    
  
  
  
  
  1.  
    2.   
  
  
  
  2.      
    3.   
  
  
  
  3.          
    4.   
  
  
  
  4.             org.apache.maven.plugins 
    5.   
  
  
  
  5.             maven-compiler-plugin 
    6.   
  
  
  
  6.             3.8.1 
    7.   
  
  
  
  7.              
    8.   
  
  
  
  8.                 1.8 
    9.   
  
  
  
  9.                 1.8 
    10.   
  
  
  
  10.                  
    11.   
  
  
  
  11.                      
    12.   
  
  
  
  12.                         org.mapstruct 
    13.   
  
  
  
  13.                         mapstruct-processor 
    14.   
  
  
  
  14.                         ${org.mapstruct.version} 
    15.   
  
  
  
  15.                      
    16.   
  
  
  
  16.                      
    17.   
  
  
  
  17.                      
    18.   
  
  
  
  18.                         org.projectlombok 
    19.   
  
  
  
  19.                         lombok 
    20.   
  
  
  
  20.                         ${org.projectlombok.version} 
    21.   
  
  
  
  21.                      
    22.   
  
  
  
  22.                      
    23.   
  
  
  
  23.                      
    24.   
  
  
  
  24.                         org.projectlombok 
    25.   
  
  
  
  25.                         lombok-mapstruct-binding 
    26.   
  
  
  
  26.                         ${lombok-mapstruct-binding.version} 
    27.   
  
  
  
  27.                      
    28.   
  
  
  
  28.                  
    29.   
  
  
  
  29.              
    30.   
  
  
  
  30.          
    31.   
  
  
  
  31.      
    32.   
  
  
  
  32.  
    33.

添加 MapStruct 映射：

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 微信公众号：Java技术栈 
    3.   
  
  
  
  3.  * @author 栈长 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. @Mapper 
    6.   
  
  
  
  6. public interface UserStruct { 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     UserStruct INSTANCE = Mappers.getMapper(UserStruct.class); 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.  @Mappings({ 
    11.   
  
  
  
  11.         @Mapping(source = "birthday", target = "birthday", dateFormat = "yyyy-MM-dd") 
    12.   
  
  
  
  12.         @Mapping(target = "regDate", expression = "java(org.apache.commons.lang3.time.DateFormatUtils.format(userDO.getRegDate(),\"yyyy-MM-dd HH:mm:ss\"))") 
    13.   
  
  
  
  13.         @Mapping(source = "userExtDO.regSource", target = "registerSource") 
    14.   
  
  
  
  14.         @Mapping(source = "userExtDO.favorite", target = "favorite") 
    15.   
  
  
  
  15.         @Mapping(target = "memo", ignore = true) 
    16.   
  
  
  
  16.     }) 
    17.   
  
  
  
  17.     UserShowDTO toUserShowDTO(UserDO userDO); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.     List toUserShowDTOs(List userDOs); 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21. } 
    22.

重点说明：

1)添加一个 interface 接口，使用 MapStruct 的 @Mapper 注解修饰，这里取名 XxxStruct，是为了不和 MyBatis 的 Mapper 混淆;

2)使用 Mappers 添加一个 INSTANCE 实例，也可以使用 Spring 注入，后面会讲到;

3)添加两个映射方法，返回单个对象、对象列表;

4)使用 @Mappings + @Mapping 组合映射，如果两个字段名相同可以不用写，可以指定映射的日期格式、数字格式、表达式等，ignore 表示忽略该字段映射;

5)List 方法的映射会调用单个方法映射，不用单独映射，后面看源码就知道了;

另外，Java 8+ 以上版本不需要 @Mappings 注解，直接使用 @Mapping 注解就行了：

Java 8 修改之后：

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 微信公众号：Java技术栈 
    3.   
  
  
  
  3.  * @author 栈长 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. @Mapper 
    6.   
  
  
  
  6. public interface UserStruct { 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     UserStruct INSTANCE = Mappers.getMapper(UserStruct.class); 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     @Mapping(source = "birthday", target = "birthday", dateFormat = "yyyy-MM-dd") 
    11.   
  
  
  
  11.     @Mapping(target = "regDate", expression = "java(org.apache.commons.lang3.time.DateFormatUtils.format(userDO.getRegDate(),\"yyyy-MM-dd HH:mm:ss\"))") 
    12.   
  
  
  
  12.     @Mapping(source = "userExtDO.regSource", target = "registerSource") 
    13.   
  
  
  
  13.     @Mapping(source = "userExtDO.favorite", target = "favorite") 
    14.   
  
  
  
  14.     @Mapping(target = "memo", ignore = true) 
    15.   
  
  
  
  15.     UserShowDTO toUserShowDTO(UserDO userDO); 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.     List toUserShowDTOs(List userDOs); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. } 
    20.

测试一下：

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 微信公众号：Java技术栈 
    3.   
  
  
  
  3.  * @author 栈长 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. public class UserStructTest { 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.     @Test 
    8.   
  
  
  
  8.     public void test1() { 
    9.   
  
  
  
  9.         UserExtDO userExtDO = new UserExtDO(); 
    10.   
  
  
  
  10.         userExtDO.setRegSource("公众号：Java技术栈"); 
    11.   
  
  
  
  11.         userExtDO.setFavorite("写代码"); 
    12.   
  
  
  
  12.         userExtDO.setSchool("社会大学"); 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         UserDO userDO = new UserDO(); 
    15.   
  
  
  
  15.         userDO.setName("栈长"); 
    16.   
  
  
  
  16.         userDO.setSex(1); 
    17.   
  
  
  
  17.         userDO.setAge(18); 
    18.   
  
  
  
  18.         userDO.setBirthday(new Date()); 
    19.   
  
  
  
  19.         userDO.setPhone("18888888888"); 
    20.   
  
  
  
  20.         userDO.setMarried(true); 
    21.   
  
  
  
  21.         userDO.setRegDate(new Date()); 
    22.   
  
  
  
  22.         userDO.setMemo("666"); 
    23.   
  
  
  
  23.         userDO.setUserExtDO(userExtDO); 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25.         UserShowDTO userShowDTO = UserStruct.INSTANCE.toUserShowDTO(userDO); 
    26.   
  
  
  
  26.         System.out.println("=====单个对象映射====="); 
    27.   
  
  
  
  27.         System.out.println(userShowDTO); 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.         List userDOs = new ArrayList<>(); 
    30.   
  
  
  
  30.         UserDO userDO2 = new UserDO(); 
    31.   
  
  
  
  31.         BeanUtils.copyProperties(userDO, userDO2); 
    32.   
  
  
  
  32.         userDO2.setName("栈长2"); 
    33.   
  
  
  
  33.         userDOs.add(userDO); 
    34.   
  
  
  
  34.         userDOs.add(userDO2); 
    35.   
  
  
  
  35.         List userShowDTOs = UserStruct.INSTANCE.toUserShowDTOs(userDOs); 
    36.   
  
  
  
  36.         System.out.println("=====对象列表映射====="); 
    37.   
  
  
  
  37.         userShowDTOs.forEach(System.out::println); 
    38.   
  
  
  
  38.     } 
    39.   
  
  
  
  39. } 
    40.

输出结果：

来看结果，数据转换结果成功。

什么原理?

如上我们知道，通过一个注解修饰接口就可以搞定了，是什么原理呢?

来看编译后的目录：

原理就是在编译期间生成了一个该接口的实现类。

打开看下其源码：

 
 
 
 
    
  
  
  
  
  1. public class UserStructImpl implements UserStruct { 
    2.   
  
  
  
  2.     public UserStructImpl() { 
    3.   
  
  
  
  3.     } 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     public UserShowDTO toUserShowDTO(UserDO userDO) { 
    6.   
  
  
  
  6.         if (userDO == null) { 
    7.   
  
  
  
  7.             return null; 
    8.   
  
  
  
  8.         } else { 
    9.   
  
  
  
  9.             UserShowDTO userShowDTO = new UserShowDTO(); 
    10.   
  
  
  
  10.             if (userDO.getBirthday() != null) { 
    11.   
  
  
  
  11.                 userShowDTO.setBirthday((new SimpleDateFormat("yyyy-MM-dd")).format(userDO.getBirthday())); 
    12.   
  
  
  
  12.             } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.             userShowDTO.setRegisterSource(this.userDOUserExtDORegSource(userDO)); 
    15.   
  
  
  
  15.             userShowDTO.setFavorite(this.userDOUserExtDOFavorite(userDO)); 
    16.   
  
  
  
  16.             userShowDTO.setName(userDO.getName()); 
    17.   
  
  
  
  17.             userShowDTO.setSex(userDO.getSex()); 
    18.   
  
  
  
  18.             userShowDTO.setMarried(userDO.isMarried()); 
    19.   
  
  
  
  19.             userShowDTO.setRegDate(DateFormatUtils.format(userDO.getRegDate(), "yyyy-MM-dd HH:mm:ss")); 
    20.   
  
  
  
  20.             return userShowDTO; 
    21.   
  
  
  
  21.         } 
    22.   
  
  
  
  22.     } 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.     public List toUserShowDTOs(List userDOs) { 
    25.   
  
  
  
  25.         if (userDOs == null) { 
    26.   
  
  
  
  26.             return null; 
    27.   
  
  
  
  27.         } else { 
    28.   
  
  
  
  28.             List list = new ArrayList(userDOs.size()); 
    29.   
  
  
  
  29.             Iterator var3 = userDOs.iterator(); 
    30.   
  
  
  
  30.  
    31.   
  
  
  
  31.             while(var3.hasNext()) { 
    32.   
  
  
  
  32.                 UserDO userDO = (UserDO)var3.next(); 
    33.   
  
  
  
  33.                 list.add(this.toUserShowDTO(userDO)); 
    34.   
  
  
  
  34.             } 
    35.   
  
  
  
  35.  
    36.   
  
  
  
  36.             return list; 
    37.   
  
  
  
  37.         } 
    38.   
  
  
  
  38.     } 
    39.   
  
  
  
  39.  
    40.   
  
  
  
  40.     private String userDOUserExtDORegSource(UserDO userDO) { 
    41.   
  
  
  
  41.         if (userDO == null) { 
    42.   
  
  
  
  42.             return null; 
    43.   
  
  
  
  43.         } else { 
    44.   
  
  
  
  44.             UserExtDO userExtDO = userDO.getUserExtDO(); 
    45.   
  
  
  
  45.             if (userExtDO == null) { 
    46.   
  
  
  
  46.                 return null; 
    47.   
  
  
  
  47.             } else { 
    48.   
  
  
  
  48.                 String regSource = userExtDO.getRegSource(); 
    49.   
  
  
  
  49.                 return regSource == null ? null : regSource; 
    50.   
  
  
  
  50.             } 
    51.   
  
  
  
  51.         } 
    52.   
  
  
  
  52.     } 
    53.   
  
  
  
  53.  
    54.   
  
  
  
  54.     private String userDOUserExtDOFavorite(UserDO userDO) { 
    55.   
  
  
  
  55.         if (userDO == null) { 
    56.   
  
  
  
  56.             return null; 
    57.   
  
  
  
  57.         } else { 
    58.   
  
  
  
  58.             UserExtDO userExtDO = userDO.getUserExtDO(); 
    59.   
  
  
  
  59.             if (userExtDO == null) { 
    60.   
  
  
  
  60.                 return null; 
    61.   
  
  
  
  61.             } else { 
    62.   
  
  
  
  62.                 String favorite = userExtDO.getFavorite(); 
    63.   
  
  
  
  63.                 return favorite == null ? null : favorite; 
    64.   
  
  
  
  64.             } 
    65.   
  
  
  
  65.         } 
    66.   
  
  
  
  66.     } 
    67.   
  
  
  
  67. } 
    68.

其实实现类就是调用了对象的 get/set 等其他常规操作，而 List 就是循环调用的该对象的单个映射方法，这下就清楚了吧!

Spring 注入法

上面的示例创建了一个 UserStruct 实例：

 
 
 
 
    
  
  
  
  
  1. UserStruct INSTANCE = Mappers.getMapper(UserStruct.class); 
    2.

如 @Mapper 注解源码所示：

参数 componentModel 默认值是 default，也就是手动创建实例，也可以通过 Spring 注入。

Spring 修改版如下：

干掉了 INSTANCE，@Mapper 注解加入了 componentModel = "spring" 值。

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 微信公众号：Java技术栈 
    3.   
  
  
  
  3.  * @author 栈长 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. @Mapper(componentModel = "spring") 
    6.   
  
  
  
  6. public interface UserSpringStruct { 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     @Mapping(source = "birthday", target = "birthday", dateFormat = "yyyy-MM-dd") 
    9.   
  
  
  
  9.     @Mapping(target = "regDate", expression = "java(org.apache.commons.lang3.time.DateFormatUtils.format(userDO.getRegDate(),\"yyyy-MM-dd HH:mm:ss\"))") 
    10.   
  
  
  
  10.     @Mapping(source = "userExtDO.regSource", target = "registerSource") 
    11.   
  
  
  
  11.     @Mapping(source = "userExtDO.favorite", target = "favorite") 
    12.   
  
  
  
  12.     @Mapping(target = "memo", ignore = true) 
    13.   
  
  
  
  13.     UserShowDTO toUserShowDTO(UserDO userDO); 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.     List toUserShowDTOs(List userDOS); 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17. } 
    18.

测试一下：

本文用到了 Spring Boot，所以这里就要用到 Spring Boot 的单元测试方法。Spring Boot 单元测试不懂的可以关注公众号：Java技术栈，在后台回复：boot，系列教程都整理好了。

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * 微信公众号：Java技术栈 
    3.   
  
  
  
  3.  * @author 栈长 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. @RunWith(SpringRunner.class) 
    6.   
  
  
  
  6. @SpringBootTest 
    7.   
  
  
  
  7. public class UserSpringStructTest { 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     @Autowired 
    10.   
  
  
  
  10.     private UserSpringStruct userSpringStruct; 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     @Test 
    13.   
  
  
  
  13.     public void test1() { 
    14.   
  
  
  
  14.         UserExtDO userExtDO = new UserExtDO(); 
    15.   
  
  
  
  15.         userExtDO.setRegSource("公众号：Java技术栈"); 
    16.   
  
  
  
  16.         userExtDO.setFavorite("写代码"); 
    17.   
  
  
  
  17.         userExtDO.setSchool("社会大学"); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.         UserDO userDO = new UserDO(); 
    20.   
  
  
  
  20.         userDO.setName("栈长Spring"); 
    21.   
  
  
  
  21.         userDO.setSex(1); 
    22.   
  
  
  
  22.         userDO.setAge(18); 
    23.   
  
  
  
  23.         userDO.setBirthday(new Date()); 
    24.   
  
  
  
  24.         userDO.setPhone("18888888888"); 
    25.   
  
  
  
  25.         userDO.setMarried(true); 
    26.   
  
  
  
  26.         userDO.setRegDate(new Date()); 
    27.   
  
  
  
  27.         userDO.setMemo("666"); 
    28.   
  
  
  
  28.         userDO.setUserExtDO(userExtDO); 
    29.   
  
  
  
  29.  
    30.   
  
  
  
  30.         UserShowDTO userShowDTO = userSpringStruct.toUserShowDTO(userDO); 
    31.   
  
  
  
  31.         System.out.println("=====单个对象映射====="); 
    32.   
  
  
  
  32.         System.out.println(userShowDTO); 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.         List userDOs = new ArrayList<>(); 
    35.   
  
  
  
  35.         UserDO userDO2 = new UserDO(); 
    36.   
  
  
  
  36.         BeanUtils.copyProperties(userDO, userDO2); 
    37.   
  
  
  
  37.         userDO2.setName("栈长Spring2"); 
    38.   
  
  
  
  38.         userDOs.add(userDO); 
    39.   
  
  
  
  39.         userDOs.add(userDO2); 
    40.   
  
  
  
  40.         List userShowDTOs = userSpringStruct.toUserShowDTOs(userDOs); 
    41.   
  
  
  
  41.         System.out.println("=====对象列表映射====="); 
    42.   
  
  
  
  42.         userShowDTOs.forEach(System.out::println); 
    43.   
  
  
  
  43.     } 
    44.   
  
  
  
  44. } 
    45.

如上所示，直接使用 @Autowired 注入就行，使用更方便。

输出结果：

没毛病，稳如狗。

总结

本文栈长只是介绍了 MapStruct 的简单用法，使用 MapStruct 可以使代码更优雅，还能避免出错，其实还有很多复杂的、个性化用法，一篇难以写完，栈长后面有时间会整理出来，陆续给大家分享。

感兴趣的也可以参考官方文档：

https://mapstruct.org/documentation/reference-guide/

本文实战源代码完整版已经上传：

https://github.com/javastacks/spring-boot-best-practice

欢迎 Star 学习，后面 Spring Boot 示例都会在这上面提供!

本文转载自微信公众号「Java技术栈」，可以通过以下二维码关注。转载本文请联系Java技术栈公众号。

分享题目：干掉BeanUtils！试试这款Bean自动映射工具，真心强大！！
文章来源：http://www.mswzjz.cn/qtweb/news40/419740.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

网站导航知识

同城分类信息

网站推广　　 　手机网站建设　　 　虚拟主机　　 　成都LED亮化工程　　 　app开发公司　　 　乐山装修公司　　 　LOGO设计　　 　成都模板网站　　 　成都服务器托管　　 　成都光华机房　　 　成都能净科技　　 　电商网站建设　　 　成都网站建设　　 　绵阳电信机房　　 　专业LED亮化工程　　 　江油做网站　　 　网站空间　　 　温江服务器托管　　 　云服务器　　 　成都众诚伟业