一看就会的Orika实体映射工具

最新推荐文章于 2023-07-20 20:00:49 发布

置顶冉野丶

最新推荐文章于 2023-07-20 20:00:49 发布

阅读量9.6k

点赞数 2

分类专栏： Java学习笔记 Orika工具文章标签： Orika Bean工具类

本文链接：https://blog.csdn.net/hanerer1314/article/details/94337178

版权

Java学习笔记同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

Orika工具

1 篇文章 0 订阅

订阅专栏

看一眼就会的Orika映射工具。

我感觉真不用再写什么Orika的详细介绍了。想必你要是写过Convert类的话应该会明白这个工具大概是能做什么了，如果真要写我可能也只会是跟别人有所雷同，我之所以想起这个工具是因为在DO（实体对象-持久化）
和数据传输对象（DTO）之间的映射时候，要写get 和set方法，超级麻烦，我就开始琢磨能不能使用一种工具如果DO对象和DTO对象之间保持字段名称相同两者之间可相互映射，不用写繁琐的Convert转化类，Orika同级别的竞品还有Apache的BeanUtils，Spring的BeanUtils，还有Dozer（还没用过），MapStruct（这个稍微有点麻烦，配置起来）有性能对比说Orika这种使用字节码生成器比Dozer这种基于反射机制实现的要快出很多。

我会用例子来说明这个Orika具体是怎么来使用，如何在项目中依赖，用法是非常简单的，源码我也没有研究过，只是写了实例来说明，核心的类有MapperFactoty，用户创建实际执行映射工具对象MapperFacade。

线上工具类:

package com.ruoyi.common.utils;

import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.impl.DefaultMapperFactory;
import ma.glasnost.orika.metadata.ClassMapBuilder;
import org.springframework.expression.ExpressionException;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 映射工具类
 *
 * @author 冉野
 */
public enum MapperUtils {

    /**
     * 实例
     */
    INSTANCE;

    /**
     * 默认字段工厂
     */
    private static final MapperFactory MAPPER_FACTORY = new DefaultMapperFactory.Builder().build();

    /**
     * 默认字段实例
     */
    private static final MapperFacade MAPPER_FACADE = MAPPER_FACTORY.getMapperFacade();

    /**
     * 默认字段实例集合
     */
    private static final Map<String, MapperFacade> CACHE_MAPPER_FACADE_MAP = new ConcurrentHashMap<>();

    /**
     * 映射实体（默认字段）
     *
     * @param toClass 映射类对象
     * @param data    数据（对象）
     * @return 映射类对象
     */
    public <E, T> E map(Class<E> toClass, T data) {
        return MAPPER_FACADE.map(data, toClass);
    }

    /**
     * 映射实体（自定义配置）
     *
     * @param toClass   映射类对象
     * @param data      数据（对象）
     * @param configMap 自定义配置
     * @return 映射类对象
     */
    public <E, T> E map(Class<E> toClass, T data, Map<String, String> configMap) {
        MapperFacade mapperFacade = this.getMapperFacade(toClass, data.getClass(), configMap);
        return mapperFacade.map(data, toClass);
    }

    /**
     * 映射集合（默认字段）
     *
     * @param toClass 映射类对象
     * @param data    数据（集合）
     * @return 映射类对象
     */
    public <E, T> List<E> mapAsList(Class<E> toClass, Collection<T> data) {
        return MAPPER_FACADE.mapAsList(data, toClass);
    }


    /**
     * 映射集合（自定义配置）
     *
     * @param toClass   映射类
     * @param data      数据（集合）
     * @param configMap 自定义配置
     * @return 映射类对象
     */
    public <E, T> List<E> mapAsList(Class<E> toClass, Collection<T> data, Map<String, String> configMap) {
        T t = data.stream().findFirst().orElseThrow(() -> new ExpressionException("映射集合，数据集合为空"));
        MapperFacade mapperFacade = this.getMapperFacade(toClass, t.getClass(), configMap);
        return mapperFacade.mapAsList(data, toClass);
    }

    /**
     * 获取自定义映射
     *
     * @param toClass   映射类
     * @param dataClass 数据映射类
     * @param configMap 自定义配置
     * @return 映射类对象
     */
    private <E, T> MapperFacade getMapperFacade(Class<E> toClass, Class<T> dataClass, Map<String, String> configMap) {
        String mapKey = dataClass.getCanonicalName() + "_" + toClass.getCanonicalName();
        MapperFacade mapperFacade = CACHE_MAPPER_FACADE_MAP.get(mapKey);
        if (Objects.isNull(mapperFacade)) {
            MapperFactory factory = new DefaultMapperFactory.Builder().build();
            ClassMapBuilder classMapBuilder = factory.classMap(dataClass, toClass);
            configMap.forEach(classMapBuilder::field);
            classMapBuilder.byDefault().register();
            mapperFacade = factory.getMapperFacade();
            CACHE_MAPPER_FACADE_MAP.put(mapKey, mapperFacade);
        }
        return mapperFacade;
    }
}

Maven项目依赖包：POM文件直接依赖进去即可。

<dependency>
    <groupId>ma.glasnost.orika</groupId>
    <artifactId>orika-core</artifactId>
    <version>1.4.6</version>
</dependency>

先说一下需要达到的结果，PersonDTO需要从Person中映射出来，暴露出来的是DTO对象。Orika中主要使用到的也就几个方法，一个是刚才说的MapperFactoty另一个便是MapperFacade
一旦有了MapperFacade他，字段映射的工作就基本完成了百分之50了。
第一步：

/**
     * 获取默认字段工厂 
     */
    private static final MapperFactory MAPPER_FACTORY = new DefaultMapperFactory.Builder().build();

第二步：获取MapperFacade

 /**
     * 默认字段实例
     */
    private static final MapperFacade MAPPER_FACADE = MAPPER_FACTORY.getMapperFacade();

第三步：开始实体对象的映射这一步可自己封住对应的API方法，也可直接拷贝我这份过去，生产上已经验证通过没啥大问题的。eg：

/**
     * 映射实体（默认字段）
     * 这种映射就是DTO字段名称和实体对象DO之间字段名称一致
     * @param toClass 映射类对象 DTO对象
     * @param data    数据（对象）DO对象
     * @return 映射类对象
     */
    public <E, T> E map(Class<E> toClass, T data) {
        return MAPPER_FACADE.map(data, toClass);
    }

    /**
     * 映射实体（自定义配置）
     * @param toClass   映射类对象 DTO对象
     * @param data      数据（对象）DO对象
     * @param configMap 自定义配置 这个自定义配置我目前就理解为，如果需要映射的字段之间存在差异，需要通过一个对象来中中转
     * @return 映射类对象
     */
    public <E, T> E map(Class<E> toClass, T data, Map<String, String> configMap) {
        MapperFacade mapperFacade = this.getMapperFacade(toClass, data.getClass(), configMap);
        return mapperFacade.map(data, toClass);
    }

    /**
     * 映射集合（默认字段）
     * 映射为集合的形式
     * @param toClass 映射类对象 DTO对象
     * @param data    数据（集合） DO对象
     * @return 映射类对象
     */
    public <E, T> List<E> mapAsList(Class<E> toClass, Collection<T> data) {
        return MAPPER_FACADE.mapAsList(data, toClass);
    }

    简单栗子说明：

    实体对象：
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Person {
    private Long id;
    private String name;
    private String email;
    private Date birth;
    private User user;
}

    DTO对象：
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class PersonDTO {
    private Long id;
    private String name;
    /**
     * 对应 Person.user.age
     */
    private Integer age;
    private String email;
    /**
     * 与 DO 里面的字段名称(birthDay)不一致
     */
    private Date birth;
    /**
     * 对 DO 里面的字段(birthDay)进行拓展,dateFormat 的形式
     */
    private String birthDateFormat;
    /**
     * 对 DO 里面的字段(birthDay)进行拓展,expression 的形式
     */
    private String birthExpressionFormat;
}
    先创建一个实体对象DO class
    Person person = new Person(1200L,"冉野","yangtianrui@163.com",new Date(),new User(25));
    大招开始：对象之间默认字段映射
    PersonDTO personDTO = MapperUtils.INSTANCE.map(PersonDTO.class,person);
    结果输出：
    
    映射为集合：
    List<Person> personList = new ArrayList<>();
    personList.add(person);
    List<PersonDTO> list = MapperUtils.INSTANCE.mapAsList(PersonDTO.class, personList);
    System.out.println(list);
    结果输出：

    
    如何自定义字段映射，DO和DTO之间字段有着明显的差异，如果通过属性获取方式来映射，这就得说起Orika的Field属性了，获取这个高级特性的方法如下：
     /**
     * 获取自定义映射
     *
     * @param toClass   映射类
     * @param dataClass 数据映射类
     * @param configMap 自定义配置
     * @return 映射类对象
     */
    private <E, T> MapperFacade getMapperFacade(Class<E> toClass, Class<T> dataClass, Map<String, String> configMap) {
        String mapKey = dataClass.getCanonicalName() + "_" + toClass.getCanonicalName();
        MapperFacade mapperFacade = CACHE_MAPPER_FACADE_MAP.get(mapKey);
        if (Objects.isNull(mapperFacade)) {
            MapperFactory factory = new DefaultMapperFactory.Builder().build();
            ClassMapBuilder classMapBuilder = factory.classMap(dataClass, toClass);
            configMap.forEach(classMapBuilder::field);
            classMapBuilder.byDefault().register();
            mapperFacade = factory.getMapperFacade();
            CACHE_MAPPER_FACADE_MAP.put(mapKey, mapperFacade);
        }
        return mapperFacade;
    }

举例如下：
// key 是数据对象 value是映射对象

 Map<String, String> map = Maps.newHashMap();
        map.put("birth","birth");
        map.put("pemail","email");
        map.put("user.age","age"); // 嵌套映射
        PersonDTO dto = MapperUtils.INSTANCE.map(PersonDTO.class, person, map);
        System.out.println(dto);

   要测试pemail 和email之间的映射，就是可以使用field字段了，在Person DO实体对象中修改email属性为pemail,然后更能方便看出映射的结果，这里有必要注意byDefault().register()方法，
   如果byDefault方法没有直接调用而是直接调用了register()方法，默认相同的字段也不会映射成功，只映射成功了pemail和email字段。可以看出有一个字段age，其映射的是user.age两者之间的映射，这就是嵌套映射，非常简单，通过对象.属性获取到对应的字段即可。
   结果输出：

如果需要排除指定的某个字段不用映射，在classMap()方法后直接调用exclude("指定字段")即可。
   如果需要从一个Map对象中映射到另一个对象的属性中，就需要我们使用类似下标索引的方式构建field字段，首先我们在Person对象中增加一个Map集合，
   private Ma<String,String> address; // 用于存储地址信息
   同时DTO对象中增加需要映射的两个或者多个字段（根据Map的长度啦），
   private String company; // 公司地址
private String home；// 家庭住址

   直接上代码：

 person对象：
    Map<String,String> address = new HashMap<>();
        address.put("company","来广营");
        address.put("home","望京");
        Person person = new Person(1200L,"冉野","yangtianrui@163.com",new Date(),new User(25),address);

   field字段转换过程：

  MapperFactory factory = new DefaultMapperFactory.Builder().build();
        ClassMapBuilder classMapBuilder = factory.classMap(Person.class,PersonDTO.class)
                .field("address['company']","company")
                .field("address['home']","home");
        classMapBuilder.byDefault().register();

        MapperFacade mapper = factory.getMapperFacade();
        PersonDTO dto = mapper.map(person,PersonDTO.class);
        System.out.println(dto);

结果输出：

   另外一种情况是，映射null值，如果源对象中有null的属性值，在映射后目标对象中的值也有null，测试过程如下：在构建Person对象时候，指定id = null,但在映射对象PersonDTO中给定一个自定义的的初始值id = 100L，
   map映射后id变为null，然后通过MapperFactory mapperFactory = new DefaultMapperFactory.Builder()
.mapNulls(false).build(); 设置为false后，null值不做映射，反之设置为true，映射为null。刚才这种配置是局部配置，同样也支持字段属性级别的配置：mapperFactory.classMap(Source.class, Dest.class).field("age", "age")
.fieldMap("birth", "birth").mapNulls(false).add().byDefault().register();

以上功能算是Orika给我们提供的API，也可自己实现自定义的映射，非常的简单只需要继承一下Orika为我们提供的CustomMapper，映射方法，例如Person对象中有一个属性类型为Date的currentDate字段，PersonDTO中有一个属性为String 类型的currentDate字段，这里就需要我们自定义一个实现这种属性间的转换，代码如下：

MapperFactory factory = new DefaultMapperFactory.Builder().build();
        ClassMapBuilder classMapBuilder = factory.classMap(Person.class,PersonDTO.class).byDefault().customize(new CustomMapper<Person, PersonDTO>() {
            @Override
            public void mapAtoB(Person person, PersonDTO personDTO, MappingContext context) {
                Objects.requireNonNull(person);
                DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                personDTO.setCurrentDate(format.format(person.getCurrentDate()));
            }
        });

CustomMapper 类也也可单独提出来一个单独的类。为了代码的简洁就直接new CustomMapper()也可。在重写方法时候，请注意看方法名称，有mapAtoB还有mapBtoA等一系列。

冉野丶

关注

2
点赞
踩
15

收藏

觉得还不错? 一键收藏
2
评论
一看就会的Orika实体映射工具

看一眼就会的Orika映射工具。我感觉真不用再写什么Orika的详细介绍了。想必你要是写过Convert类的话应该会明白这个工具大概是能做什么了，如果真要写我可能也只会是跟别人有所雷同，我之所以想起这个工具是因为在DO（实体对象-持久化）和数据传输对象（DTO）之间的映射时候，要写get 和set方法，超级麻烦，我就开始琢磨能不能使用一种工具如果DO对象和DTO对象之间保持字段...
复制链接

扫一扫

专栏目录