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

时间  2019-11-17
标签 常见 bean 映射 工具 性能 比对 栏目 系统性能 繁體版
原文   原文链接

本文由 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 返回如下结果(越少越好):

AverageTime

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

5.2. 吞吐量

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

Throughput

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

5.3. SingleShotTime

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

SingleShotTime

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

5.4. 采样时间

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

SampleTime

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

6. 真实模型测试

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

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

6.1. 平均时间

JMH 返回如下平均运行时间结果（越少越好）：

平均时间

该基准清楚地代表，MapStruct 和 JMapper 均具备最佳的平均工做时间。

6.2. 吞吐量

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

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

6.3. SingleShotTime

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

6.4. 采样时间

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

SampleTime

尽管简单示例和实际示例的确切结果明显不一样，可是它们的趋势相同。在哪一种算法最快和哪一种算法最慢方面，两个示例都给出了类似的结果。

6.5. 结论

根据咱们在本节中执行的真实模型测试，咱们能够看出，最佳性能显然属于 MapStruct。在相同的测试中，咱们看到 Dozer 始终位于结果表的底部。

7. 总结

在这篇文章中，咱们已经进行了五个流行的 Java Bean 映射框架性能测试：ModelMapper ， MapStruct ， Orika ，Dozer， JMapper。

示例代码地址：https://github.com/eugenp/tutorials/tree/master/performance-tests。

开源项目推荐

做者的其余开源项目推荐：

  1. JavaGuide：【Java学习+面试指南】 一份涵盖大部分Java程序员所须要掌握的核心知识。
  2. springboot-guide : 适合新手入门以及有经验的开发人员查阅的 Spring Boot 教程（业余时间维护中，欢迎一块儿维护）。
  3. programmer-advancement : 我以为技术人员应该有的一些好习惯！
  4. spring-security-jwt-guide :从零入门 ！Spring Security With JWT（含权限验证）后端部分代码。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程