(四) SpringBoot 进行对象复制--Orika

已于 2022-08-10 14:35:11 修改
阅读量1.3k 收藏 4
点赞数
分类专栏： SpringBoot 文章标签： spring boot spring java
于 2022-07-01 13:42:06 首次发布
原文链接：https://zhuanlan.zhihu.com/p/410630612
版权 
		SpringBoot 进行对象复制--Orika

业务开发需要对象复制

在这里插入图片描述如上，是我们平时开发中最常见的三层MVC架构模型，编辑操作时Controller层接收到前端传来的DTO对象，在Service层需要将DTO转换成DO，然后在数据库中保存。查询操作时Service层查询到DO对象后需要将DO对象转换成VO对象，然后通过Controller层返回给前端进行渲染。

这中间会涉及到大量的对象转换，很明显我们不能直接使用getter/setter复制对象属性,严重影响开发效率

对象复制工具类推荐

对象复制的类库工具有很多，除了常见的Apache的BeanUtils，Spring的BeanUtils，Cglib BeanCopier，还有重量级组件MapStruct，Orika，Dozer，ModelMapper等。

如果没有特殊要求，这些工具类都可以直接使用，除了Apache的BeanUtils。原因在于Apache BeanUtils底层源码为了追求完美，加了过多的包装，使用了很多反射，做了很多校验，所以导致性能较差，并在阿里巴巴开发手册上强制规定避免使用 Apache BeanUtils。

Orika基本使用

要使用Orika很简单，只需要简单四步：
引入依赖

<dependency>
  <groupId>ma.glasnost.orika</groupId>
  <artifactId>orika-core</artifactId>
  <version>1.5.4</version>
</dependency>
  1. 构造一个MapperFactory
MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
  1. 注册字段映射
mapperFactory.classMap(SourceClass.class, TargetClass.class)  
   .field("firstName", "givenName")
   .field("lastName", "sirName")
   .byDefault()
   .register();

当字段名在两个实体不一致时可以通过.field()方法进行映射，如果字段名都一样则可省略，byDefault()方法用于注册名称相同的属性，如果不希望某个字段参与映射，可以使用exclude方法。

OrikaUtils

package com.jianzh5.blog.orika;

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.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Description:
 * Orika封装的工具类
 * @author babayang
 * @date 2022/6/25 14:01
 */
public class OrikaUtils {

    private static final MapperFactory FACTORY = new DefaultMapperFactory.Builder().build();

    /**
     * 缓存实例集合
     */
    private static final Map<String, MapperFacade> CACHE_MAPPER = new ConcurrentHashMap<>();

    private final MapperFacade mapper;

    public OrikaUtils(MapperFacade mapper) {
        this.mapper = mapper;
    }

    /**
     * 转换实体函数
     * @param sourceEntity 源实体
     * @param targetClass  目标类对象
     * @param refMap       配置源类与目标类不同字段名映射
     * @param <S>          源泛型
     * @param <T>          目标泛型
     * @return 目标实体
     */
    public static <S, T> T convert(S sourceEntity, Class<T> targetClass, Map<String, String> refMap) {
        if (sourceEntity == null) {
            return null;
        }
        return classMap(sourceEntity.getClass(), targetClass, refMap).map(sourceEntity, targetClass);
    }

    /**
     * 转换实体函数
     *
     * @param sourceEntity 源实体
     * @param targetClass  目标类对象
     * @param <S>          源泛型
     * @param <T>          目标泛型
     * @return 目标实体
     */
    public static <S, T> T convert(S sourceEntity, Class<T> targetClass) {
        return convert(sourceEntity, targetClass, null);
    }

    /**
     * 转换实体集合函数
     *
     * @param sourceEntityList 源实体集合
     * @param targetClass      目标类对象
     * @param refMap           配置源类与目标类不同字段名映射
     * @param <S>              源泛型
     * @param <T>              目标泛型
     * @return 目标实体集合
     */
    public static <S, T> List<T> convertList(List<S> sourceEntityList, Class<T> targetClass, Map<String, String> refMap) {
        if (sourceEntityList == null) {
            return null;
        }
        if (sourceEntityList.size() == 0) {
            return new ArrayList<>(0);
        }
        return classMap(sourceEntityList.get(0).getClass(), targetClass, refMap).mapAsList(sourceEntityList, targetClass);
    }

    /**
     * 转换实体集合函数
     *
     * @param sourceEntityList 源实体集合
     * @param targetClass      目标类对象
     * @param <S>              源泛型
     * @param <T>              目标泛型
     * @return 目标实体集合
     */
    public static <S, T> List<T> convertList(List<S> sourceEntityList, Class<T> targetClass) {
        return convertList(sourceEntityList, targetClass, null);
    }



    /**
     * 注册属性
     * @param source 源类
     * @param target 目标类
     * @param refMap 属性转换
     */
    public static <V, P> void register(Class<V> source, Class<P> target,Map<String, String> refMap){
        if (CollectionUtils.isEmpty(refMap)) {
            FACTORY.classMap(source, target).byDefault().register();
        } else {
            ClassMapBuilder<V, P> classMapBuilder = FACTORY.classMap(source, target);
            refMap.forEach(classMapBuilder::field);
            classMapBuilder.byDefault().register();
        }
    }

    /**
     * 属性名称一致可用
     * @param source 源数据
     * @param target 目标对象
     * @return OrikaUtils
     */
    private static <V, P> OrikaUtils classMap(Class<V> source, Class<P> target) {
        return classMap(source, target, null);
    }

    /**
     * 属性名称不一致可用
     *
     * @param source 原对象
     * @param target 目标对象
     * @return OrikaUtils
     */
    private static synchronized <V, P> OrikaUtils classMap(Class<V> source, Class<P> target, Map<String, String> refMap) {
        String key = source.getCanonicalName() + ":" + target.getCanonicalName();
        if (CACHE_MAPPER.containsKey(key)) {
            return new OrikaUtils(CACHE_MAPPER.get(key));
        }
        register(source,target,refMap);
        MapperFacade mapperFacade = FACTORY.getMapperFacade();
        CACHE_MAPPER.put(key, mapperFacade);

        return new OrikaUtils(mapperFacade);
    }



    /**
     * Orika复制对象
     * @param source 源数据
     * @param target 目标对象
     * @return target
     */
    private <V, P> P map(V source, Class<P> target) {
        return mapper.map(source, target);
    }

    /**
     * 复制List
     * @param source 源对象
     * @param target 目标对象
     * @return P
     */
    private <V, P> List<P> mapAsList(List<V> source, Class<P> target) {
        return CollectionUtils.isEmpty(source) ? Collections.emptyList() : mapper.mapAsList(source, target);
    }

}

分别对应：

  • 字段一致实体转换
  • 字段不一致实体转换（需要字段映射）
  • 字段一致集合转换字段不一致集合转换（需要字段映射）
  • 字段属性转换注册

Orika工具类使用文档

先准备两个基础实体类，Student，Teacher

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private String id;
    private String name;
    private String email;
}


@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    private String id;
    private String name;
    private String emailAddress;
}

TC1，基础实体映射

/**
 * 只拷贝相同的属性
 */
@Test
public void convertObject(){
  Student student = new Student("1","李四","laoying@163.com");
  Teacher teacher = OrikaUtils.convert(student, Teacher.class);
  System.out.println(teacher);
}

输出结果：

Teacher(id=1, name=李四, emailAddress=null)

此时由于属性名不一致，无法映射字段email。

TC2，实体映射 - 字段转换

/**
 * 拷贝不同属性
 */
@Test
public void convertRefObject(){
  Student student = new Student("1","张三","babayang@163.com");

  Map<String,String> refMap = new HashMap<>(1);
  //map key 放置 源属性，value 放置 目标属性
  refMap.put("email","emailAddress");
  Teacher teacher = OrikaUtils.convert(student, Teacher.class, refMap);
  System.out.println(teacher);
}

输出结果：

Teacher(id=1, name=张三, emailAddress=babayang@163.com)

此时由于对字段做了映射，可以将email映射到emailAddress。注意这里的refMap中key放置的是源实体的属性，而value放置的是目标实体的属性，不要弄反了。

TC3，基础集合映射

/**
  * 只拷贝相同的属性集合
  */
@Test
public void convertList(){
  Student student1 = new Student("1","张三","babayang@163.com");
  Student student2 = new Student("2","李四","laoying@xxx.com");
  List<Student> studentList = Lists.newArrayList(student1,student2);

  List<Teacher> teacherList = OrikaUtils.convertList(studentList, Teacher.class);

  System.out.println(teacherList);
}

输出结果：

[Teacher(id=1, name=张三, emailAddress=null), Teacher(id=2, name=李四, emailAddress=null)]

此时由于属性名不一致，集合中无法映射字段email。

TC4，集合映射 - 字段映射

/**
 * 映射不同属性的集合
 */
@Test
public void convertRefList(){
  Student student1 = new Student("1","张三","babayang@163.com");
  Student student2 = new Student("2","李四","laoying@xxx.com");
  List<Student> studentList = Lists.newArrayList(student1,student2);

  Map<String,String> refMap = new HashMap<>(2);
  //map key 放置 源属性，value 放置 目标属性
  refMap.put("email","emailAddress");

  List<Teacher> teacherList = OrikaUtils.convertList(studentList, Teacher.class,refMap);

  System.out.println(teacherList);
}

输出结果：
[Teacher(id=1, name=张三, emailAddress=babayang@163.com), Teacher(id=2, name=李四, emailAddress=laoying@xxx.com)]

也可以通过这样映射：

Map<String,String> refMap = new HashMap<>(2);
refMap.put("email","emailAddress");
List<Teacher> teacherList = OrikaUtils.classMap(Student.class,Teacher.class,refMap)
        .mapAsList(studentList,Teacher.class);

TC5，集合与实体映射

有时候我们需要将集合数据映射到实体中，如Person类

@Data
public class Person {
    private List<String> nameParts;
}

现在需要将Person类nameParts的值映射到Student中，可以这样做

/**
 * 数组和List的映射
 */
@Test
public void convertListObject(){
   Person person = new Person();
   person.setNameParts(Lists.newArrayList("1","美丽","meili@163.com"));

    Map<String,String> refMap = new HashMap<>(2);
    //map key 放置 源属性，value 放置 目标属性
    refMap.put("nameParts[0]","id");
    refMap.put("nameParts[1]","name");
    refMap.put("nameParts[2]","email");

    Student student = OrikaUtils.convert(person, Student.class,refMap);
    System.out.println(student);
}

输出结果：

Student(id=1, name=美丽, email=meili@163.com)

TC6，类类型映射
有时候我们需要类类型对象映射，如BasicPerson类

@Data
public class BasicPerson {
    private Student student;
}

现在需要将BasicPerson映射到Teacher

/**
 * 类类型映射
 */
@Test
public void convertClassObject(){
    BasicPerson basicPerson = new BasicPerson();
    Student student = new Student("1","艾伦","ailun@163.com");
    basicPerson.setStudent(student);

    Map<String,String> refMap = new HashMap<>(2);
    //map key 放置 源属性，value 放置 目标属性
    refMap.put("student.id","id");
    refMap.put("student.name","name");
    refMap.put("student.email","emailAddress");

    Teacher teacher = OrikaUtils.convert(basicPerson, Teacher.class,refMap);
    System.out.println(teacher);
}

输出结果：

Teacher(id=1, name=艾伦, emailAddress=ailun@163.com)

TC7，多重映射

有时候我们会遇到多重映射，如将StudentGrade映射到TeacherGrade

@Data
public class StudentGrade {
    private String studentGradeName;
    private List<Student> studentList;
}

@Data
public class TeacherGrade {
    private String teacherGradeName;
    private List<Teacher> teacherList;
}

这种场景稍微复杂，Student与Teacher的属性有email字段不相同，需要做转换映射；StudentGrade与TeacherGrade中的属性也需要映射。

/**
 * 一对多映射
 */
@Test
public void convertComplexObject(){
  Student student1 = new Student("1","zhangsan","babayang@163.com");
  Student student2 = new Student("2","lisi","laoying@xxx.com");
  List<Student> studentList = Lists.newArrayList(student1,student2);

  StudentGrade studentGrade = new StudentGrade();
  studentGrade.setStudentGradeName("硕士");
  studentGrade.setStudentList(studentList);

  Map<String,String> refMap1 = new HashMap<>(1);
  //map key 放置 源属性，value 放置 目标属性
  refMap1.put("email","emailAddress");
  OrikaUtils.register(Student.class,Teacher.class,refMap1);


  Map<String,String> refMap2 = new HashMap<>(2);
  //map key 放置 源属性，value 放置 目标属性
  refMap2.put("studentGradeName", "teacherGradeName");
  refMap2.put("studentList", "teacherList");


  TeacherGrade teacherGrade = OrikaUtils.convert(studentGrade,TeacherGrade.class,refMap2);
  System.out.println(teacherGrade);
}

多重映射的场景需要根据情况调用OrikaUtils.register()注册字段映射。

输出结果：

TeacherGrade(teacherGradeName=硕士, teacherList=[Teacher(id=1, name=zhangsan, emailAddress=babayang@163.com), Teacher(id=2, name=lisi, emailAddress=laoying@xxx.com)])

TC8，MyBaits plus分页映射

如果你使用的是mybatis的分页组件，可以这样转换

public IPage<UserDTO> selectPage(UserDTO userDTO, Integer pageNo, Integer pageSize) {
  Page page = new Page<>(pageNo, pageSize);
  LambdaQueryWrapper<User> query = new LambdaQueryWrapper();
  if (StringUtils.isNotBlank(userDTO.getName())) {
    query.like(User::getKindName,userDTO.getName());
  }
  IPage<User> pageList = page(page,query);
  // 实体转换 SysKind转化为SysKindDto
  Map<String,String> refMap = new HashMap<>(3);
  refMap.put("kindName","name");
  refMap.put("createBy","createUserName");
  refMap.put("createTime","createDate");
  return pageList.convert(item -> OrikaUtils.convert(item, UserDTO.class, refMap));
}

参考文章: http://orika-mapper.github.io/orika-docs/index.html
参考文章: https://zhuanlan.zhihu.com/p/410630612
参考文章: https://github.com/jianzh5/cloud-blog

懒羊羊--搞点小技术
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
SpringBoot 系列教程(一百零八)：SpringBoot整合Orika实体映射工具
Thinkingcao的专栏
04-23 1054
在开发过程中，经常涉及到对象之间的拷贝，我记得以前用得最多的`Spring`框架中自带的一个`API`方法是： ```java BeanUtils.copyProperties(Object source, Object target) ``` `BeanUtils.copyProperties(Object source, Object target)`的含义是将`source`的属性值复制到`target`，属性为null时也会进行复制。
OrikaUtil以及BeanUtils的使用
Blank 哥哥
09-22 927
OrikaUtil以及BeanUtils的使用 OrikaUtil是DO/BO以及 VO 的复制工具类,一般进行对象和集合之间的复制 一 ; copyObject /** * 将对象sourceObject的值拷贝到对象targetObject中 */ public static void copyObject(Object sourceObject, Object targetObject) { mapperFacade.map(sourceObject
orika-spring-boot-starter：适用于Orika的Spring Boot Starter
01-30
orika-spring-boot-starter 适用于 Starter 。 注意：此页面用于Spring 。如果使用Spring Boot 1，请参阅。 产品特点 在应用程序上下文中管理MapperFacade （Orika的mapper界面），并将其注入代码中。 提供用于自定义MapperFactory接口。 提供用于自定义MapperFactoryBuilder界面。 支持的版本 “ orika-spring-boot-starter”支持以下版本。 其他版本也可以使用，但我们尚未对其进行测试。 Java 8、9、10、11 Spring Boot 2.1.3 奥里卡1.5.4 用法 添加依赖 “ orika-spring-boot-starter”在Maven中央存储库中发布。 如果使用的是Maven，请添加以下依赖项。 < dependency> < groupId>net.rakugakibox.spring.boot</ groupId> < artifactId>orika-spring-boot-starter</ art
强烈推荐一个高性能 Java 对象映射框架，简单易用又高效，马上把 BeanUtils 扔了！（带私活源码）
最新发布
m0_68103666的博客
05-27 813
如今微服务架构和领域驱动设计 DDD 愈来愈盛行，于是我们有了大量的 DO 对象与 DTO 对象的映射转化场景。以前的我都是傻乎乎的使用 getter / setter 方式转换，又慢又容易出错。周末在家好好的研究了一下，还真找到一个更好用的。
SpringBoot 项目中 Bean 拷贝及工具类封装
junkaione的博客
05-19 988
在我们SpringBoot 项目的开发中，经常需要做对象的拷贝和转化，例如我们需要把前端传给我们的DTO对象转化为POJO对象存到数据库，返回前端数据时需要把POJO对象转换为VO，这篇文章就讲讲SpringBoot中对象的拷贝及其工具类的封装。
Springboot对象拷贝方案(Orika/MapStructPlus)
青春不散场的专栏
08-20 334
对象拷贝分为深拷贝和浅拷贝，如果使用Apache-BeanUtil和Hutool和Spring的BeanUtil等都是浅拷贝。效率:因为Orika的设计思路是预先通过javaassist把JavaBean之间的映射关系一次性生成目标拷贝方法代码。这样就可以避免在Bean 映射环节一次次的读取映射规则。从而实现效率上的提高。
orika-core-1.5.4-API文档-中英对照版.zip
07-13
赠送jar包：orika-core-1.5.4.jar； 赠送原API文档：orika-core-1.5.4-javadoc.jar； 赠送源代码：orika-core-1.5.4-sources.jar； 赠送Maven依赖信息文件：orika-core-1.5.4.pom； 包含翻译后的API文档：orika-core...
orika-core-1.5.4-API文档-中文版.zip
07-13
赠送jar包：orika-core-1.5.4.jar； 赠送原API文档：orika-core-1.5.4-javadoc.jar； 赠送源代码：orika-core-1.5.4-sources.jar； 赠送Maven依赖信息文件：orika-core-1.5.4.pom； 包含翻译后的API文档：orika-core...
orika-eclipse-tools-1.1.8.zip
10-23
【标题】"orika-eclipse-tools-1.1.8.zip" 提供的是Orika Eclipse Tools的1.1.8版本，这是一个针对Eclipse IDE的工具集，专门用于支持Orika对象映射库的开发工作。Orika是一个高性能、易用的Java Bean到Java Bean...
orika-sample:使用“ ma.glasnost.orika”的样本
05-19
"orika-sample:使用“ma.glasnost.orika”的样本"是一个关于Java对象映射库Orika的实践项目。Orika是一个高性能、易用的对象映射框架，它简化了Java对象到Java对象之间的数据转换过程。这个项目提供了一系列示例，...
spring boot 对象拷贝工具(Orika)
qq_42702229的博客
10-23 1700
1.spring 自带拷贝工具 LoginUser user = new LoginUser(); // 将data中字段相同的属性拷贝到user中 BeanUtils.copyProperties(data , user); 2. 基于Orika的字节码拷贝工具 1) pom <!-- 基于字节码的深拷贝工具类 --> <dependency> <groupId>ma.glasnost.orika&
【业务功能篇51】对象复制的三种方式 工具类Orika、反射、BeanUtils浅拷贝
studyday1的博客
07-25 748
业务场景： 设计规范前提下，我们数据层传输承载的是用DTO，而到控制层返回给前端会对应定义一个VO对象，比如是一个问题单数据集合list,数据层接收的是DTO对对象，到控制层接收后需要转换成list,这里就涉及到要转换对象数据对象复制的类库工具有很多Orika，同时也最流行的对象映射工具,Orika底层采用了javassist类库生成Bean映射的字节码，之后直接加载执行生成的字节码文件，在速度上比使用反射进行赋值会快很多。阿里巴巴开发手册上强制规定避免使用。
SpringBoot系列之对象值复制
qq_42739776的博客
10-27 1619
SpringBoot系列-对象值复制背景1.使用Spring或者Apache的BeanUtils.copyProperties对象赋值2.使用mapstruct，以下版本为我自己尝试的，部分版本会有问题 背景 在实际开发中，我们往往会遇到这种情况：需要将一个对象的值复制到另外一个对象 如下就是使用·构造器赋值的方式 @Accessors(chain = true) public class OmsOrder implements Serializable { private static fina
Java Bean 映射框架(对象拷贝)-Orika
白面小生的博客
09-19 1223
日常开发中，经常会遇到将一个对象bean值复制到另一个bean,一般通过set方法一个一个属性写上去，比较麻烦。当然也有spring、apache的属性拷贝工具,这里介绍一下orika我们的目标是构建一个全面、高效和健壮的 Java bean 映射解决方案。Orika 专注于尽可能实现自动化，同时在需要时通过配置和扩展提供定制。Orika 使开发人员能够：映射复杂和深度结构化的对象通过将嵌套属性映射到顶级属性来“展平”或“扩展”对象，反之亦然即时创建映射器，并应用自定义来控制部分或全部映射。
map怎么转化dto_使用Orika实现DO与DTO的互转
weixin_39769675的博客
12-21 278
使用OrikaUtil实现DO与DTO的互转本文主要讲些什么呢orika是什么？orika的优缺点？ orika怎么集成？No No No ！！！想看这些东西的请往这边走 --> Orika Orika Orika Orika这些东西网上太多了，随便查一下就有了，在这里主要就是提供一个Util类的代码。看到这里，有同学就要开始问了，上面那些都看完之后写个Util那还不是信手捏来？是的，你说的...
1.8大基础类型+String是传值 2.浅克隆和深拷贝对象 Orika(且线程安全,需有无参构造) 3.SerializationUtils(实现Serializable)
focus-unchanged-thing
01-05 1196
import java.util.ArrayList; class Work implements Cloneable{ private String strText; private ArrayList array = new ArrayList(); @SuppressWarnings("unchecked") @Override protected Work clone(){
Orika —— 工具类
正怒月神的博客
10-18 644
在原本基础上，有增加了拷贝对象到对象，null不拷贝的方法。
SpringBoot集成OrikaMapper
118路司机的博客
09-27 1940
OrikaMapper是一个简单、快速的JavaBean拷贝框架，底层采用了javassist类库生成Bean映射的字节码，之后直接加载执行生成的字节码文件，因此在速度上比使用反射进行赋值会快很多。与SpringBoot集成可以快速的进行各种DTO类之间的属性拷贝。...
Orika--更快的bean复制工具
weixin_42030357的博客
05-29 1022
文章目录pom使用 原博客，点击这里 参考博文，点击这里 pom <dependency> <groupId>ma.glasnost.orika</groupId> <artifactId>orika-core</artifactId> <version>1.4.2</version><!-- or latest version --> </dependency> 使用 这里假设我
orika-spring-boot-starter作用
05-13
Orika是一个Java对象映射工具，它可以将一个Java对象映射到另一个Java对象，支持复杂对象、对象嵌套、集合映射等功能。`orika-spring-boot-starter`是一个基于Spring Boot的Orika自动配置Starter，它可以自动配置Orika并将其集成到Spring Boot应用程序中。 使用`orika-spring-boot-starter`可以简化Orika的配置过程，开发人员只需要定义好需要映射的对象，然后在代码中调用即可，无需手动创建Mapper对象。此外，该Starter还支持自定义Mapper对象，以便满足特殊需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值