java bean 转bean_如何用Bull转换任意类型的Java Bean

Bull(Bean Utils Light Library)是一个将数据从一个对象递归地复制到另一个对象的Java-bean到Javabean转换器。它是通用的，灵活的，可重用的，可配置的，而且非常快。

它是唯一能够在没有任何自定义配置的情况下转换可变、不可变和混合bean的库。

本文介绍了如何使用它，并给出了每个可用特性的具体示例。

1.依赖性

com.hotels.beans

bull-bean-transformer

1.7.1

该项目提供两个不同的构建。，与jdk 8(或以上)jdk 11或者更高。

库的最新版本可以从自述档案或来自变化量g(万一你需要一个jdk 8-兼容版本请参阅Changelog-JDK 8).

2.特征

本文中解释的宏特性如下：

bean变换

bean验证

3.bean变换

bean转换由Transformer对象，该对象可以执行以下指令获得：

BeanTransformer transformer = new BeanUtils().getTransformer();

一旦我们有了BeanTransformer对象实例，我们可以使用该方法transform把我们的对象复制到另一个。

使用的方法是：K transform(T sourceObj, Class targetObject);其中，第一个参数表示原对象，第二个参数表示目标类。

例如，给定源和目标类：

public class FromBean { public class ToBean {

private final String name; public BigInteger id;

private final BigInteger id; private final String name;

private final List subBeanList; private final List list;

private List list; private final List nestedObjectList;

private final FromSubBean subObject; private ImmutableToSubFoo nestedObject;

// all args constructor // constructors

// getters and setters... // getters and setters

} }

转换可以通过以下代码行获得：

ToBean toBean = new BeanUtils().getTransformer().transform(fromBean, ToBean.class);

请注意，字段顺序与此无关。

不同字段名副本

给定两个字段数相同但名称不同的类：

private final String name; private final String differentName;

private final int id; private final int id;

private final List subBeanList; private final List subBeanList;

private final List list; private final List list;

private final FromSubBean subObject; private final ToSubBean subObject;

// all constructors // all args constructor

// getters... // getters...

} }

我们需要定义适当的字段映射并将其传递给Transformer目的：

// the first parameter is the field name in the source object

// the second one is the the field name in the destination one

FieldMapping fieldMapping = new FieldMapping("name", "differentName");

Tansformer transformer = new BeanUtils().getTransformer().withFieldMapping(fieldMapping);

然后，我们可以执行转换：

ToBean toBean = transformer.transform(fromBean, ToBean.class);

源对象和目标对象之间的映射字段

案例1：必须从源对象中的嵌套类中检索目标字段值

假设对象FromSubBean声明如下：

public class FromSubBean {

private String serialNumber;

private Date creationDate;

// getters and setters...

}

我们的源类和目标类描述如下：

private final String name; private final String name;

private final FromSubBean subObject; private final String serialNumber;

private final Date creationDate;

/ all args constructor // all args constructor

// getters... // getters...

.而字段的值serialNumber和creationDate进入ToBean对象需要从subObject，可以定义分隔的属性点的整个路径：

FieldMapping serialNumberMapping = new FieldMapping("subObject.serialNumber", "serialNumber");

FieldMapping creationDateMapping = new FieldMapping("subObject.creationDate", "creationDate");

ToBean toBean = new BeanUtils().getTransformer()

.withFieldMapping(serialNumberMapping, creationDateMapping)

.transform(fromBean, ToBean.class);

案例2：必须从源类根检索目标字段值(在嵌套类中)

前面的示例突出显示了如何从源对象中获取值；而这个示例则解释了如何将值放入嵌套对象中。

给予：

public class FromBean { public class ToBean {

private final String name; private final String name;

private final FromSubBean nestedObject; private final ToSubBean nestedObject;

private final int x;

// all args constructor // all args constructor

// getters... // getters...

} }

以及：

public class ToSubBean {

private final int x;

// all args constructor

} // getters...

假设x应该映射到字段：x载于ToSubBean对象，必须将字段映射定义为：

FieldMapping fieldMapping = new FieldMapping("x", "nestedObject.x");

然后，我们只需要把它传递给Transformer并执行转换：

ToBean toBean = new BeanUtils().getTransformer()

.withFieldMapping(fieldMapping)

.transform(fromBean, ToBean.class);

定义构造器args的不同字段名

还可以通过添加@ConstructorArg构造函数参数旁边的注释。

这个@ConstructorArg接受源对象中对应字段的名称作为输入。

public class FromBean { public class ToBean {

private final String name; private final String differentName;

private final int id; private final int id;

private final List subBeanList; private final List subBeanList;

private final List list; private final List list;

private final FromSubBean subObject; private final ToSubBean subObject;

// all args constructor

// getters...

public ToBean(@ConstructorArg("name") final String differentName,

@ConstructorArg("id") final int id,

} @ConstructorArg("subBeanList") final List subBeanList,

@ConstructorArg(fieldName ="list") final List list,

@ConstructorArg("subObject") final ToSubBean subObject) {

this.differentName = differentName;

this.id = id;

this.subBeanList = subBeanList;

this.list = list;

this.subObject = subObject;

}

// getters...

}

然后：

ToBean toBean = beanUtils.getTransformer().transform(fromBean, ToBean.class);

对特定字段Lambda函数应用自定义转换

我们知道，在现实生活中，很少需要在两个Javabean之间复制几乎相同的信息，经常会发生这样的情况：

目标对象的结构与源对象完全不同。

在复制特定字段值之前，我们需要对它执行一些操作。

必须验证目标对象的字段

目标对象有一个比源对象更多的字段，需要填充来自不同源的内容。

公牛给出了在特定领域执行任何一种操作的可能性，实际上是利用了Lambda表达式，开发人员可以定义自己的方法，在复制a值之前应用该方法。

让我们用一个例子更好地解释它：

鉴于以下情况Source班级：

public class FromFoo {

private final String id;

private final String val;

private final List nestedObjectList;

// all args constructor

// getters

}

以及以下内容Destination班级：

public class MixedToFoo {

public String id;

@NotNull

private final Double val;

// constructors

// getters and setters

}

假设val在我们的变压器中，场需要乘以一个随机值，我们有两个问题：

这个val字段的类型与Source对象，确实是String一个是Double

我们需要指导图书馆如何应用数学运算。

这很简单，您只需定义自己的lambda表达式即可：

FieldTransformer valTransformer =

new FieldTransformer<>("val",

n -> Double.valueOf(n) * Math.random());

表达式将应用于具有名称的字段。val在目标对象中。

最后一步是将函数传递给Transformer例如：

MixedToFoo mixedToFoo = new BeanUtils().getTransformer()

.withFieldTransformer(valTransformer)

.transform(fromFoo, MixedToFoo.class);

在源对象中缺少字段的情况下指定默认值

有时，在目标对象比源对象具有更多字段的情况下会发生这种情况；在本例中，BeanUtils库将引发异常，通知它它们无法执行映射，因为它们不知道必须从何处检索值。

典型的情况如下：

public class FromBean { public class ToBean {

private final String name; @NotNull

private final BigInteger id; public BigInteger id;

private final String name;

private String notExistingField; // this will be null and no exceptions will be raised

// constructors... // constructors...

// getters... // getters and setters...

} }

但是，我们可以将库配置为为字段类型分配默认值(如：0为int类型，null为String等等)

ToBean toBean = new BeanUtils().getTransformer()

.setDefaultValueForMissingField(true)

.transform(fromBean, ToBean.class);

在源对象中缺少字段的情况下应用转换函数

下面的示例演示如何在源对象中不存在的字段上分配默认值(或lambda函数的结果)：

public class FromBean { public class ToBean {

private final String name; @NotNull

private final BigInteger id; public BigInteger id;

private final String name;

private String notExistingField; // this will have value: sampleVal

// all args constructor // constructors...

// getters... // getters and setters...

} }

我们需要做的是分配一个FieldTransformer函数到特定字段：

FieldTransformer notExistingFieldTransformer =

new FieldTransformer<>("notExistingField", () -> "sampleVal");

上述函数将为该字段指定一个固定值。notExistingField，但是我们可以返回任何内容，例如，我们可以调用一个外部方法，该方法返回一组操作后获得的值，如下所示：

FieldTransformer notExistingFieldTransformer =

new FieldTransformer<>("notExistingField", () -> calculateValue());

但是，最后，我们只需要将它传递给Transformer.

ToBean toBean = new BeanUtils().getTransformer()

.withFieldTransformer(notExistingFieldTransformer)

.transform(fromBean, ToBean.class);

将转换函数应用于嵌套对象中的特定字段

案例1：应用于嵌套类中特定字段的Lambda转换函数

给予：

public class FromBean { public class ToBean {

private final String name; private final String name;

private final FromSubBean nestedObject; private final ToSubBean nestedObject;

// all args constructor // all args constructor

// getters... // getters...

} }

以及：

public class FromSubBean { public class ToSubBean {

private final String name; private final String name;

private final long index; private final long index;

// all args constructor // all args constructor

// getters... // getters...

} }

假设lambda转换函数只应用于字段name载于ToSubBean对象时，必须将转换函数定义为：

FieldTransformer nameTransformer = new FieldTransformer<>("nestedObject.name", StringUtils::capitalize);

然后，将函数传递给Transformer目的：

ToBean toBean = new BeanUtils().getTransformer()

.withFieldTransformer(nameTransformer)

.transform(fromBean, ToBean.class);

案例2：应用于特定字段的Lambda转换函数与其位置无关

想象一下在我们Destination类中，有更多相同名称的字段出现在不同的类中，并且我们希望对所有这些类应用相同的转换函数；有一个允许这样做的设置。

以上面的对象为例，并假设我们希望利用name字段独立于它们的位置，我们可以这样做：

FieldTransformer nameTransformer = new FieldTransformer<>("name", StringUtils::capitalize);

然后：

ToBean toBean = beanUtils.getTransformer()

.setFlatFieldTransformation(true)

.withFieldTransformer(nameTransformer)

.transform(fromBean, ToBean.class);

静态变压器功能：

BeanUtils 提供了转换器方法的“静态”版本，当需要在复合lambda表达式中应用时，它可以是一个附加值。

例如：

List fromFooSimpleList = Arrays.asList(fromFooSimple, fromFooSimple);

这一转变应该由以下几个方面来完成：

BeanTransformer transformer = new BeanUtils().getTransformer();

List actual = fromFooSimpleList.stream()

.map(fromFoo -> transformer.transform(fromFoo, ImmutableToFooSimple.class))

.collect(Collectors.toList());

由于这个特性，可以为特定的对象类创建特定的转换器函数：

Function transformerFunction = BeanUtils.getTransformer(ImmutableToFooSimple.class);

然后，可以将列表转换为：

List actual = fromFooSimpleList.stream()

.map(transformerFunction)

.collect(Collectors.toList());

但是，可能发生的情况是，我们已经配置了一个BeanTransformer具有多个字段、映射和转换函数的实例，我们也希望在此转换中使用它，因此我们需要做的是从我们的转换器创建转换器函数：

BeanTransformer transformer = new BeanUtils().getTransformer()

.withFieldMapping(new FieldMapping("a", "b"))

.withFieldMapping(new FieldMapping("c", "d"))

.withTransformerFunction(new FieldTransformer<>("locale", Locale::forLanguageTag));

Function transformerFunction = BeanUtils.getTransformer(transformer, ImmutableToFooSimple.class);

List actual = fromFooSimpleList.stream()

.map(transformerFunction)

.collect(Collectors.toList());

启用Java Bean验证

库提供的特性之一是bean验证。它包括检查转换后的对象是否满足在其上定义的约束。验证在两种默认情况下都有效。javax.constraints还有定制的。

假设字段id在FromBean实例是null.

public class FromBean { public class ToBean {

private final String name; @NotNull

private final BigInteger id; public BigInteger id;

private final String name;

// all args constructor // all args constructor

// getters... // getters and setters...

} }

添加以下配置后，将在转换过程结束时执行验证，在我们的示例中，将抛出一个异常，通知对象无效：

ToBean toBean = new BeanUtils().getTransformer()

.setValidationEnabled(true)

.transform(fromBean, ToBean.class);

在现有实例上复制

即使库能够创建给定类的新实例，并用给定对象中的值填充它，也可能需要在已有实例上注入值，因此给出以下Java bean：

public class FromBean { public class ToBean {

private final String name; private String name;

private final FromSubBean nestedObject; private ToSubBean nestedObject;

// all args constructor // constructor

// getters... // getters and setters...

} }

如果我们需要对已经存在的对象执行副本，则只需将类实例传递给transform职能：

ToBean toBean = new ToBean();

new BeanUtils().getTransformer().transform(fromBean, toBean);

给定字段集上的跳跃变换

如果我们将源对象值复制到已经存在的实例中(某些值已经设置)，则可能需要避免转换操作覆盖现有值。下面的示例说明了如何做到这一点：

public class FromBean { public class ToBean {

private final String name; private String name;

private final FromSubBean nestedObject; private ToSubBean nestedObject;

// all args constructor // constructor

// getters... // getters and setters...

} }

public class FromBean2 {

private final int index;

private final FromSubBean nestedObject;

// all args constructor

// getters...

}

如果我们需要跳过一组字段的转换，只需将它们的名称传递给skipTransformationForField方法。例如，如果我们想跳过字段上的转换nestedObject，这就是我们需要做的：

ToBean toBean = new ToBean();

new BeanUtils().getTransformer()

.skipTransformationForField("nestedObject")

.transform(fromBean, toBean);

此功能允许转换保存来自不同源的数据的对象.

为了更好地解释这个函数，让我们假设ToBean(上文定义)应改为：

name字段值已从FromBean对象

nestedObject字段值已从FromBean2对象

可以通过这样做来实现目标：

// create the destination object

ToBean toBean = new ToBean();

// execute the first transformation skipping the copy of: 'nestedObject' field that should come from the other source object

new BeanUtils().getTransformer()

.skipTransformationForField("nestedObject")

.transform(fromBean, toBean);

// then execute the transformation skipping the copy of: 'name' field that should come from the other source object

new BeanUtils().getTransformer()

.skipTransformationForField("name")

.transform(fromBean2, toBean);

字段类型转换

在字段类型与源类和目标不同的情况下，我们有以下示例：

public class FromBean {

public class ToBean {

private final String index;

private int index;

// all args constructor

// constructor

// getters...

// getters and setters...

}

}

它可以使用特定的转换函数进行转换：

FieldTransformer indexTransformer = new FieldTransformer<>("index", Integer::parseInt);

ToBean toBean = new BeanUtils()

.withFieldTransformer(indexTransformer)

.transform(fromBean, ToBean.class);

用Builder模式实现Java Bean的转换

库使用不同类型的Builder模式支持JavaBean的转换：标准模式(默认支持)和自定义模式。让我们详细了解它们，以及如何启用自定义Builder类型转换。

让我们从标准一默认支持：

public class ToBean {

private final Class> objectClass;

private final Class> genericClass;

ToBean(final Class> objectClass, final Class> genericClass) {

this.objectClass = objectClass;

this.genericClass = genericClass;

}

public static ToBeanBuilder builder() {

return new ToBean.ToBeanBuilder();

}

// getter methods

public static class ToBeanBuilder {

private Class> objectClass;

private Class> genericClass;

ToBeanBuilder() {

}

public ToBeanBuilder objectClass(final Class> objectClass) {

this.objectClass = objectClass;

return this;

}

public ToBeanBuilder genericClass(final Class> genericClass) {

this.genericClass = genericClass;

return this;

}

public com.hotels.transformer.model.ToBean build() {

return new ToBean(this.objectClass, this.genericClass);

}

}

}

如前所述，这不需要额外的设置，因此可以通过执行以下操作来执行转换：

ToBean toBean = new BeanTransformer()

.transform(sourceObject, ToBean.class);

自定义生成器模式：

public class ToBean {

private final Class> objectClass;

private final Class> genericClass;

ToBean(final ToBeanBuilder builder) {

this.objectClass = builder.objectClass;

this.genericClass = builder.genericClass;

}

public static ToBeanBuilder builder() {

return new ToBean.ToBeanBuilder();

}

// getter methods

public static class ToBeanBuilder {

private Class> objectClass;

private Class> genericClass;

ToBeanBuilder() {

}

public ToBeanBuilder objectClass(final Class> objectClass) {

this.objectClass = objectClass;

return this;

}

public ToBeanBuilder genericClass(final Class> genericClass) {

this.genericClass = genericClass;

return this;

}

public com.hotels.transformer.model.ToBean build() {

return new ToBean(this);

}

}

}

要转换上面的Bean，要使用的指令是：

ToBean toBean = new BeanTransformer()

.setCustomBuilderTransformationEnabled(true)

.transform(sourceObject, ToBean.class);

4.bean验证

对一组规则的类验证是非常宝贵的，特别是当我们需要确保对象数据符合我们的期望时。

“字段验证”方面是Bull提供的特性之一，它是完全自动的--您只需要用一个现有的javax.validation.约束(或定义一个自定义的约束)对您的字段进行注释，然后对其执行验证。

给定以下bean：

public class SampleBean {

@NotNull

private BigInteger id;

private String name;

// constructor

// getters and setters...

}

上述对象的实例：

SampleBean sampleBean = new SampleBean();

和一行代码，例如：

new BeanUtils().getValidator().validate(sampleBean);

这将抛出一个InvalidBeanException，作为田野id是null.

结语

我试着用例子来解释如何使用Bull项目提供的主要功能。然而，查看完整的源代码可能更有帮助。

可以找到更多的示例，查看在Bull项目上实现的测试用例。这里.

GitHub还包含一个示例弹簧靴项目，该项目使用库在不同层之间转换请求/响应对象，可以找到这里.

为感谢您对我们的认可，特意准备了一些IT入门和进阶的干货

包括：Java、UI设计、H5前端、Python+人工智能、软件测试和新媒体运营六大学科视频资料。以及IT就业大礼包。

线上视频、音频，随时学习观看

关注我们并私信“资料”即可获取。