在我们实际开发中，常常会有对象与对象之间的转化，或者把一个对象的数据转化到另一个数据之中，如果我们手动的一个一个的set就会比较麻烦，代码段看起来也会比较长。而Orika的MapperFacade就是解决这个问题的，实现对象属性的复制。
Orika的MapperFacade的官网：http://orika-mapper.github.io/orika-docs/intro.html
这里有两个核心的类，MapperFactory 、MapperFacade。
MapperFactory：相当于一个通道，无它不行，可以用来注册字段的映射、转换器、自定义映射器、具体类型等等。
上面的图片是从官网上截下来的，大致就是说，创建一个MapperFactory实例，它的作用可以用来注册字段的映射、转换器、自定义映射器、具体类型等等。MapperFactory的classMap方法是用来映射名称不同的属性，比如现在person类有dateTime属性，而student类没有dateTime属性，但是有birth属性，这两个属性虽然名字不同，但是表示的意思是一样的，表示出生年月，此时就需要使用classMap来匹配不同属性的映射。
而field()、byDefault()、register()的作用分别如下：
MapperFacade：它是实现映射过程的真正部分。有两种映射模式：
模式一：map(objectA, B.class)方法：将会生成一个新的实例B，然后把实例A中的属性赋值给实例B。所以方法是有返回值的，返回的是已经赋值完成的实例B。
模式二：map(objectA, objectB)方法：A、B都是实例，不是null，然后把实例A的属性赋值到实例B中。所以是没有返回值的。
另外：MapperFacade的作用和Spring中的BeanUtils是一样的，都是属性赋值的，只不过BeanUtils属性复制的时候，如果两个对象的属性不一样的话，需要手动的去设置，比较麻烦。
MapperFacade的效率相对来说高一些：因为Orika的设计思路是预先通过javaassist把JavaBean之间的映射关系一次性生成目标拷贝方法代码。 这样就可以避免在Bean 映射环节一次次的读取映射规则。 从而实现效率上的提高。
下面就写一个demo测试一下。
第一步：maven工程的话，先导入依赖。不是maven的话，可以去官网下载相关文件。
<dependency>
<groupId>ma.glasnost.orika</groupId>
<artifactId>orika-core</artifactId>
<version>1.4.2</version><!-- or latest version -->
</dependency>
第二步：写一个配置类，生成MapperFactory实例。如果不写配置的话，就直接在代码中生成即可。
package com.lmh.config;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.impl.DefaultMapperFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author lmh
* @Description:
* @date 2021/12/21 14:01
*/
@Configuration
public class MapperFactoryAutowire {
@Bean
public MapperFactory getMapperFactory(){
return new DefaultMapperFactory.Builder().build();
}
}
第三步：写两个实体类，属性设置的有不一样的。
package com.lmh.po;
import java.util.Date;
/**
* @author lmh
* @Description:
* @date 2021/12/21 14:07
*/
public class Person {
public Person() {
}
public Person(String name, Integer age, Date dateTime) {
this.name = name;
this.age = age;
this.dateTime = dateTime;
}
private String name;
private Integer age;
private Date dateTime;
public String getName() {
return name;
}
public Person setName(String name) {
this.name = name;
return this;
}
public Integer getAge() {
return age;
}
public Person setAge(Integer age) {
this.age = age;
return this;
}
public Date getDateTime() {
return dateTime;
}
public Person setDateTime(Date dateTime) {
this.dateTime = dateTime;
return this;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", dateTime=" + dateTime +
'}';
}
}
package com.lmh.po;
import java.util.Date;
/**
* @author lmh
* @Description:
* @date 2021/12/21 14:08
*/
public class Student {
private String name;
private String grade;
private Integer age;
private Date birth;
public Date getBirth() {
return birth;
}
public Student setBirth(Date birth) {
this.birth = birth;
return this;
}
public String getName() {
return name;
}
public Student setName(String name) {
this.name = name;
return this;
}
public String getGrade() {
return grade;
}
public Student setGrade(String grade) {
this.grade = grade;
return this;
}
public Integer getAge() {
return age;
}
public Student setAge(Integer age) {
this.age = age;
return this;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", grade='" + grade + '\'' +
", age=" + age +
", birth=" + birth +
'}';
}
}
上面是一些前期准备，在controller中写一个测试方法测试对对象属性拷贝。
/**
* @author lmh
* @Description:
* @date 2021/12/21 14:12
*/
@RestController
public class BeanCopyController {
@Autowired
public MapperFactory mapperFactory;
/**
* @Decription 测试MapperFactory是否生成
* @Param null
* @Return void
* @Author lmh
* @Date 2021/12/21 14:14
*/
@RequestMapping("/createMapperFactory")
public String createMapperFactoryTest(){
System.out.println("注入的mapperFactory是："+mapperFactory);
return "注入的mapperFactory是:"+mapperFactory;
}
/**
* @Decription 将一个已经存在的类的属性映射到另外一个类上（可以不存在），直接返回该类，注意
* 必须要有默认的构造方法，不然会报错
* @Param null
* @Return com.lmh.po.Student
* @Author lmh
* @Date 2021/12/21 14:27
*/
@RequestMapping("/beanCopyToBean")
public Student beanCopyToBean(){
Student student = null;
try {
Person person = new Person("lmh",21,new SimpleDateFormat("yyyy-MM-dd").parse("2000-04-29"));
//MapperFactory 映射两个对象之间的属性、注册转换器、自定义映射器等等
mapperFactory.classMap(Person.class,Student.class)
.field("dateTime","birth") //不同属性名的映射
.byDefault() //剩余字段（相同属性名）的映射
.register(); //向MapperFactory注册映射关系
//如果所有的字段都一样，就不用写mapperFactory.classMap()方法；
student = mapperFactory.getMapperFacade().map(person, Student.class);
System.out.println("属性赋值之后student的属性："+student);
} catch (ParseException e) {
e.printStackTrace();
}
return student;
}
测试结果：
代码如下：
/**
* @Decription 将一个list映射到另一个list中
* @Param null
* @Return java.util.List<com.lmh.po.Student>
* @Author lmh
* @Date 2021/12/21 15:13
*/
@RequestMapping("/beanCopyToList")
public List<Student> beanCopyToList(){
List<Person> personList = this.getPersonList();
//手动配置不一样属性转换
mapperFactory.classMap(Person.class,Student.class)
.field("dateTime","birth") //不一样字段的映射
.byDefault() //剩余字段的映射
.register(); //想MapperFacade注册映射关系
//转换list
List<Student> studentList = mapperFactory.getMapperFacade().mapAsList(personList, Student.class);
studentList.forEach(student -> {
System.out.println(student);
});
return studentList;
}
/**
* @Decription 生成personList
* @Param null
* @Return java.util.List<com.lmh.po.Person>
* @Author lmh
* @Date 2021/12/21 15:20
*/
public List<Person> getPersonList(){
List<Person> list = new ArrayList<>(5);
Person person1 = new Person("lmh1", 20, new Date());
Person person2 = new Person("lmh2", 22, new Date());
Person person3 = new Person("lmh3", 30, new Date());
Person person4 = new Person("lmh4", 14, new Date());
Person person5 = new Person("lmh5", 15, new Date());
list.add(person1);
list.add(person2);
list.add(person3);
list.add(person4);
list.add(person5);
return list;
}
测试结果：
注意：如果两个类属性都一样，进行属性赋值的时候，就不需要进行字段映射了，直接通过mapperFactory获取mapperFacade对象即可。
