5种常见Bean映射工具的性能比对

时间 2019-11-16

原文原文链接

本文由 JavaGuide 翻译自 https://www.baeldung.com/java-performance-mapping-frameworks 。转载请注明原文地址以及翻译做者。html

1. 介绍

建立由多个层组成的大型 Java 应用程序须要使用多种领域模型，如持久化模型、领域模型或者所谓的 DTO。为不一样的应用程序层使用多个模型将要求咱们提供 bean 之间的映射方法。手动执行此操做能够快速建立大量样板代码并消耗大量时间。幸运的是，Java 有多个对象映射框架。在本教程中，咱们将比较最流行的 Java 映射框架的性能。java

综合平常使用状况和相关测试数据，我的感受 MapStruct、ModelMapper 这两个 Bean 映射框架是最佳选择。git

2. 常见 Bean 映射框架概览

2.1. Dozer

Dozer 是一个映射框架，它使用递归将数据从一个对象复制到另外一个对象。框架不只可以在 bean 之间复制属性，还可以在不一样类型之间自动转换。程序员

要使用 Dozer 框架，咱们须要添加这样的依赖到咱们的项目:github

<dependency>
    <groupId>net.sf.dozer</groupId>
    <artifactId>dozer</artifactId>
    <version>5.5.1</version>
</dependency>复制代码

更多关于 Dozer 的内容能够在官方文档中找到： http://dozer.sourceforge.net/documentation/gettingstarted.html ，或者你也能够阅读这篇文章：https://www.baeldung.com/dozer 。面试

2.2. Orika

Orika 是一个 bean 到 bean 的映射框架，它递归地将数据从一个对象复制到另外一个对象。算法

Orika 的工做原理与 Dozer 类似。二者之间的主要区别是 Orika 使用字节码生成。这容许以最小的开销生成更快的映射器。spring

要使用 Orika 框架，咱们须要添加这样的依赖到咱们的项目:后端

<dependency>
    <groupId>ma.glasnost.orika</groupId>
    <artifactId>orika-core</artifactId>
    <version>1.5.2</version>
</dependency>复制代码

更多关于 Orika 的内容能够在官方文档中找到：https://orika-mapper.github.io/orika-docs/，或者你也能够阅读这篇文章：https://www.baeldung.com/orika-mapping。api

2.3. MapStruct

MapStruct 是一个自动生成 bean mapper 类的代码生成器。MapStruct 还可以在不一样的数据类型之间进行转换。Github 地址：https://github.com/mapstruct/mapstruct。

要使用 MapStruct 框架，咱们须要添加这样的依赖到咱们的项目:

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>1.2.0.Final</version>
</dependency>复制代码

更多关于 MapStruct 的内容能够在官方文档中找到：https://mapstruct.org/，或者你也能够阅读这篇文章：https://www.baeldung.com/mapstruct。

要使用 MapStruct 框架，咱们须要添加这样的依赖到咱们的项目:

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>1.2.0.Final</version>
</dependency>复制代码

2.4. ModelMapper

ModelMapper 是一个旨在简化对象映射的框架，它根据约定肯定对象之间的映射方式。它提供了类型安全的和重构安全的 API。

更多关于 ModelMapper 的内容能够在官方文档中找到：http://modelmapper.org/ 。

要使用 ModelMapper 框架，咱们须要添加这样的依赖到咱们的项目:

<dependency>
  <groupId>org.modelmapper</groupId>
  <artifactId>modelmapper</artifactId>
  <version>1.1.0</version>
</dependency>复制代码

2.5. JMapper

JMapper 是一个映射框架，旨在提供易于使用的、高性能的 Java bean 之间的映射。该框架旨在使用注释和关系映射应用 DRY 原则。该框架容许不一样的配置方式:基于注释、XML 或基于 api。

更多关于 JMapper 的内容能够在官方文档中找到：https://github.com/jmapper-framework/jmapper-core/wiki。

要使用 JMapper 框架，咱们须要添加这样的依赖到咱们的项目:

<dependency>
    <groupId>com.googlecode.jmapper-framework</groupId>
    <artifactId>jmapper-core</artifactId>
    <version>1.6.0.1</version>
</dependency>
复制代码

3.测试模型

为了可以正确地测试映射，咱们须要有一个源和目标模型。咱们已经建立了两个测试模型。

第一个是一个只有一个字符串字段的简单 POJO，它容许咱们在更简单的状况下比较框架，并检查若是咱们使用更复杂的 bean 是否会发生任何变化。

简单的源模型以下:

public class SourceCode {
    String code;
    // getter and setter
}
复制代码

它的目标也很类似:

public class DestinationCode {
    String code;
    // getter and setter
}复制代码

源 bean 的实际示例以下:

public class SourceOrder {
    private String orderFinishDate;
    private PaymentType paymentType;
    private Discount discount;
    private DeliveryData deliveryData;
    private User orderingUser;
    private List<Product> orderedProducts;
    private Shop offeringShop;
    private int orderId;
    private OrderStatus status;
    private LocalDate orderDate;
    // standard getters and setters
}复制代码

目标类以下图所示:

public class Order {
    private User orderingUser;
    private List<Product> orderedProducts;
    private OrderStatus orderStatus;
    private LocalDate orderDate;
    private LocalDate orderFinishDate;
    private PaymentType paymentType;
    private Discount discount;
    private int shopId;
    private DeliveryData deliveryData;
    private Shop offeringShop;
    // standard getters and setters
}复制代码

整个模型结构能够在这里找到:https://github.com/eugenp/tutorials/tree/master/performance-tests/src/main/java/com/baeldung/performancetests/model/source。

4. 转换器

为了简化测试设置的设计，咱们建立了以下所示的转换器接口:

public interface Converter {
    Order convert(SourceOrder sourceOrder);
    DestinationCode convert(SourceCode sourceCode);
}复制代码

咱们全部的自定义映射器都将实现这个接口。

4.1. OrikaConverter

Orika 支持完整的 API 实现，这大大简化了 mapper 的建立:

public class OrikaConverter implements Converter{
    private MapperFacade mapperFacade;

    public OrikaConverter() {
        MapperFactory mapperFactory = new DefaultMapperFactory
          .Builder().build();

        mapperFactory.classMap(Order.class, SourceOrder.class)
          .field("orderStatus", "status").byDefault().register();
        mapperFacade = mapperFactory.getMapperFacade();
    }

    @Override
    public Order convert(SourceOrder sourceOrder) {
        return mapperFacade.map(sourceOrder, Order.class);
    }

    @Override
    public DestinationCode convert(SourceCode sourceCode) {
        return mapperFacade.map(sourceCode, DestinationCode.class);
    }
}复制代码

4.2. DozerConverter

Dozer 须要 XML 映射文件，有如下几个部分:

<mappings xmlns="http://dozer.sourceforge.net"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://dozer.sourceforge.net
  http://dozer.sourceforge.net/schema/beanmapping.xsd">

    <mapping>
        <class-a>com.baeldung.performancetests.model.source.SourceOrder</class-a>
        <class-b>com.baeldung.performancetests.model.destination.Order</class-b>
        <field>
            <a>status</a>
            <b>orderStatus</b>
        </field>
    </mapping>
    <mapping>
        <class-a>com.baeldung.performancetests.model.source.SourceCode</class-a>
        <class-b>com.baeldung.performancetests.model.destination.DestinationCode</class-b>
    </mapping>
</mappings>复制代码

定义了 XML 映射后，咱们能够从代码中使用它:

public class DozerConverter implements Converter {
    private final Mapper mapper;

    public DozerConverter() {
        DozerBeanMapper mapper = new DozerBeanMapper();
        mapper.addMapping(
          DozerConverter.class.getResourceAsStream("/dozer-mapping.xml"));
        this.mapper = mapper;
    }

    @Override
    public Order convert(SourceOrder sourceOrder) {
        return mapper.map(sourceOrder,Order.class);
    }

    @Override
    public DestinationCode convert(SourceCode sourceCode) {
        return mapper.map(sourceCode, DestinationCode.class);
    }
}复制代码

4.3. MapStructConverter

Map 结构的定义很是简单，由于它彻底基于代码生成:

@Mapper
public interface MapStructConverter extends Converter {
    MapStructConverter MAPPER = Mappers.getMapper(MapStructConverter.class);

    @Mapping(source = "status", target = "orderStatus")
    @Override
    Order convert(SourceOrder sourceOrder);

    @Override
    DestinationCode convert(SourceCode sourceCode);
}复制代码

4.4. JMapperConverter

JMapperConverter 须要作更多的工做。接口实现后:

public class JMapperConverter implements Converter {
    JMapper realLifeMapper;
    JMapper simpleMapper;

    public JMapperConverter() {
        JMapperAPI api = new JMapperAPI()
          .add(JMapperAPI.mappedClass(Order.class));
        realLifeMapper = new JMapper(Order.class, SourceOrder.class, api);
        JMapperAPI simpleApi = new JMapperAPI()
          .add(JMapperAPI.mappedClass(DestinationCode.class));
        simpleMapper = new JMapper(
          DestinationCode.class, SourceCode.class, simpleApi);
    }

    @Override
    public Order convert(SourceOrder sourceOrder) {
        return (Order) realLifeMapper.getDestination(sourceOrder);
    }

    @Override
    public DestinationCode convert(SourceCode sourceCode) {
        return (DestinationCode) simpleMapper.getDestination(sourceCode);
    }
}复制代码

咱们还须要向目标类的每一个字段添加@JMap注释。此外，JMapper 不能在 enum 类型之间转换，它须要咱们建立自定义映射函数:

@JMapConversion(from = "paymentType", to = "paymentType")
public PaymentType conversion(com.baeldung.performancetests.model.source.PaymentType type) {
    PaymentType paymentType = null;
    switch(type) {
        case CARD:
            paymentType = PaymentType.CARD;
            break;

        case CASH:
            paymentType = PaymentType.CASH;
            break;

        case TRANSFER:
            paymentType = PaymentType.TRANSFER;
            break;
    }
    return paymentType;
}复制代码

4.5. ModelMapperConverter

ModelMapperConverter 只须要提供咱们想要映射的类:

public class ModelMapperConverter implements Converter {
    private ModelMapper modelMapper;

    public ModelMapperConverter() {
        modelMapper = new ModelMapper();
    }

    @Override
    public Order convert(SourceOrder sourceOrder) {
       return modelMapper.map(sourceOrder, Order.class);
    }

    @Override
    public DestinationCode convert(SourceCode sourceCode) {
        return modelMapper.map(sourceCode, DestinationCode.class);
    }
}
复制代码

5. 简单的模型测试

对于性能测试，咱们可使用 Java Microbenchmark Harness，关于如何使用它的更多信息能够在这篇文章：https://www.baeldung.com/java-microbenchmark-harness 中找到。

咱们为每一个转换器建立了一个单独的基准测试，并将基准测试模式指定为 Mode.All。

5.1. 平均时间

对于平均运行时间，JMH 返回如下结果(越少越好):

这个基准测试清楚地代表，MapStruct 和 JMapper 都有最佳的平均工做时间。

5.2. 吞吐量

在这种模式下，基准测试返回每秒的操做数。咱们收到如下结果(越多越好):

在吞吐量模式中，MapStruct 是测试框架中最快的，JMapper 紧随其后。

5.3. SingleShotTime

这种模式容许测量单个操做从开始到结束的时间。基准给出了如下结果(越少越好):

这里，咱们看到 JMapper 返回的结果比 MapStruct 好得多。

5.4. 采样时间

这种模式容许对每一个操做的时间进行采样。三个不一样百分位数的结果以下:

全部的基准测试都代表，根据场景的不一样，MapStruct 和 JMapper 都是不错的选择，尽管 MapStruct 对 SingleShotTime 给出的结果要差得多。

6. 真实模型测试