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

时间 2019-11-15

原文原文链接

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

1. 介绍

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

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

2. 常见 Bean 映射框架概览

2.1. Dozer

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

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

<dependency>
    <groupId>net.sf.dozer</groupId>
    <artifactId>dozer</artifactId>
    <version>5.5.1</version>
</dependency>

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

2.2. Orika

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

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

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

<dependency>
    <groupId>ma.glasnost.orika</groupId>
    <artifactId>orika-core</artifactId>
    <version>1.5.2</version>
</dependency>

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

2.3. MapStruct

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

要使用 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/maps...。

要使用 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-fr...。

要使用 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/tut...。

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... 中找到。

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

5.1. 平均时间

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

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

5.2. 吞吐量

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

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

5.3. SingleShotTime

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

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

5.4. 采样时间

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

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

6. 真实模型测试