关于spring:帮助-Java-开发人员进行-Bean-映射的-8-大框架

作为一名老手 Java 程序员，您可能想晓得如何构建一个大型应用程序，而无需应用大量可能使您精疲力竭的相似代码。

在 Java 上构建 蕴含多个层的大型应用程序须要域、持久性和数据传输对象 (DTO) 等模型。应用程序通常由不同但类似的对象模型组成，其中数据可能类似但构造和指标不同。在执行大型应用程序时转换不同类型的数据或对象以用于业务决策或数据暗藏至关重要。

应用对象映射，能够更轻松地将一个模型转换为另一个模型，同时隔离独自的模型。

只管将一个对象映射到另一个对象是很常见的，但因为这两个类具备类似或雷同的映射属性，它通常可能是迭代且乏味的。侥幸的是，有几个 Java 映射框架能够用来递归地将数据从一个对象复制到另一个对象。

但在持续探讨映射 框架之前，让咱们先理解一下 Java 映射的基础知识。

什么是 JavaBean？

JavaBean 是将不同对象封装到一个对象或 bean 中的 Java 类。Bean 应该是可序列化的（行将对象状态转换为字节流），应该有一个公共的无参数构造函数，并且属性必须是公有的，具备公共的 getter 和 setter 办法。

让咱们看一个显示 JavaBean 类的构造的示例。

1. 打包 我的包；
2. 公共 类 学生 实现 java.io.Serializable{
3. 私人 int id；
4. 公有 字符串名称；
5. 公共 学生（）{}
6. public void setId(int id){this .id=id;}
7. public int getId(){返回 id;}
8. public void setName(String name){this .name=name;}
9. 公共 字符串 getName(){ 返回 名称；}
10. }

当初拜访 JavaBean，getter 和 setter 办法应用如下：

1. 打包 我的包；
2. 公共 类 测试{
3. 公共 动态 有效 次要（字符串参数[]）{
4. 学生 s=新 学生（）；// 对象被创立
5. s.setName(“安娜”); // 设置对象的值
6. System.out.println(e.getName());
7. }}

只管 JavaBeans 能够裸露给其余应用程序以重用软件组件，但 JavaBeans 是可变的（即能够在创立后更改），因而它们无奈从不可变对象（如 Java 中的字符串在创立后无奈更改）中受害。当你想要封装（暗藏）数据时，它须要一个 get 办法来返回它的值，并须要一个 set 办法来设置或更新它的值。然而，为每个属性创立 getter 和 setter 办法可能会导致在多个区域反复代码，简直没有变动，也称为样板。

这就是 bean 映射框架在 我的项目开发中发挥作用的中央。

什么是 Bean 映射框架？

有时，因为非结构化、宽泛的指标和非线性工作流程使应用程序更加简单，构建企业级我的项目可能会很艰难。此外，实现内部零碎遗留组件的某些性能须要将具备类似构造的对象，如对域对象的内部服务响应和域对象转换为难以手动获取的内部服务申请。

让咱们看看事实世界的场景，这些申请和响应对象可能蕴含许多列。应用手动代码将一个 bean/ 对象复制到另一个将须要大量代码行，例如 destination.setABC(source.getABC())，它是递归且容易出错的。

如果您想克服编写相似代码行以将数据从一个 bean 复制到另一个的复杂性和重复性，那么 bean 映射框架十分有用，因为它提供了简略的配置和更少的代码行来简化您的工作。

Java 中用于映射的顶级框架

当初您曾经晓得 Java 中的 JavaBean 和 Bean 映射框架是什么以及为什么首先应用它们。当初是学习顶级 Java Bean 映射 框架的时候 了，您能够在解决下一个我的项目时应用这些框架进行映射。

dOOv

Domain Object Oriented Validation (dOOv) 是一种用于域模型验证和映射的 API。dOOv 应用代码生成、正文和类型平安的畛域特定语言 (DSL) 来使映射和验证更容易、更疾速。为您节省时间和精力。

dOOV 由 dOOv 外围、dOOv 生成器和 dOOv 断言组成，其中外围蕴含形象语法树 (AST)、DST 和正文，生成器由用于字段信息和模型映射的代码生成器组成，断言包含 AssertJ 断言。

对于以下无关举荐框架的局部，我将提供框架的概述阐明，而后编写代码段供您在筹备好时开始应用。

• 标注域模型

公共类用户{@TestPath(field = TestFieldId.FIRST_NAME, readable = "user first name") 
    private String firstName;

    @TestPath(field = TestFieldId.LAST_NAME, readable = "user last name") 
    private String lastName;

    @TestPath(field = TestFieldId.DATEOFDATE, 可读 = "用户出生日期") 
    private LocalDatebirthDate;

}

• 应用 userFirstName、userLastName 和 userDateIOfBirth 等元素生成 DSL 代码
• 编写和执行验证规定

ValidationRule 规定 = DOOV.when(userDateOfBirth.ageAt(today()).greaterOrEquals(18)).validate();

您必须在实例化模型中编写代码来执行它，其中实例化模型是实在实例的创立或形象的特定实现，例如对象类。

// 在模型上执行 DSL 
DslModel model = new SampleModelWrapper(sampleModel); 
后果 result = rule.executeOn(model); 
if (result.isFalse()) {// 在模型上做一些没有验证的事件}

• 地图

要应用 dOOv 将对象与其余对象映射，您将编写代码为：

MappingRegistry 映射 = 映射（映射（userFirstName，userLastName）.using(biConverter((first, last) -> first + "" + last)) 
    .to(accountFullName), 
  map(userDateOfBirth) 
    .using(date -> Years.yearsBetween (日期, LocalDate.now())) 
    .to(accountAge));

而后能够应用两个实例化模型来执行映射代码。

DslModel model1 = new SampleModelWrapper(sampleModel1);
DslModel model2 = new SampleModelWrapper(sampleModel2);
上下文上下文 = mappings.executeOn(model1, model2);
// 应用 model2 的新值做一些事件

• 测试验证规定

断言在 doov-assertions jar 中可用。因为 AssertJ 是必须的，因而您能够应用 assertThat 语法。

ValidationRule 规定 = DOOV.when(userFirstName.isNotNull().or(userLastName.isNull())).validate();

assertThat(rule).validates(model).hasFailedNodeEmpty();

映射器

JMapper 是 基于 Javassist 的 Java 映射框架，它应用字节码操作进行疾速映射。JMapper 以零内存耗费提供动静转换、关系映射和动态代码性能的劣势。它承受两个类的输出，Destination（将创立或批改的实例）和 Source（蕴含数据的实例）。所以在映射之前，须要在 Source 和 Destination 之间配置一个类，而后调用 Get 办法。

注解

类目的地{

  @JMap
  字符串标识；@JMap("SourceField")
  字符串指标字段；其余字符串；// getter 和 setter 
 }

类源{
   字符串 ID；字符串源字段；其余字符串；// getter 和 setter 
 }

要调用 GetDestination 办法，您将创立和应用 XML 文件，如下所示：

<jmapper> 
  <class name="it.jmapper.bean.Destination"> 
    <attribute name="id"> 
      <value name="id"/> 
    </attribute> 
    <attribute name="destinationField"> 
      <value name= "SourceField"> 
    </attribute> 
  </class> 
</jmapper>

为了执行，您将创立如下 API：

JMapperAPI jmapperAPI = new JMapperAPI() 
    .add(mappedClass(Destination.class) 
             .add(attribute("id") 
                     .value("id")) 
             .add(attribute("destinationField") 
                     .value("SourceField")) );

地图构造

MapStruct 是用于高性能和类型平安的 JavaBeans 类映射器的最罕用的 Java 正文处理器之一。它带有内置的转换和正当的默认值，在实现或配置特定行为时不会打搅您。

MapStruct 通过尽可能地自动化来简化映射。它生成 bean 映射编译工夫以确保高性能、彻底的谬误检查和疾速反馈。

MapStruct 是一个注解处理器，插入到 Java 编译器中，可用于您首选的集成开发环境 (IDE) 或 Gradle 和 Maven 等命令行构建。

要应用 MapStruct，您须要定义映射器接口，申明所有必须的映射办法。

假如您有两个类，一个代表汽车，另一个代表数据传输对象 (DTO)，如下所示：

• 汽车.java

公共类汽车{

    私人字符串制作；私人 int numberOfSeats; 
    公有 CarType 类型；// 构造函数、getter、setter 等
}

• CarDTO.java

公共类 CarDto {

    私人字符串制作；私人 int 座位数；公有字符串类型；// 构造函数、getter、setter 等
}

这两个类简直雷同，只是座位数的属性具备不同的名称，并且 Car 类中的枚举类型属性是 DTO 中的纯字符串。

要为 carDTO 创立映射器，映射器接口将定义为：

@Mapper
公共接口 TestMapper {TestMapper INSTANCE = Mappers.getMapper(TestMapper.class);

    @Mapping(target = "seatCount", source = "numberOfSeats") 
    TestDto testToTestDto(Test test); 
}

应用您为映射器创立的接口，能够以类型平安的形式轻松实现对象映射，如下所示：

@Test 
public void shouldMapCarToDto() { 
    // 给定
    汽车 car = new Car("Morris", 5, CarType.SEDAN);

    // 当
    CarDto carDto = CarMapper.INSTANCE.carToCarDto(car);

    // 而后
    assertThat(carDto).isNotNull(); 
    assertThat(carDto.getMake() ).isEqualTo("Morris"); 
    assertThat(carDto.getSeatCount() ).isEqualTo(5); 
    assertThat(carDto.getType() ).isEqualTo("轿车"); 
}

模型映射器

ModelMapper 是一个智能映射库，可能主动映射对象。它提供了一个简略的重构平安 API，并应用传统的办法来解决某些用例。

ModelMapper 是一个很棒的 Java Bean Mapper，因为它通过主动确定一个对象如何通过约定映射到另一个对象，从而使对象映射更容易，因而您不用放心手动映射。

您能够在 Maven 中设置 ModelMapper，如下所示：

<dependency> 
  <groupId>org.modelmapper</groupId> 
  <artifactId>modelmapper</artifactId> 
  <version>3.0.0</version> 
</dependency>

要应用 ModelMapper 将对象与其余对象映射，您能够将源和指标模型代码创立为：

源代码：

// 假如每个类都有 getter 和 setter 
class Order { 
  Customer customer; 
  地址 billingAddress; 
}

类客户{名称名称；}

类名 {
  字符串名；字符串姓氏；}

类地址{
  字符串街道；串城；}

目的地代码：

// 假如 getter 和 setter
类 OrderDTO { 
  String customerFirstName; 
  字符串客户姓氏；字符串 billingStreet；字符串计费城市；}

要执行 ModelMapper 隐含映射，请应用以下内容：

模型映射器模型映射器 = 新模型映射器（）；OrderDTO orderDTO = modelMapper.map(order, OrderDTO.class);

在调用 map 办法时，将剖析源模型和指标模型代码，以依据 匹配的配置 和策略辨认属性简略性。只有在该数据映射到其余对象之后。

重映射

ReMap 是一个 Java 映射库，可帮忙开发人员一一属性地简化对象转换，同时缩小映射器类的单元测试。

ReMap 能够通过 JCenter 和 Maven Central 轻松拜访。以下是您将如何在利用内映射源和指标类型。

Mapping.from(Customer.class) .to 
    (Person.class) 
    .omitInSource(Customer::getAddress) 
    .omitInDestination(Person::getBodyHeight) 
    .reassign(Customer::getTitle) .to 
        (Person::getSalutation) 
    .replace(Customer::getGender, Person::getGender) 
        .withSkipWhenNull(Gender::valueOf) 
    .mapper();

折花

Orika 是一个 JavaBean 到 Bean 映射框架，它迭代地将数据从一个对象复制到另一个对象。强烈建议在开发多层 Web 应用程序时应用它，因为 Orika 如何为 Java Bean 映射构建无效、全面和强壮的解决方案。

Orika 通过应用字节码生成器以最小的开销使 Java Bean 的映射更快。

要将两个 bean 或对象互相映射，首先要申明指标类和源类，如下所示：

类 BasicPerson {
  公有字符串名称；私人年龄；私人日期出生日期；// getter/setter 省略
} 
class BasicPersonDto { 
  private String fullName; 
  私人 int currentAge；私人日期出生日期；// getter/setter 省略
}

接下来，将这两个类映射为：

  mapperFactory.classMap(BasicPerson.class, BasicPersonDto.class) .field 
("name", "fullName") .field ("age", "currentAge") .register();   
   
   

如果您创立自定义 Mappers、Convertors 和 ObjectFactory 类型，也能够自定义 Orika 映射，其中映射器可用于将对象的属性利用于另一个对象；ObjectFactory 可用于在映射的上下文中结构实例，Converter 齐全管制映射过程。为您的下一个我的项目制作一个高效的 Jave Bean Mapper。

塞尔玛

Stupid Simple Statically Linked Mapper (AKA Selma) 是一个基于注解处理器的 Java bean 到 bean 映射器。它生成 Java 代码来解决字段到字段的映射，还能够作为运行时库来调用生成的映射器。

要查看 Selma 的运行状况，请依照给定的步骤操作：

@Mapper
公共接口 SelmaMapper {

    // 不可变映射
    OutBean asOutBean(InBean source);

    // 更新图
    OutBean updateOutBean(InBean source, OutBean destination);

要应用 Selma 进行映射，咱们将：

  SelmaMapper 映射器 = Selma.mapper(SelmaMapper.class);

    OutBean res = mapper.asOutBean(in);

    // 或者
    OutBean dest = dao.getById(42);

    OutBean res = mapper.updateOutBean(in, dest); 
    // res 是 bean 目的地的值

推土机

Dozer 是一个 Java 映射框架，它应用 APL/XML 配置和正文将数据从一个对象复制到另一个对象。它是一个开源、强壮、灵便、可配置、可重用和通用的映射框架，反对 JavaBean 的简单、简略、隐式、显式、双向和递归映射。如果您想防止在将数据从一个 bean 复制到另一个 bean 时应用不必要的代码，Dozer 是现实的抉择。它不仅反对 bean 的映射，还能够主动转换数据类型以映射类与 DTO。

应用 Maven，您能够简略地通过以下形式在我的项目中增加 Dozer：

< 依赖 >

    <groupId>com.github.dozermapper</groupId>

    <artifactId> 推土机外围 </artifactId>

    < 版本 >6.5.2</ 版本 >

</ 依赖 >

创立源和指标类：

<mapping> 
  <class-a>yourpackage.SourceClassName</class-a> 
  <class-b>yourpackage.DestinationClassName</class-b> 
    <field> 
      <a>yourSourceFieldName</a> 
      <b>yourDestinationFieldName</b> 
    </field> 
</mapping>

并将这些类映射为：

SourceClassName sourceObject = new SourceClassName(); 
sourceObject.setYourSourceFieldName("Dozer");

映射器映射器 = DozerBeanMapperBuilder.buildDefault(); 
DestinationClassName destObject = mapper.map(sourceObject,
DestinationClassName.class); 

assertTrue(destObject.getYourDestinationFieldName().equals(sourceObject.getYourSourceFieldName()));

应用框架使 JavaBeans 映射更容易

在开发为满足大型企业的需要而量身定制的软件或 Web 应用程序时，[Java 映射框架十分重要且至关重要

采纳 Java Mapping 框架将更容易以更快的速度将数据对象从一个 bean 复制到另一个 bean，而且准确度更高，工作量最小。

这些顶级的 Java Mapping 框架，如 MapStruck、reMap、dozer 和 dOOv 将帮忙您在将来取得业余劣势。

要害要点：

• 应用对象映射，能够更轻松地将一个模型转换为另一个模型，同时隔离独自的模型。
• Bean 映射框架十分有用，因为它提供了简略的配置和更少的代码行来简化您的工作。
• dOOv、JMapper、MapStruct、ModelMapper、reMap、Orika、Selma 和 Dozer 等 Java Bean 映射框架可用于映射。
• 要映射两个对象，您须要创立源类和指标类。
  s(sourceObject.getYourSourceFieldName()));

## ** 应用框架使 JavaBeans 映射更容易 **

 在开发为满足大型企业的需要而量身定制的软件或 Web 应用程序时，[Java 映射框架十分重要且至关重要

采纳 Java Mapping 框架将更容易以更快的速度将数据对象从一个 bean 复制到另一个 bean，而且准确度更高，工作量最小。这些顶级的 Java Mapping 框架，如 MapStruck、reMap、dozer 和 dOOv 将帮忙您在将来取得业余劣势。要害要点：- 应用对象映射，能够更轻松地将一个模型转换为另一个模型，同时隔离独自的模型。- Bean 映射框架十分有用，因为它提供了简略的配置和更少的代码行来简化您的工作。- dOOv、JMapper、MapStruct、ModelMapper、reMap、Orika、Selma 和 Dozer 等 Java Bean 映射框架可用于映射。- 要映射两个对象，您须要创立源类和指标类。