Java对象属性拷贝工具对比分析

已于 2022-05-19 11:25:25 修改
阅读量4.8k 收藏 7
点赞数
分类专栏： 基础框架 文章标签： Java对象属性拷贝工具详解
于 2022-03-26 19:06:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37583655/article/details/123761134
版权

Java对象属性拷贝工具对比分析

1. 对象属性拷贝概述

在开发中经常遇到对象属性拷贝功能，而对象属性拷贝方式很多，比如手动set赋值，虽然麻烦，但是性能是最好的，其次MapStruct也是通过预编译完成，效率等同手动set，但是这两种相较于一些工具类稍微麻烦一些，一些常用的工具类方便简单，而且效率也相对不错，比如SpringBeanUtils，CgLib，hutoolBeanUtil效率功能都很不错，而且没有第三方依赖，非常干净好用，而Apache的BeanUtils与PropertyUtils虽然使用方便，但是效率不高，很少使用了。

对于手动set实现对象拷贝功能介绍一款idea插件可自动完成两个对象之间set/get值，GenerateAllSetter，IDEA 一键生成所有setter方法，alt+ctrl+s 快捷键进入设置，在Plugins中搜索GenerateAllSetter安装插件，然后重启idea即可。
使用方法，光标置于对象要转换的对象之上，alt+enter会出现快捷选项Generate all setter即可。

2. 对象属性拷贝工具

2.1 拷贝工具对比

拷贝工具使用效率
Spring BeanUtils使用方便，效率中等
Cglib BeanCopier使用方便，效率最高
Apache BeanUtils使用方便，效率低,原因Apache BeanUtils力求做的完美，做了很多校验，兼容，日志打印等导致性能下降。
Apache PropertyUtils使用方便，效率低
Hutool BeanUtil使用方便，封装完善，效率较高

2.2 拷贝工具验证

对比结果，仅供参考，当然耗时因素很多，机器配置环境等。

工具类100次消耗时间1000次消耗时间10000次消耗时间100000次消耗时间1000000次消耗时间
Spring BeanUtils30714371651518
Cglib BeanCopier323102780
Apache BeanUtils28371847677076
Apache PropertyUtils2161018578693

3. 对象属性拷贝实现

3.1 集合对象拷贝

BeanUtils使用instantiateClass初始化对象注意：
必须保证初始化类必须有public默认无参数构造器，注意初始化内部类时，内部类必须是静态的，否则报错！

import cn.hutool.core.collection.CollectionUtil;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeansException;

import java.util.List;

/**
 * 对象属性拷贝
 *
 * @author zrj
 * @since 2021/7/29
 **/
@Slf4j
public class BeanUtil {
    /**
     * 对象属性拷贝
     * 将源对象的属性拷贝到目标对象
     *
     * @param source 源对象
     * @param target 目标对象
     */
    public static void copyProperties(Object source, Object target) {
        try {
            BeanUtils.copyProperties(source, target);
        } catch (BeansException e) {
            log.error("BeanUtil property copy  failed :BeansException", e);
        } catch (Exception e) {
            log.error("BeanUtil property copy failed:Exception", e);
        }
    }

    /**
     * @param input 输入集合
     * @param clzz  输出集合类型
     * @param <E>   输入集合类型
     * @param <T>   输出集合类型
     * @return 返回集合
     */
    public static <E, T> List<T> convertList2List(List<E> input, Class<T> clzz) {
        List<T> output = Lists.newArrayList();
        if (CollectionUtil.isEmpty(input)) {
            return output;
        }

        input.forEach(source -> {
            T target = BeanUtils.instantiateClass(clzz);
            BeanUtils.copyProperties(source, target);
            output.add(target);
        });
        return output;
    }
}

3.2 对象拷贝验证

BeanMapperUtils

package com.jerry.unit.bean;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.core.Converter;

import java.util.ArrayList;
import java.util.List;

/**
 * 对象属性拷贝工具
 * 1、Spring BeanUtils：效率其次
 * 2、Cglib BeanCopier：效率最高
 * 3、Apache BeanUtils：效率低,原因Apache BeanUtils力求做的完美，做了很多校验，兼容，日志打印等导致性能下降。
 * 4、Apache PropertyUtils：效率低
 * 5、HutoolBeanUtil ：使用方便，效率比较高
 *
 * @author zrj
 * @since 2022/3/26
 **/
@Slf4j
public class BeanMapperUtils {
    /**
     * SpringBeanUtils对象属性拷贝
     *
     * @param source 源对象
     * @param target 目标对象
     */
    public static void mappingBeanBySpringBeanUtils(Object source, Object target) {
        try {
            BeanUtils.copyProperties(source, target);
        } catch (Exception e) {
            log.error("SpringBeanUtils Mapping Failed，ErrorMessage：{}，{}", e.getMessage(), e);
        }
    }

    /**
     * CglibBeanCopier对象属性拷贝
     *
     * @param source       源对象，PersonDO.class
     * @param target       目标对象，PersonDTO.class
     * @param useConverter
     * @param var1         源对象，personDO
     * @param var2         目标对象，new PersonDTO()
     * @param var3
     */
    public static void mappingBeanByCglibBeanCopier(Class source, Class target, boolean useConverter, Object var1, Object var2, Converter var3) {
        try {
            BeanCopier copier = BeanCopier.create(source, target, useConverter);
            copier.copy(var1, var2, var3);
        } catch (Exception e) {
            log.error("CglibBeanCopier Mapping Failed，ErrorMessage：{}，{}", e.getMessage(), e);
        }
    }

    /**
     * ApacheBeanUtils对象属性拷贝
     *
     * @param dest 目标对象
     * @param orig 源对象
     */
    private void mappingBeanByApacheBeanUtils(Object dest, Object orig) {
        try {
            org.apache.commons.beanutils.BeanUtils.copyProperties(dest, orig);
        } catch (Exception e) {
            log.error("ApacheBeanUtils Mapping Failed，ErrorMessage：{}，{}", e.getMessage(), e);
        }
    }

    /**
     * ApachePropertyUtils进行属性拷贝（几乎很少使用）
     *
     * @param dest 目标对象
     * @param orig 源对象
     */
    private void mappingBeanByApachePropertyUtils(Object dest, Object orig) {
        try {
            org.apache.commons.beanutils.PropertyUtils.copyProperties(dest, orig);
        } catch (Exception e) {
            log.error("ApachePropertyUtils Mapping Failed，ErrorMessage：{}，{}", e.getMessage(), e);
        }
    }

    /**
     * HutoolBeanUtil进行属性拷贝（几乎很少使用）
     *
     * @param source     源Bean对象
     * @param target     目标Bean对象
     * @param ignoreCase 是否忽略大小写
     */
    private void mappingBeanByHutoolBeanUtil(Object source, Object target, boolean ignoreCase) {
        try {
            BeanUtil.copyProperties(source, target, ignoreCase);
        } catch (Exception e) {
            log.error("HutoolBeanUtil Mapping Failed，ErrorMessage：{}，{}", e.getMessage(), e);
        }
    }

    /**
     * SpringBeanUtils集合对象属性拷贝
     *
     * @param input 输入集合
     * @param clzz  输出集合类型
     * @param <E>   输入集合类型
     * @param <T>   输出集合类型
     * @return 返回集合
     */
    public static <E, T> List<T> mappingListSpringBeanUtils(List<E> input, Class<T> clzz) {
        List<T> output = new ArrayList<>();
        if (CollectionUtil.isEmpty(input)) {
            return output;
        }
        input.forEach(source -> {
            T target = BeanUtils.instantiateClass(clzz);
            BeanUtils.copyProperties(source, target);
            output.add(target);
        });
        return output;
    }
}

BeanMapperUtilsTest

package com.jerry.unit.bean;

import cn.hutool.core.bean.BeanUtil;
import org.apache.commons.beanutils.PropertyUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.util.StopWatch;

import java.lang.reflect.InvocationTargetException;

import static org.apache.commons.beanutils.BeanUtils.copyProperties;

/**
 * 对象属性拷贝工具测试类
 * 1、Spring BeanUtils：效率其次
 * 2、Cglib BeanCopier：效率最高
 * 3、Apache BeanUtils：效率低,原因Apache BeanUtils力求做的完美，做了很多校验，兼容，日志打印等导致性能下降。
 * 4、Apache PropertyUtils：效率低
 * 5、Dozer
 * 使用场景：DO,DTO,VO,PO,BO等场景装换的时候通过对象属性拷贝提高开发效率，简化代码，
 * 但是同时也带来了隐藏拷贝了那些属性，没有直接转换更为直接，按需使用吧
 *
 * @author zrj
 * @since 2022/3/26
 **/
public class BeanMapperUtilsTest {
    public static void main(String[] args) throws Exception {
        //构建对象
        PersonDO personDO = PersonDO.builder().id(20220326).name("jerry").age(6).build();

        BeanMapperUtilsTest mapperTest = new BeanMapperUtilsTest();

        System.out.println("------mappingBySelf-------");
        mapperTest.mappingBySelf(personDO, 100);
        mapperTest.mappingBySelf(personDO, 1000);
        mapperTest.mappingBySelf(personDO, 10000);
        mapperTest.mappingBySelf(personDO, 100000);
        mapperTest.mappingBySelf(personDO, 1000000);

        System.out.println("------mappingBeanByHutoolBeanUtil-------");
        mapperTest.mappingBeanByHutoolBeanUtil(personDO, 100);
        mapperTest.mappingBeanByHutoolBeanUtil(personDO, 1000);
        mapperTest.mappingBeanByHutoolBeanUtil(personDO, 10000);
        mapperTest.mappingBeanByHutoolBeanUtil(personDO, 100000);
        mapperTest.mappingBeanByHutoolBeanUtil(personDO, 1000000);

        System.out.println("------mappingBySpringBeanUtils-------");
        mapperTest.mappingBySpringBeanUtils(personDO, 100);
        mapperTest.mappingBySpringBeanUtils(personDO, 1000);
        mapperTest.mappingBySpringBeanUtils(personDO, 10000);
        mapperTest.mappingBySpringBeanUtils(personDO, 100000);
        mapperTest.mappingBySpringBeanUtils(personDO, 1000000);

        System.out.println("------mappingByCglibBeanCopier-------");
        mapperTest.mappingByCglibBeanCopier(personDO, 100);
        mapperTest.mappingByCglibBeanCopier(personDO, 1000);
        mapperTest.mappingByCglibBeanCopier(personDO, 10000);
        mapperTest.mappingByCglibBeanCopier(personDO, 100000);
        mapperTest.mappingByCglibBeanCopier(personDO, 1000000);

        System.out.println("------mappingByApachePropertyUtils-------");
        mapperTest.mappingByApachePropertyUtils(personDO, 100);
        mapperTest.mappingByApachePropertyUtils(personDO, 1000);
        mapperTest.mappingByApachePropertyUtils(personDO, 10000);
        mapperTest.mappingByApachePropertyUtils(personDO, 100000);
        mapperTest.mappingByApachePropertyUtils(personDO, 1000000);

        System.out.println("------mappingByApacheBeanUtils-------");
        mapperTest.mappingByApacheBeanUtils(personDO, 100);
        mapperTest.mappingByApacheBeanUtils(personDO, 1000);
        mapperTest.mappingByApacheBeanUtils(personDO, 10000);
        mapperTest.mappingByApacheBeanUtils(personDO, 100000);
        mapperTest.mappingByApacheBeanUtils(personDO, 1000000);
    }

    /**
     * 手动进行属性拷贝
     */
    private void mappingBySelf(PersonDO personDO, int times) {
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();

        for (int i = 0; i < times; i++) {
            PersonDTO personDTO = new PersonDTO();
            personDTO.setName(personDO.getName());
            personDTO.setAge(personDO.getAge());
        }

        stopwatch.stop();
        System.out.println("mappingBySelf cost " + times + " :" + stopwatch.getTotalTimeMillis());
    }

    /**
     * 手动进行属性拷贝
     */
    private void mappingBeanByHutoolBeanUtil(PersonDO personDO, int times) {
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();

        for (int i = 0; i < times; i++) {
            PersonDTO personDTO = new PersonDTO();
            BeanUtil.copyProperties(personDO, personDTO, false);
        }

        stopwatch.stop();
        System.out.println("mappingBeanByHutoolBeanUtil cost " + times + " :" + stopwatch.getTotalTimeMillis());
    }

    /**
     * Spring BeanUtils进行属性拷贝
     */
    private void mappingBySpringBeanUtils(PersonDO personDO, int times) {
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();

        for (int i = 0; i < times; i++) {
            PersonDTO personDTO = new PersonDTO();
            BeanUtils.copyProperties(personDO, personDTO);
        }

        stopwatch.stop();
        System.out.println("mappingBySpringBeanUtils cost " + times + " :" + stopwatch.getTotalTimeMillis());
    }

    /**
     * Cglib BeanCopier进行属性拷贝
     */
    private void mappingByCglibBeanCopier(PersonDO personDO, int times) {
        StopWatch stopwatch = new StopWatch();

        stopwatch.start();

        for (int i = 0; i < times; i++) {
            PersonDTO personDTO = new PersonDTO();
            BeanCopier copier = BeanCopier.create(PersonDO.class, PersonDTO.class, false);
            copier.copy(personDO, personDTO, null);
        }

        stopwatch.stop();

        System.out.println("mappingByCglibBeanCopier cost " + times + " :" + stopwatch.getTotalTimeMillis());
    }

    /**
     * Apache BeanUtils进行属性拷贝
     */
    private void mappingByApacheBeanUtils(PersonDO personDO, int times)
            throws InvocationTargetException, IllegalAccessException {
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();
        for (int i = 0; i < times; i++) {
            PersonDTO personDTO = new PersonDTO();
            copyProperties(personDTO, personDO);
        }
        stopwatch.stop();
        System.out.println("mappingByApacheBeanUtils cost " + times + " :" + stopwatch.getTotalTimeMillis());
    }

    /**
     * Apache PropertyUtils进行属性拷贝
     * 无人问津
     */
    private void mappingByApachePropertyUtils(PersonDO personDO, int times)
            throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();
        for (int i = 0; i < times; i++) {
            PersonDTO personDTO = new PersonDTO();
            PropertyUtils.copyProperties(personDTO, personDO);
        }
        stopwatch.stop();
        System.out.println("mappingByApachePropertyUtils cost " + times + " :" + stopwatch.getTotalTimeMillis());
    }
}

PersonDO & PersonDTO

/**
 * 人员数据对象
 *
 * @author zrj
 * @since 2022/3/26
 **/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PersonDO {
    private Integer id;
    private String name;
    private Integer age;
}

/**
 * 人员传输对象
 *
 * @author zrj
 * @since 2022/3/26
 **/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PersonDTO {
    private String name;
    private Integer age;
}
靖节先生
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 对象复制工具_五种对象属性拷贝工具类大全 Bean的属性拷贝从此不用愁
weixin_36382556的博客
02-21 2084
1.引言大家在做java开发时，肯定会遇到api层参数对象传递给服务层，或者把service层的对象传递给dao层，他们之间又不是同一个类型对象，但字段又是一样，如果还是用普通的get、set方式来处理话，比较繁琐，.... 那么来跟我学....."天下武功，唯快不破"....突突突--biubiu---2.大全套餐使用get/set不用说了,字段一多脑壳大....使用了cglib的修改字节码,真...
反射拷贝属性
05-25
在Java编程语言中，"反射拷贝属性"是一种利用反射机制来复制对象属性的技术。反射是Java提供的一种强大工具，允许程序在运行时检查和操作类、接口、字段和方法等对象。通过反射，我们可以动态地获取类的信息并操作类...
Java的属性拷贝工具类
Gamble6
11-13 2274
BeanUtils.copyProperties的使用场景：DO、DTO、VO之间的转换 BeanUtils.copyProperties的避坑 BeanUtils的替代工具类——Mapstruct
相同元素的实体类对象拷贝、list集合拷贝
最新发布
zxxCSDN_的博客
06-04 660
目录1.实体类对象拷贝1.1 将一个对象的相同属性值拷贝给另一个对象（一般情况：全拷贝）；1.2 属性值为null不复制，保留原有值；1.3 元素命名不同，存储的是相同值；1.3.1 属性名大小写不同：忽略大小写拷贝。1.3.2 属性名拼写不同：配置拷贝字段映射选项。1.4 实体类的属性名相同，但是数据类型不同；1.4.1 解决方案1：使用 ignoreProperties。1.4.2 解决方案2：使用 CopyOptions 对象。2.List集合copy主要用到 hutool工具的BeanUtil依赖：
List＜Object＞集合对象属性拷贝工具类
weixin_42585386的博客
03-01 860
但当遇到一个对象含有多个属性时，如果使用每个属性对应的set方法来赋值，就显得代码很冗长，也比较浪费时间。该工具类有个很强大的方法就可以用于拷贝对象属性值到另一个对象中去，而且这两个对象不需要数据类型相同，只要两个对象存在相同属性/字段名即可实现拷贝，非常方便；于是打算写个通用工具类来实现适配各种数据类型的List集合对象属性拷贝的功能。因此，我打算写个通用的工具类来代替这些代码，这样使用起来就会很方便了！可以看到也很顺利的实现了List集合对象间元素属性拷贝的功能。
java 对象复制工具类_Java常用属性拷贝工具类使用总结
weixin_30831261的博客
02-13 482
开头聊几句1、网上很多的技术文章和资料是有问题的，要学会辨证的看待，不能随便就拿来用，起码要自己验证一下2、关注当下，关注此刻，如果你真正阅读本篇文章，请花几分钟时间的注意力阅读，相信你会有收获的3、文中代码没有使用图片展示，可能存在阅读排版错乱问题，请见谅，因为可能考虑到有其他伙伴需要拷贝代码，这样比较方便Java常用属性拷贝工具类使用总结对项目中经常使用的属性拷贝工具类进行总结：org.apa...
Java常用属性拷贝工具类使用总结
香农三定律的博客
03-28 1447
Java常用属性拷贝工具类使用总结引言字段与属性使用说明原理剖析 引言 对项目中经常使用的属性拷贝工具类进行总结： org.apache.commons.beanutils.BeanUtils org.apache.commons.beanutils.PropertyUtils org.springframework.beans.BeanUtils 字段与属性 public class UserTest{ private String userName; private String p
Java的属性拷贝工具类---Mapstruct
GeGe&YoYo的博客
11-14 477
Mapstruct正是在java文件到class这一步帮我们实现了转换方法，即做了预处理，提前编译好文件，如果用过lombok的同学一定能理解其好处，通过查看class文件，可以看出IPersonMapper被打上org.mapstruct.Mapper注解后，编译器自动会帮我们生成一个实现类IPersonMapperImpl，并实现了po2entity这个方法。接口中有一个常量和一个方法，常量的值是接口的实现类，这个实现类是Mapstruct默认帮我们实现的，下文会讲到。
java拷贝对象属性的几种方式对比
不积跬步无以至千里，不积小流无以成江河
12-10 2755
常用的对象属性的拷贝方式有很多，就随便说几个： spring 的 BeanUtils.copyproperties()  原理：反射 apache的 BeanUtils.copyproperties() String的 BeanUtils.copyproperties() PropertyUtils.copyproperties() BeanCopier.create(）原理：cgli...
java 文件拷贝保留原来的属性_Java常用属性拷贝工具类使用总结
weixin_29189377的博客
02-24 454
开头聊几句1、网上很多的技术文章和资料是有问题的，要学会辨证的看待，不能随便就拿来用，起码要自己验证一下2、关注当下，关注此刻，如果你真正阅读本篇文章，请花几分钟时间的注意力阅读，相信你会有收获的3、文中代码没有使用图片展示，可能存在阅读排版错乱问题，请见谅，因为可能考虑到有其他伙伴需要拷贝代码，这样比较方便Java常用属性拷贝工具类使用总结对项目中经常使用的属性拷贝工具类进行总结：org.apa...
java 属性拷贝_你还在用BeanUtils进行对象属性拷贝？
weixin_28799111的博客
02-12 746
在做业务的时候，为了隔离变化，我们会将DAO查询出来的DO和对前端提供的DTO隔离开来。大概90%的时候，它们的结构都是类似的；但是我们很不喜欢写很多冗长的b.setF1(a.getF1())这样的代码，于是我们需要简化对象拷贝方式。大多时候时候使用的是Apache或Spring`BeanUtils，今天，我们来看一下一个更高效的属性拷贝方式：BeanCopier`。一、背景1.1 对象拷贝概念J...
Java常用工具类，多年工作积累整理
03-31
1. **`java.util.Arrays`**：这是一个非常基础且重要的工具类，提供了对数组进行操作的各种静态方法，如排序、复制、填充、比较等。例如，`Arrays.sort()`用于对数组进行升序或降序排序，`Arrays.copyOf()`则用于...
Java常用工具包 Jodd
05-15
6. **反射和枚举操作**：Jodd的反射工具可以帮助开发者在运行时检查和修改对象的属性，而其枚举工具则提供了对Java枚举类型更丰富的操作，如遍历、比较和转换。 7. **线程安全**：Jodd提供了一些线程安全的数据结构...
28个java常用的工具类
10-27
14. **对象拷贝工具类**：如`BeanUtils`，提供了对象属性的复制功能，`copyProperties()`可以将源对象的属性复制到目标对象。 15. **安全加密工具类**：如`SecurityUtils`，包含了加密和解密方法，如`md5Encode()`...
Jmeter压测工具详解
热门推荐
靖节先生的博客
08-24 2万+
Apache JMetier是Apache组织开发的基于Java的压力测试工具。一款非常优秀的开源的性能测试工具。
Java操作MongoDB详解
靖节先生的博客
03-29 2万+
MongoDB详解1. MongoDB概述1.1 MongoDB简介1.2 MongoDB概念2. MongoDB安装2.1 MongoDB下载3. MongoDB操作4. MongoDB客户端工具5. MongoDB Java操作6. MongoDB集成SpringBoot 1. MongoDB概述 1.1 MongoDB简介 什么是MongoDB ? MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。 mongodb官网地址：https://www.mongodb.org.
Netty详解（持续更新中）
靖节先生的博客
12-20 1万+
Netty详解1. Netty概述1.1 Netty简介1.2 原生NIO问题1.3 Netty特点1.4 Netty应用场景1.3 Netty版本说明2. Java IO模型2.1 IO模型2.2 BIO,NIO,AIO适用场景3. Java BIO3.1 Java BIO 基本说明3.2 Java BIO 工作机制3.3 Java BIO 问题分析4. Java NIO4.1 Java NIO 基本说明4.2 NIO 和 BIO 的比较4.3 NIO 核心组件4.4 Selector（选择器）4.5 C
工作流引擎Activiti详解
靖节先生的博客
11-15 1万+
工作流引擎Activiti1. 什么是工作流1.1 工作流介绍1.2 工作流系统1.3 工作流实现方式1.4 工作流实现原理2. Activiti7概述2.1 Activiti介绍2.2 Activiti使用3. Activiti环境配置3.1 创建数据库3.2 初始化数据库表：3.3 创建数据库表3.4 数据库表命名规则4. Activiti架构简介5. Activiti入门案例5.1 流程定义5.2 部署流程5.3 启动流程5.4 流程定义查询5.5 流程定义删除5.6 流程定义资源查询 1. 什么是工
java不同类型的对象如何拷贝属性值
06-13
Java中不同类型的对象拷贝...4. 使用MapStruct库：MapStruct是一个Java Bean映射框架，可以通过注解和接口定义来生成类型安全的属性拷贝代码。与Dozer相比，MapStruct的运行效率更高，但需要开发者自行编写映射接口。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值