一、引入

在没有遇见mapstruct的时候，实现各个实体之间的转换，都是手动转换实现的，属性少一带你还好，当属性一多，代码就会变得很冗余，没必要的非逻辑的代码就会加多。。。。

比如：

public class UserDTO {private String username;private String email;private boolean isActive;// Getters and setters// Constructor// Other methods as needed
}// BO: UserBO.java
public class UserBO {private String username;private String email;private boolean isActive;// Getters and setters// Constructor// Business methods as needed
}

手动实现类型转换：

public class UserConverter {public static UserBO convertToBO(UserDTO userDTO) {UserBO userBO = new UserBO();userBO.setUsername(userDTO.getUsername());userBO.setEmail(userDTO.getEmail());userBO.setActive(userDTO.isActive());return userBO;}public static UserDTO convertToDTO(UserBO userBO) {UserDTO userDTO = new UserDTO();userDTO.setUsername(userBO.getUsername());userDTO.setEmail(userBO.getEmail());userDTO.setActive(userBO.isActive());return userDTO;}
}

这种方式，就很费时费力，一个突然的契机，我在学习DDD（领域驱动设计）架构的时候，发现up使用的mapstruct做的实体之间的转换，后面也了解了一下，发现这个工具还是很优秀的。

二、Mapstruct

MapStruct 是一个代码生成器，用于创建实现Java Bean之间转换的扩展映射器，它基于约定优于配置的方法极大地简化了 Java bean 之间映射的实现，我们只需要创建接口，MapStruct就会在编译时自动创建一个具体的实现进行对象的转换

2.1、Mapstruct和BeanUtil的比较 

Mapstruct的性能远远高于BeanUtils，这应该是大佬使用Mapstruct的主要原因，下面是我的测试结果，可以看出随着属性个数的增加，BeanUtils的耗时也在增加，并且BeanUtils的耗时跟属性个数成正比，而Mapstruct的耗时却一直是1秒，所以从对比数据可以看出Mapstruct是非常优秀的，其性能远远超过BeanUtil


BeanUtils 只能同属性映射，或者在属性相同的情况下，允许被映射的对象属性少；但当遇到被映射的属性数据类型被修改或者被映射的字段名被修改，则会导致映射失败。

 

2.2、优势，为什么选择Mapstruct

2.3、快速入门

2.3.1、引入依赖

 <dependency><groupId>org.mapstruct</groupId><artifactId>mapstruct</artifactId><version>1.4.2.Final</version></dependency><dependency><groupId>org.mapstruct</groupId><artifactId>mapstruct-processor</artifactId><version>1.4.2.Final</version></dependency>

2.3.1、定义DTO和BO 

/*** SubjectCategoryDTO*/
@Data
public class SubjectCategoryDTO implements Serializable {private static final long serialVersionUID = -36288445272926615L;private Long id;private String categoryName;private Integer categoryType;private String imageUrl;private Long parentId;private Integer count;}

@Data
public class SubjectCategoryBO implements Serializable {private static final long serialVersionUID = -36288445272926615L;private Long id;private String categoryName;private Integer categoryType;private String imageUrl;private Long parentId;private Integer count;
}

2.4.1、定义Convert接口

@Mapper
public interface SubjectCategoryDTOConvert {SubjectCategoryDTOConvert INSTANCE = Mappers.getMapper(SubjectCategoryDTOConvert.class);//将DTO转换为BOSubjectCategoryBO convertDTOToBO(SubjectCategoryDTO subjectCategoryDTO);//将List<BO>转换为List<DTO>List<SubjectCategoryDTO> convertBoListToDTOList(List<SubjectCategoryBO> subjectCategoryBOList);//将BO转换为DTOSubjectCategoryDTO convertBoToCategoryDTO(SubjectCategoryBO subjectCategoryBO);
}

2.4、性能好的原因

Java程序执行的过程，是由编译器先把java文件编译成class字节码文件，然后由JVM去解释执行class文件。Mapstruct正是在java文件到class这一步帮我们实现了转换方法，即做了预处理，提前编译好文件，如果用过lombok的同学一定能理解其好处，通过查看class文件，可以看出SubjectCategoryDTOConvert 被打上org.mapstruct.Mapper注解后，编译器自动会帮我们生成一个实现类SubjectCategoryDTOConvertImpl，并实现了convertDTOToBO、convertBoListToDTOList、convertBoToCategoryDTO这些方法

 

从生成的代码可以看出，转化过程非常简单，只使用了UserPo的get方法和UserEntity的set方法，没有复杂的逻辑处理，清晰明了，所以性能很高

 相对于BeanUtils来说

BeanUtils，转换的原理是使用的反射，反射的效率相对来说是低的，因为jvm优化在这种场景下有可能无效，所以在对性能要求很高或者经常被调用的程序中，尽量不要使用。我们平时在研发过程中，也会遵守这个原则，非必要，不反射。


从下面的BeanUtils的copyProperties方法代码中可以看出，转化逻辑非常复杂，有很多的遍历，去获取属性，获取方法，设置方法可访问，然后执行，所以执行效率相对Mapstruct来说，是非常低的。回头看Mapstruct自动生成的实现类，简洁、高效

 BeanUtils的copyProperties方法的源码：

 private static void copyProperties(Object source, Object target, @Nullable Class<?> editable, @Nullable String... ignoreProperties) throws BeansException {Assert.notNull(source, "Source must not be null");Assert.notNull(target, "Target must not be null");Class<?> actualEditable = target.getClass();if (editable != null) {if (!editable.isInstance(target)) {throw new IllegalArgumentException("Target class [" + target.getClass().getName() + "] not assignable to Editable class [" + editable.getName() + "]");}actualEditable = editable;}PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);List<String> ignoreList = ignoreProperties != null ? Arrays.asList(ignoreProperties) : null;PropertyDescriptor[] var7 = targetPds;int var8 = targetPds.length;for(int var9 = 0; var9 < var8; ++var9) {PropertyDescriptor targetPd = var7[var9];Method writeMethod = targetPd.getWriteMethod();if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());if (sourcePd != null) {Method readMethod = sourcePd.getReadMethod();if (readMethod != null) {ResolvableType sourceResolvableType = ResolvableType.forMethodReturnType(readMethod);ResolvableType targetResolvableType = ResolvableType.forMethodParameter(writeMethod, 0);if (targetResolvableType.isAssignableFrom(sourceResolvableType)) {try {if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {readMethod.setAccessible(true);}Object value = readMethod.invoke(source);if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {writeMethod.setAccessible(true);}writeMethod.invoke(target, value);} catch (Throwable var17) {throw new FatalBeanException("Could not copy property '" + targetPd.getName() + "' from source to target", var17);}}}}}}}

所以综上所述，

Mapstruct的高性能是毋庸置疑的，这也是我选择使用他的根本原因。在使用方式上和BeanUtils对比，Mapstruct需要创建mapper接口和自定义转换工具类，其实上手成本并不高，但是我们换取了高性能，这是非常值得的，所以强烈推荐大家使用Mapstruct，是时候和BeanUtils说再见了

对于 Mapstruct更深入的学习，大家可以自己自行搜索学习~