详解Dozer对象转换使用方法

Dear 丶 2022-02-23 12:10 1244阅读 0赞

# 1.Dozer作用 #

Dozer是一个实现对象间字段赋值转换的工具包。

它支持简单的属性映射，复杂类型映射，双向映射，隐式显式的映射，以及递归映射。

它支持三种映射方式：注解、API、XML。

它是开源的，遵从[Apache 2.0 协议][Apache 2.0]

常见应用场景：

微服中，有大量实体转换，从前端表单转换为业务实体，从业务实体转换为报表Dto。

# 2.Dozer设计 #

![20190408102554360.png][]

**核心接口Mapper：**

定义了类之间的转换方法map

/**
 * Public root interface for performing Dozer mappings from application code.
 * 
 * @author tierney.matt
 * @author garsombke.franz
 */
 public interface Mapper {
 
 /**
 * Constructs new instance of destinationClass and performs mapping between from source
 *
 * @param source
 * @param destinationClass
 * @param <T>
 * @return
 * @throws MappingException
 */
 <T> T map(Object source, Class<T> destinationClass) throws MappingException;
 
 /**
 * Performs mapping between source and destination objects
 *
 * @param source
 * @param destination
 * @throws MappingException
 */
 void map(Object source, Object destination) throws MappingException;
 
 /**
 * Constructs new instance of destinationClass and performs mapping between from source
 *
 * @param source
 * @param destinationClass
 * @param mapId
 * @param <T>
 * @return
 * @throws MappingException
 */
 <T> T map(Object source, Class<T> destinationClass, String mapId) throws MappingException;
 
 /**
 * Performs mapping between source and destination objects
 *
 * @param source
 * @param destination
 * @param mapId
 * @throws MappingException
 */
 void map(Object source, Object destination, String mapId) throws MappingException;
 
 }

**DozerBeanMapper类：**  
实现了Mapper接口，供外部使用。内部真正的逻辑实现，在MappingProcessor中实现。

通常整个应用中，只需要一个DozerBeanMapper（即单例）。如果不是Spring应用，则可以使用Dozer中封装好的单例类DozerBeanMapperSingletonWrapper。

/**
 * Public Dozer Mapper implementation. This should be used/defined as a singleton within your application. This class
 * performs several one-time initializations and loads the custom xml mappings, so you will not want to create many
 * instances of it for performance reasons. Typically a system will only have one DozerBeanMapper instance per VM. If
 * you are using an IOC framework (i.e Spring), define the Mapper as singleton="true". If you are not using an IOC
 * framework, a DozerBeanMapperSingletonWrapper convenience class has been provided in the Dozer jar.
 * 
 * It is technically possible to have multiple DozerBeanMapper instances initialized, but it will hinder internal
 * performance optimizations such as caching.
 *
 * @author tierney.matt
 * @author garsombke.franz
 * @author dmitry.buzdin
 * @author suwarnaratana.arm
 */
 public class DozerBeanMapper implements Mapper {
 
 …………
 
 }
 
 
 /**
 * Public Singleton wrapper for the DozerBeanMapper. Only supports a single mapping file named dozerBeanMapping.xml, so
 * configuration is very limited. Instead of using the DozerBeanMapperSingletonWrapper, it is recommended that the
 * DozerBeanMapper(MapperIF) instance is configured via an IOC framework, such as Spring, with singleton property set to
 * "true"
 * 
 * @author garsombke.franz
 */
 public class DozerBeanMapperSingletonWrapper {
 
 private static Mapper instance;
 
 private DozerBeanMapperSingletonWrapper() {
 }
 
 public static synchronized Mapper getInstance() {
 if (instance == null) {
 List<String> mappingFiles = new ArrayList<String>();
 mappingFiles.add(DozerConstants.DEFAULT_MAPPING_FILE);
 instance = new DozerBeanMapper(mappingFiles);
 }
 return instance;
 }
 }

**MappingProcessor类：**

只供内部使用的Mapping处理引擎，是DozerBeanMapper实现对象间转换的真正实现。

该类线程不安全，每一次mapping请求都会创建一个新的MappingProcessor。

/**
 * Internal Mapping Engine. Not intended for direct use by Application code.
 * This class does most of the heavy lifting and is very recursive in nature.
 * 
 * This class is not threadsafe and is instantiated for each new mapping request.
 *
 * @author garsombke.franz
 * @author sullins.ben
 * @author tierney.matt
 * @author dmitry.buzdin
 * @author johnsen.knut-erik
 */
 public class MappingProcessor implements Mapper {

# 3.Dozer使用 #

**DozerMapper -- 支持基本数据类型以及Date、枚举、自定义对象类型转换**

1.默认会匹配名称相同的属性

若存在两个属性，其中一个名称相同，另一个名称不同，但使用@Mapper指定的名称相同， 
则只给@Mapper对应的属性赋值 
eg: 
 
private String name; 
@Mapper("name") 
private String alias;

此时，DozerMapper只给alias赋值，不会给name赋值。 
 
@see 测试方法：com.java.dozer.controller.DozerMapperTest\#modeToDto() 
2.名称不同的属性需要赋值，则需要使用@Mapper 
3.可以使用@Mapper给嵌套对象赋值

**测试场景：**

一个微服项目中，需要将前端提交的表单转换为对应的业务对象，以及将业务对象转换为报表对象Dto

//构建DozerMapper单例
 public final class DozerMapper {
 
 private final static DozerBeanMapper dozerMapper;
 
 private DozerMapper(){}
 
 static {
 dozerMapper = new DozerBeanMapper();
 }
 
 public static DozerBeanMapper get(){
 return dozerMapper;
 }
 }
 
 
 //业务实体对象
 @Data
 public class Teacher {
 
 private String id;
 private String name;
 private Integer age;
 private BigDecimal salary;
 private SexEnum sex;
 private Date birthDate;
 private boolean isManager;//是否是管理层
 private Long num;
 //假设是一对一辅导
 private Student student;
 
 }
 
 @Data
 public class Student implements Serializable {
 private static final long serialVersionUID = -5308107267346753671L;
 
 private String name;
 private Integer age;
 }
 
 @Data
 public class Person implements Serializable {
 
 private static final long serialVersionUID = -4872324978319131431L;
 @Mapping("pId")
 private String id;
 @Mapping("pName")
 private String name;
 private Integer age;//与dto中名称不对应，不会赋值
 private BigDecimal salary;
 private SexEnum sex;
 private Date birthDate;
 private Long num;
 
 }
 
 public enum SexEnum {
 MAN("男性"),WOMAN("女性");
 
 private String desc;
 
 SexEnum(String desc) {
 this.desc = desc;
 }
 
 public String getDesc() {
 return desc;
 }
 }
 
 
 //前端提交表单
 
 @Data
 public class TeacherInsertForm implements Serializable {
 
 private static final long serialVersionUID = -1721667762364509779L;
 /**
 * DozerMapper -- 支持基本数据类型以及Date和自定义对象类型转换
 * 1.默认会匹配名称相同的属性
 * 若存在两个属性，其中一个名称相同，另一个名称不同，但使用@Mapper指定的名称相同，
 * 则只给@Mapper对应的属性赋值
 * eg:
 * 
 * private String name;
 * @Mapper("name")
 * private String alias;
 *
 * 此时，DozerMapper只给alias赋值，不会给name赋值。
 * 
 * @see 测试方法：com.java.dozer.controller.DozerMapperTest#modeToDto()
 * 2.名称不同的属性需要赋值，则需要使用@Mapper
 * 3.可以使用@Mapper给嵌套对象赋值
 */
 
 //名称不同时，使用@Mapper指定属性名
 @Mapping("name")
 private String pName;
 @Mapping("age")
 private Integer pAge;
 
 //名称相同时，可以不用@Mapper指定属性名，当然也可以使用
 private BigDecimal salary;
 private SexEnum sex;
 private Date birthDate;
 private boolean isManager;//是否是管理层
 private Long num;
 
 //嵌套对象赋值
 @Mapping("student.name")
 private String stuName;
 @Mapping("student.age")
 private Integer stuAge;
 
 }
 
 
 @Data
 public class PersonInsertForm implements Serializable {
 
 private static final long serialVersionUID = -1721667762364509779L;
 
 private String pId;
 private String pName;
 private Integer pAge;
 private BigDecimal salary;
 private SexEnum sex;
 private Date birthDate;
 private boolean isManager;//是否是管理层
 private Long num;
 
 }
 
 
 //测试类
 public class DozerMapperTest {
 
 /**
 * 测试：从form转换为业务实体对象 【在form中设置注解@Mapping】
 * form：表示前端提交的参数
 */
 @Test
 public void formToModel(){
 TeacherInsertForm insertForm = this.initTeracherForm();
 
 Teacher teacher = new Teacher();
 DozerMapper.get().map(insertForm, teacher);
 System.out.println(teacher);
 
 /**
 * 测试结果：
 * Teacher(id=null, name=老师张三, age=36, salary=4999.9, sex=MAN, birthDate=Mon Apr 08 10:37:15 CST 2019,
 isManager=true, num=1000, student=Student(name=学生李四, age=18))
 */
 
 }
 
 /**
 * 模拟前端传的参数
 * @return
 */
 private TeacherInsertForm initTeracherForm() {
 TeacherInsertForm insertForm = new TeacherInsertForm();
 insertForm.setPName("老师张三");
 insertForm.setPAge(36);
 insertForm.setSex(SexEnum.MAN);
 insertForm.setSalary(new BigDecimal("4999.9"));
 insertForm.setBirthDate(new Date());
 insertForm.setManager(true);
 insertForm.setNum(1000l);
 insertForm.setStuName("学生李四");
 insertForm.setStuAge(18);
 return insertForm;
 }
 
 /**
 * 测试：从form转换为业务实体对象 【在业务实体对象中设置注解@Mapping】
 * form：表示前端提交的参数
 */
 @Test
 public void formToModel2(){
 PersonInsertForm insertForm = this.initPersonForm();
 
 Person person = new Person();
 DozerMapper.get().map(insertForm, person);
 System.out.println(person);
 
 /**
 * 测试结果：
 * Person(id=627bb9fe-b026-405a-aaac-b2ee6009d116, name=老师张三, age=null,
 salary=4999.9, sex=MAN, birthDate=Mon Apr 08 10:38:18 CST 2019, num=1000)
 */
 }
 
 /**
 * 模拟前端传的参数
 * @return
 */
 private PersonInsertForm initPersonForm() {
 PersonInsertForm insertForm = new PersonInsertForm();
 insertForm.setPId(UUID.randomUUID().toString());
 insertForm.setPName("老师张三");
 insertForm.setPAge(36);
 insertForm.setSex(SexEnum.MAN);
 insertForm.setSalary(new BigDecimal("4999.9"));
 insertForm.setBirthDate(new Date());
 insertForm.setManager(true);
 insertForm.setNum(1000l);
 return insertForm;
 }
 
 /**
 * 测试：从业务实体对象转换为dto 【在dto中设置注解@Mapping】
 * dto:表示返回给前端的报表字段
 */
 @Test
 public void modeToDto(){
 List<TeacherDto> teacherDtos = new ArrayList<>();
 Arrays.asList(new Teacher[]{this.initTeacher(),this.initTeacher()})
 .forEach(t->{
 TeacherDto dto = new TeacherDto();
 DozerMapper.get().map(t,dto);
 teacherDtos.add(dto);
 });
 
 System.out.println(teacherDtos);
 
 /**测试结果：
 * [
 TeacherDto(id=personId -1173793554433870336, name=null, age=22, salary=4999.9, sex=MAN,
 birthDate=Mon Apr 08 10:38:42 CST 2019, isManager=true, num=1000, pName=张三),
 TeacherDto(id=personId -7819220080057138940, name=null, age=22, salary=4999.9, sex=MAN,
 birthDate=Mon Apr 08 10:38:42 CST 2019, isManager=true, num=1000, pName=张三)
 ]
 */
 }
 
 private Teacher initTeacher(){
 Teacher teacher = new Teacher();
 teacher.setId("personId "+ new Random().nextLong());
 teacher.setName("张三");
 teacher.setAge(22);
 teacher.setSex(SexEnum.MAN);
 teacher.setSalary(new BigDecimal("4999.9"));
 teacher.setBirthDate(new Date());
 teacher.setManager(true);
 teacher.setNum(1000l);
 return teacher;
 }
 
 }

## 参考 ##

[Dozer官方文档][Dozer] | [Dozer源码地址][Dozer 1]

[Apache 2.0]: https://link.jianshu.com/?t=http://www.apache.org/licenses/LICENSE-2.0
[20190408102554360.png]: /images/20220223/4ac1b505e32046188af5f2b8fe1bcd15.png
[Dozer]: https://link.jianshu.com/?t=http://dozer.sourceforge.net/documentation/gettingstarted.html
[Dozer 1]: https://link.jianshu.com/?t=https://github.com/DozerMapper/dozer