移形换影-MapStruct使用技巧

介绍

在我们开发中，涉及到对各种DO，VO，DTO之间的转换，如果你还在使用下面的工具类做这些工作

SuppliersDTO suppliersDTO = BeanUtils.copyProperties(suppliersDO, SuppliersDTO.class);

那么我觉得你很有必要了解下我即将介绍的这个框架

竞品分析

在阿里编码规范插件中有这么一条

下面我们就来分析下 Apache BeanUtils, Spring BeanUtils，Cglib BeanCopier和本文介绍的MapStruct的差别。

框架/工具类	原理	性能	功能丰富性
Apache BeanUtils	反射	差	一般
Spring BeanUtils	反射	差	弱
Cglib BeanCopier	字节码生成	强	一般
MapStruct	字节码生成	较强	强

为什么反射性能差？简单的讲下，你方法直接调用，在类加载(解析阶段，符号引用替换为直接引用)的时候就知道调用的方法地址在哪里。而反射的话，运行时获取地址，如果一个类有10个方法，遍历10个方法去计算出这个地址，肯定增加了耗时。

功能性的话，我看除了MapStruct框架外，其他几种都是让你自己实现一些转换器传入，太鸡肋了

以下是上面4中框架/工具类执行100万次对象拷贝的时间对比(单位纳秒)

Cglib BeanCopier排名第一，MapStruct排名第二。

为啥同是字节码，Cglib BeanCopier比MapStruct强，因为我的测试用例是太简单了，那么比较下复杂的场景吧，不好意思，Cglib BeanCopier能够支持的场景不够复杂。

性能和Cglib BeanCopier上差距不大，但是MapStruct使用起来太方便简洁了，所以我还是推荐使用MapStruct。

对比代码见https://github.com/shengchaojie/java_framework_contrast
下面的demo代码也在这个github项目中

如何使用

配置

...
<properties>
    <org.mapstruct.version>1.3.0.Final</org.mapstruct.version>
    <org.projectlombok.version>1.18.0</org.projectlombok.version>
</properties>
...
<dependencies>
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>${org.mapstruct.version}</version>
    </dependency>

    <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${org.projectlombok.version}</version>
            <scope>provided</scope>
        </dependency>
</dependencies>
...
<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${org.mapstruct.version}</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${org.projectlombok.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </pluginManagement>
</build>
...

上面的配置是和lombok集成的配置方式，单不仅限以上一种配置方式

使用方式

比如我有以下两个模型需要转换

@Data
public class OrderDO {

    private String orderCode;

    private String address;

}

@Data
public class OrderDTO {

    private String orderCode;

    private String address;

    private List<OrderWareDetailDTO> orderWareDetailDTOS;

}

我只需要创建一个ConvertUtil，并且加上@Mapper注解即可

@Mapper
public interface ConvertUtil {

    ConvertUtil INSTANCE = Mappers.getMapper(ConvertUtil.class);

    OrderDTO map(OrderDO orderDO);

}

通过mvn命令编译后，在target的classes目录ConvertUtil统计目录下会生成一个ConvertUtilImpl类，里面包括模型拷贝的逻辑。

上面map方法对应生成的代码如下

    public OrderDTO map(OrderDO orderDO) {
        if (orderDO == null) {
            return null;
        } else {
            OrderDTO orderDTO = new OrderDTO();
            orderDTO.setOrderCode(orderDO.getOrderCode());
            orderDTO.setAddress(orderDO.getAddress());
            return orderDTO;
        }
    }

MapStruct最基础的功能讲解完毕，下面介绍MapStruct一系列遍历的功能

更多功能

名称映射

有时候2个实体之间的名字不完全统一，但是可能代表的是一个含义，我们可以在方法上面加上@Mapping注解来实现不同名称属性的赋值

将上面OrderDTO的address改为receiverAddress，然后在对应map上增加@Mapping注解

    @Mapping(source = "address",target = "receiverAddress")
    OrderDTO map(OrderDO orderDO);

生成字节码如下

    @Override
    public OrderDTO map(OrderDO orderDO) {
        if ( orderDO == null ) {
            return null;
        }

        OrderDTO orderDTO = new OrderDTO();

        orderDTO.setReceiverAddress( orderDO.getAddress() );
        orderDTO.setOrderCode( orderDO.getOrderCode() );

        return orderDTO;
    }

传入返回

上面的基础功能，转换后的模型是通过方法结果返回的，MapStruct也支持对传入对象的赋值

    @Mapping(source = "address",target = "receiverAddress")
    void map(OrderDO orderDO,@MappingTarget OrderDTO orderDTO);

对应字节码如下

    @Override
    public void map(OrderDO orderDO, OrderDTO orderDTO) {
        if ( orderDO == null ) {
            return;
        }

        orderDTO.setReceiverAddress( orderDO.getAddress() );
        orderDTO.setOrderCode( orderDO.getOrderCode() );
    }

多合一

上面可以看到，OrderDO转换成OrderDTO的时候，我没有处理orderWareDetailDTOS，MapStruct支持多个对象转换为一个对象。

    @Mapping(source = "orderDO.address",target = "receiverAddress")
    @Mapping(source = "orderWareDetailDTOList",target = "orderWareDetailDTOS")
    OrderDTO map(OrderDO orderDO,List<OrderWareDetailDTO> orderWareDetailDTOList);

对应字节码如下

    @Override
    public OrderDTO map(OrderDO orderDO, List<OrderWareDetailDTO> orderWareDetailDTOList) {
        if ( orderDO == null && orderWareDetailDTOList == null ) {
            return null;
        }

        OrderDTO orderDTO = new OrderDTO();

        if ( orderDO != null ) {
            orderDTO.setReceiverAddress( orderDO.getAddress() );
            orderDTO.setOrderCode( orderDO.getOrderCode() );
        }
        if ( orderWareDetailDTOList != null ) {
            List<OrderWareDetailDTO> list = orderWareDetailDTOList;
            if ( list != null ) {
                orderDTO.setOrderWareDetailDTOS( new ArrayList<OrderWareDetailDTO>( list ) );
            }
        }

        return orderDTO;
    }

嵌套转换

可以注意到我上面的OrderDTO有orderWareDetailDTOS这个属性，并且是一个List，然后我有下面对应的OrderVO需要进行转换。

@Data
public class OrderVO {

    private String orderCode;

    private String address;

    private List<OrderWareDetailVO> orderWareDetailVOList;

}

可以看到对应2个模型内的list属性类型是不一样的，其他3中转换框架做不到这个，或者做起来挺麻烦。但是在MapStruct只要加一下2个接口方法即可。

    @Mapping(target = "orderWareDetailVOList",source = "orderWareDetailDTOS")
    @Mapping(target = "address",source = "receiverAddress")
    OrderVO map(OrderDTO orderDTO);

    OrderWareDetailVO map(OrderWareDetailDTO orderWareDetailDTO);

生成的字节码如下

    @Override
    public OrderVO map(OrderDTO orderDTO) {
        if ( orderDTO == null ) {
            return null;
        }

        OrderVO orderVO = new OrderVO();

        orderVO.setOrderWareDetailVOList( orderWareDetailDTOListToOrderWareDetailVOList( orderDTO.getOrderWareDetailDTOS() ) );
        orderVO.setAddress( orderDTO.getReceiverAddress() );
        orderVO.setOrderCode( orderDTO.getOrderCode() );

        return orderVO;
    }

    @Override
    public OrderWareDetailVO map(OrderWareDetailDTO orderWareDetailDTO) {
        if ( orderWareDetailDTO == null ) {
            return null;
        }

        OrderWareDetailVO orderWareDetailVO = new OrderWareDetailVO();

        orderWareDetailVO.setWareCode( orderWareDetailDTO.getWareCode() );

        return orderWareDetailVO;
    }

    protected List<OrderWareDetailVO> orderWareDetailDTOListToOrderWareDetailVOList(List<OrderWareDetailDTO> list) {
        if ( list == null ) {
            return null;
        }

        List<OrderWareDetailVO> list1 = new ArrayList<OrderWareDetailVO>( list.size() );
        for ( OrderWareDetailDTO orderWareDetailDTO : list ) {
            list1.add( map( orderWareDetailDTO ) );
        }

        return list1;
    }

可以看出来这个框架不是简单的生成对应赋值的字节码，如果它遇到不能解析的转换，它会从所在接口的方法中去检查是否有对应转换逻辑。

其他

其他还有很多特性，比如对于数字类型，只要属性名一样，它会自动转换，当然高精度转低精度可能会损失精度。也包括对各种时间，以及string和int之间的互转。我上面的举的例子是我在开发中比较常见的一些点，你有更加复杂的场景推荐阅读官方文档。

原理

别看MapStruct和lombok都是通过注解来做文章，但是他们的原理是不同的。lombok是修改原有类的字节码，用的是jvm提供的Instrument机制。
看它的META-INF/MANIFEST.MF文件就知道了

Manifest-Version: 1.0
Ant-Version: Apache Ant 1.7.1
Created-By: 14.3-b01-101 (Apple Inc.)
Premain-Class: lombok.launch.Agent
Agent-Class: lombok.launch.Agent
Can-Redefine-Classes: true
Main-Class: lombok.launch.Main
Lombok-Version: 1.18.0

而MapStruct用到了APT（Annotation Processing Tool 简称，即注解处理器）这个技术，通过spi提供实现类，会在编译阶段处理特定注解。

我们上面的配置方式没有看不到注解解析器的依赖，maven帮我们做了这个事，通过下面依赖把MapStruct APT的jar包引入项目

        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-processor</artifactId>
            <version>${org.mapstruct.version}</version>
            <scope>provided</scope>
        </dependency>

在jar包的services目录下可以看到javax.annotation.processing.Processor文件,内容为

org.mapstruct.ap.MappingProcessor

具体怎么处理大家自己研究。

写这些框架的人，可见对java每个版本的特性有多了解。

参考

Java反射到底慢在哪
 官方文档多多了解
 Java中的APT的工作过程