为您推荐:
精华内容
最热下载
问答
  • 对象拷贝基础知识: Java中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括int、double、byte、boolean、char等简单数据类型,引用类型包括类、接口、数组等复杂类型。 对象拷贝分为浅拷贝(浅克隆)与...

    对象拷贝基础知识:

    Java中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括intdoublebytebooleanchar等简单数据类型,引用类型包括类、接口、数组等复杂类型。

    对象拷贝分为浅拷贝(浅克隆)深拷贝(深克隆)

    • 浅拷贝与深拷贝差异
    分类浅拷贝深拷贝
    区别创建一个新对象,然后将当前对象的非静态字段复制到该新对象,如果字段是值类型的,那么对该字段执行复制;如果该字段是引用类型的话,则复制引用但不复制引用的对象。因此,原始对象及其副本引用同一个对象。创建一个新对象,然后将当前对象的非静态字段复制到该新对象,无论该字段是值类型的还是引用类型,都复制独立的一份。当你修改其中一个对象的任何内容时,都不会影响另一个对象的内容。

    为什么需要对象拷贝: 

    1. Entity对应的是持久层数据结构(一般是数据库表的映射模型);
    2. Model 对应的是业务层的数据结构;
    3. VO 就是Controller和客户端交互的数据结构。

    例如:数据库查询出来的用户信息(表的映射模型)是UserDO,但是我们需要传递给客户端的是UserVO,这时候就需要把UserDO实例的属性一个一个赋值到UserVO实例中。

    对象拷贝工具类 :

    1. org.springframework.beans.BeanUtils ;
    2. org.springframework.cglib.beans.BeanCopier
    3. ma.glasnost.orika
    4. org.mapstruct强烈推荐

    二、BeanUtils

    Spring中的BeanUtils,其中实现的方式很简单,就是对两个对象中相同名字的属性进行简单get/set,仅检查属性的可访问性。

    可以看到, 成员变量赋值是基于目标对象的成员列表, 并且会跳过ignore的以及在源对象中不存在的, 所以这个方法是安全的, 不会因为两个对象之间的结构差异导致错误, 但是必须保证同名的两个成员变量类型相同。

    2.1、单个对象拷贝

    我们把数据库查询出来的UserDO.java 拷贝到 UserVO.java。直接使用BeanUtils.copyProperties()方法。

    @Test
    public void commonCopy() {
        UserDO userDO = new UserDO(1L, "Van", 18, 1);
        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(userDO, userVO);
        log.info("userVO:{}",userVO);
    }
    
    • 拷贝结果:
    .... userVO:UserVO(userId=1, userName=Van, age=18, sex=null)
    

    2.2、集合拷贝

    刚刚拷贝的是一个对象,但是有时候我们想拷贝一组UerDO.java,是一个集合的时候就不能这样直接赋值了。如果还按照这种逻辑,如下:

    @Test
    public void listCopyFalse() {
        List<UserDO> userDOList = new ArrayList();
        userDOList.add(new UserDO(1L, "Van", 18, 1));
        userDOList.add(new UserDO(2L, "VanVan", 18, 2));
        List<UserVO> userVOList = new ArrayList();
        BeanUtils.copyProperties(userDOList, userVOList);
        log.info("userVOList:{}",userVOList);
    }
    
    • 拷贝结果:
    .... userVOList:[]
    

    通过日志可以发现,直接拷贝集合是无效的,那么怎么解决呢?

    2.3 暴力拷贝(不推荐)

    将需要拷贝的集合遍历,暴力拷贝。

    @Test
    public void listCopyCommon() {
        List<UserDO> userDOList = new ArrayList();
        userDOList.add(new UserDO(1L, "Van", 18, 1));
        userDOList.add(new UserDO(2L, "VanVan", 20, 2));
        List<UserVO> userVOList = new ArrayList();
        userDOList.forEach(userDO ->{
            UserVO userVO = new UserVO();
            BeanUtils.copyProperties(userDO, userVO);
            userVOList.add(userVO);
        });
        log.info("userVOList:{}",userVOList);
    }
    
    • 拷贝结果:
    .... userVOList:[UserVO(userId=1, userName=Van, age=18, sex=null), UserVO(userId=2, userName=VanVan, age=20, sex=null)]
    

    虽然该方式可以解决,但是一点都不优雅,特别是写起来麻烦。

    2.4 优雅拷贝(本文推荐

    通过JDK 8 的函数式接口封装org.springframework.beans.BeanUtils

    • 定义一个函数式接口

    函数式接口里是可以包含默认方法,这里我们定义默认回调方法。

    @FunctionalInterface
    public interface BeanUtilCopyCallBack <S, T> {
    
        /**
         * 定义默认回调方法
         * @param t
         * @param s
         */
        void callBack(S t, T s);
    }
    
    • 封装一个工具类 BeanUtilCopy.java
    public class BeanUtilCopy extends BeanUtils {
    
        /**
         * 集合数据的拷贝
         * @param sources: 数据源类
         * @param target: 目标类::new(eg: UserVO::new)
         * @return
         */
        public static <S, T> List<T> copyListProperties(List<S> sources, Supplier<T> target) {
            return copyListProperties(sources, target, null);
        }
    
    
        /**
         * 带回调函数的集合数据的拷贝(可自定义字段拷贝规则)
         * @param sources: 数据源类
         * @param target: 目标类::new(eg: UserVO::new)
         * @param callBack: 回调函数
         * @return
         */
        public static <S, T> List<T> copyListProperties(List<S> sources, Supplier<T> target, BeanUtilCopyCallBack<S, T> callBack) {
            List<T> list = new ArrayList<>(sources.size());
            for (S source : sources) {
                T t = target.get();
                copyProperties(source, t);
                list.add(t);
                if (callBack != null) {
                    // 回调
                    callBack.callBack(source, t);
                }
            }
            return list;
        }
    
    }
    
    • 简单拷贝测试
     @Test
    public void listCopyUp() {
        List<UserDO> userDOList = new ArrayList();
        userDOList.add(new UserDO(1L, "Van", 18, 1));
        userDOList.add(new UserDO(2L, "VanVan", 20, 2));
        List<UserVO> userVOList = BeanUtilCopy.copyListProperties(userDOList, UserVO::new);
        log.info("userVOList:{}",userVOList);
    }
    
    • 拷贝结果:
    .... userVOList:[UserVO(userId=1, userName=Van, age=18, sex=null), UserVO(userId=2, userName=VanVan, age=20, sex=null)]
    

    通过如上方法,我们基本实现了集合的拷贝,但是从返回结果我们可以发现:属性不同的字段无法拷贝

    注意:
    UserDO.java 和UserVO.java 最后一个字段sex类型不一样,分别是:Integer/String

    优化一下

    • 新增性别枚举类
    public enum SexEnum {
        UNKNOW("未设置",0),
        MEN("男生", 1),
        WOMAN("女生",2),
    
        ;
        private String desc;
        private int code;
    
        SexEnum(String desc, int code) {
            this.desc = desc;
            this.code = code;
        }
    
        public static SexEnum getDescByCode(int code) {
            SexEnum[] typeEnums = values();
            for (SexEnum value : typeEnums) {
                if (code == value.getCode()) {
                    return value;
                }
            }
            return null;
        }
    
        public String getDesc() {
            return desc;
        }
    
        public void setDesc(String desc) {
            this.desc = desc;
        }
    
        public int getCode() {
            return code;
        }
    
        public void setCode(int code) {
            this.code = code;
        }
    }
    
    • 带特定转换的集合拷贝
    @Test
    public void listCopyUpWithCallback() {
        List<UserDO> userDOList = new ArrayList();
        userDOList.add(new UserDO(1L, "Van", 18, 1));
        userDOList.add(new UserDO(2L, "VanVan", 20, 2));
        List<UserVO> userVOList = BeanUtilCopy.copyListProperties(userDOList, UserVO::new, (userDO, userVO) -> {
            // 这里可以定义特定的转换规则
            userVO.setSex(SexEnum.getDescByCode(userDO.getSex()).getDesc());
        });
        log.info("userVOList:{}",userVOList);
    }
    
    • 拷贝结果:
    ... userVOList:[UserVO(userId=1, userName=Van, age=18, sex=男生), UserVO(userId=2, userName=VanVan, age=20, sex=女生)]
    

    通过打印结果可以发现,UserDO.java 中Integer类型的sex复制到UserVO.java成了String类型的男生/女生。

    2.5 小结

    该方法是我们用的最多的方案,这里简单封装下,可以方便集合类型对象的拷贝,平常使用基本够用,仅供参考。

    三、BeanCopier

    BeanCopier是用于在两个bean之间进行属性拷贝的。BeanCopier支持两种方式:

    1. 一种是不使用Converter的方式,仅对两个bean间属性名和类型完全相同的变量进行拷贝;
    2. 另一种则引入Converter,可以对某些特定属性值进行特殊操作。

    3.1 常规使用

    @Test
    public void normalCopy() {
        // 模拟查询出数据
        UserDO userDO = DataUtil.createData();
        log.info("拷贝前:userDO:{}", userDO);
        // 第一个参数:源对象, 第二个参数:目标对象,第三个参数:是否使用自定义转换器(下面会介绍),下同
        BeanCopier b = BeanCopier.create(UserDO.class, UserDTO.class, false);
        UserDTO userDTO = new UserDTO();
        b.copy(userDO, userDTO, null);
        log.info("拷贝后:userDTO:{}", userDTO);
    }
    
    • 拷贝结果:
    ...... 拷贝前:userDO:UserDO(id=1, userName=Van, sex=0, gmtBroth=2019-11-02T18:24:24.077, balance=100)
    ...... 拷贝后:userDTO:UserDTO(id=1, userName=Van, sex=null)
    

    通过结果发现:UserDOint类型的sex无法拷贝到UserDTOIntegersex

    即:BeanCopier只拷贝名称和类型都相同的属性。

    即使源类型是原始类型(intshortchar等),目标类型是其包装类型(IntegerShortCharacter等),或反之:都不会被拷贝。

    3.2 自定义转换器

    通过3.1可知,当源和目标类的属性类型不同时,不能拷贝该属性,此时我们可以通过实现Converter接口来自定义转换器

    • 目标对象属性类
    @Data
    public class UserDomain {
        private Integer id;
        private String userName;
        
        /**
         * 以下两个字段用户模拟自定义转换
         */
        private String gmtBroth;
        private String balance;
    }
    
    • 实现Converter接口来自定义属性转换
    public  class UserDomainConverter implements Converter {
    
        /**
         * 时间转换的格式
         */
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    
        /**
         * 自定义属性转换
         * @param value 源对象属性类
         * @param target 目标对象里属性对应set方法名,eg.setId
         * @param context 目标对象属性类
         * @return
         */
        @Override
        public Object convert(Object value, Class target, Object context) {
            if (value instanceof Integer) {
                return value;
            } else if (value instanceof LocalDateTime) {
                LocalDateTime date = (LocalDateTime) value;
                return dtf.format(date);
            } else if (value instanceof BigDecimal) {
                BigDecimal bd = (BigDecimal) value;
                return bd.toPlainString();
            }
            // 更多类型转换请自定义
            return value;
        }
    }
    
    • 测试方法
    /**
     * 类型不同,使用Converter
     */
    @Test
    public void converterTest() {
        // 模拟查询出数据
        UserDO userDO = DataUtil.createData();
        log.info("拷贝前:userDO:{}", userDO);
        BeanCopier copier = BeanCopier.create(UserDO.class, UserDomain.class, true);
        UserDomainConverter converter = new UserDomainConverter();
        UserDomain userDomain = new UserDomain();
        copier.copy(userDO, userDomain, converter);
        log.info("拷贝后:userDomain:{}", userDomain);
    }
    
    • 拷贝结果:
    ...... 拷贝前:userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T19:51:11.985, balance=100)
    ...... 拷贝后:userDomain:UserDomain(id=1, userName=Van, gmtBroth=2019-11-02 19:51:11, balance=100)
    
    • 注意
    1. 一旦使用ConverterBeanCopier只使用Converter定义的规则去拷贝属性,所以在convert()方法中要考虑所有的属性;
    2. 毫无疑问,使用Converter会使对象拷贝速度变慢。

    3.3 缓存BeanCopier实例提升性能

    BeanCopier拷贝速度快,性能瓶颈出现在创建BeanCopier实例的过程中。 所以,把创建过的BeanCopier实例放到缓存中,下次可以直接获取,提升性能。

    • 测试代码
    @Test
    public void beanCopierWithCache() {
    
        List<UserDO> userDOList = DataUtil.createDataList(10000);
        long start = System.currentTimeMillis();
        List<UserDTO> userDTOS = new ArrayList<>();
        userDOList.forEach(userDO -> {
            UserDTO userDTO = new UserDTO();
            copy(userDO, userDTO);
            userDTOS.add(userDTO);
        });
    }
    
    /**
     * 缓存 BeanCopier
     */
    private static final ConcurrentHashMap<String, BeanCopier> BEAN_COPIERS = new ConcurrentHashMap<>();
    
    public void copy(Object srcObj, Object destObj) {
        String key = genKey(srcObj.getClass(), destObj.getClass());
        BeanCopier copier = null;
        if (!BEAN_COPIERS.containsKey(key)) {
            copier = BeanCopier.create(srcObj.getClass(), destObj.getClass(), false);
            BEAN_COPIERS.put(key, copier);
        } else {
            copier = BEAN_COPIERS.get(key);
        }
        copier.copy(srcObj, destObj, null);
    
    }
    private String genKey(Class<?> srcClazz, Class<?> destClazz) {
        return srcClazz.getName() + destClazz.getName();
    }
    

    3.3 BeanCopier总结

    1. 当源类和目标类的属性名称、类型都相同,拷贝没问题。
    2. 当源对象和目标对象的属性名称相同、类型不同,那么名称相同而类型不同的属性不会被拷贝。注意,原始类型(intshortchar)和 他们的包装类型,在这里都被当成了不同类型,因此不会被拷贝。
    3. 源类或目标类的settergetter少,拷贝没问题,此时setter多余,但是不会报错。
    4. 源类和目标类有相同的属性(两者的getter都存在),但是目标类的setter不存在,此时会抛出NullPointerException
    5. 加缓存可以提升拷贝速度。

    四、Orika

    Orika 是 Java Bean 映射框架,可以实现从一个对象递归拷贝数据至另一个对象。它的优点是:名字相同类型不同也能直接复制。

    4.1 所需依赖

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

    4.2 映射工具类

    使用枚举实现的单例模式创建一个映射工具类,便于测试。

    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 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 ExceptionInInitializerError("映射集合,数据集合为空"));
            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;
        }
    }
    
    • 这个工具类中主要有四个方法:
    1. map(Class toClass, T data):普通的映射实体,主要映射名称相同(类型可以不同)的字段;

    2. map(Class toClass, T data, Map<String, String> configMap):自定义配置的映射,映射名称不同时,自定义映射对应名称;

    3. mapAsList(Class toClass, Collection data):普通的集合的映射;

    4. mapAsList(Class toClass, Collection data, Map<String, String> configMap):自定义的集合映射,自定义映射对应名称。

    4.3 简单测试

    • 拷贝名称相同类型可不同的属性
    @Test
    public void normalCopy() {
        // 模拟查询出数据
        UserDO userDO = DataUtil.createData();
        log.info("拷贝前:userDO:{}", userDO);
        // 第一个参数:源对象, 第二个参数:目标对象,第三个参数:是否使用自定义转换器(下面会介绍),下同
        UserDTO userDTO = MapperUtils.INSTANCE.map(UserDTO.class, userDO);;
        log.info("拷贝后:userDTO:{}", userDTO);
    }
    
    • 字段名称不同,带翻译
    @Test
    public void converterTest() {
        // 模拟查询出数据
        UserDO userDO = DataUtil.createData();
        Map<String, String> config = new HashMap<>();
        // 自定义配置(balance 转 balances)
        config.put("balance", "balances");
        log.info("拷贝前:userDO:{}", userDO);
        UserDomain userDomain = MapperUtils.INSTANCE.map(UserDomain.class, userDO, config);
        log.info("拷贝后:userDomain:{}", userDomain);
    }
    
    • 拷贝集合
    @Test
    public void beanCopierWithCache() {
        List<UserDO> userDOList = DataUtil.createDataList(3);
        log.info("拷贝前:userDOList:{}", userDOList);
        List<UserDTO> userDTOS = MapperUtils.INSTANCE.mapAsList(UserDTO.class,userDOList);
        log.info("拷贝后:userDTOS:{}", userDTOS);
    }
    

    五、MapStruct

    MapStruct 是一个自动生成 bean 映射类的代码生成器MapStruct 还能够在不同的数据类型之间进行转换。

    5.1 所需依赖

    • mapstruct-jdk8

    包含所需的注释,例如@Mapping

    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-jdk8</artifactId>
        <version>1.3.0.Final</version>
    </dependency>
    
    • mapstruct-processor

    在编译,生成映射器实现的注释处理器。

    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-processor</artifactId>
        <version>1.3.0.Final</version>
        <scope>provided</scope>
    </dependency>
    

    5.2 如何使用?

    您所要做的就是定义一个mapper接口,该接口声明任何所需的映射方法。在编译期间,MapStruct将生成此接口的实现。此实现使用普通的Java方法调用来在源对象和目标对象之间进行映射。

    • 创建Mapper

    利用@Mapper注解标注该接口/抽象类是被MapStruct自动映射的,只有存在该注解才会将内部的接口方法自动实现。

    • 获取Mapper

    MapStruct为我们提供了多种的获取Mapper的方式,习惯用默认配置:采用Mappers通过动态工厂内部反射机制完成Mapper实现类的获取。

    UserConvertUtils INSTANCE = Mappers.getMapper(UserConvertUtils.class);
    

    完整的一个转换器demo:

    @Mapper
    public interface UserConvertUtils {
    
        UserConvertUtils INSTANCE = Mappers.getMapper(UserConvertUtils.class);
    
        /**
         * 普通的映射
         *
         * @param userDO UserDO数据持久层类
         * @return 数据传输类
         */
        UserDTO doToDTO(UserDO userDO);
    
        /**
         * 类型转换的映射
         *
         * @param userDO UserDO数据持久层类
         * @return 数据传输类
         */
        @Mappings({
                @Mapping(target = "gmtBroth", source = "gmtBroth", dateFormat = "yyyy-MM-dd HH:mm:ss"),
                @Mapping(target = "balances", source = "balance"),
        })
        UserDTO doToDtoWithConvert(UserDO userDO);
    }
    
    • 测试
    /**
     * 一般拷贝
     */
    @Test
    public void normalCopy() {
        // 模拟查询出数据
        UserDO userDO = DataUtil.createData();
        log.info("拷贝前:userDO:{}", userDO);
        UserDTO userDTO = UserConvertUtils.INSTANCE.doToDTO(userDO);
        log.info("拷贝后:userDTO:{}", userDTO);
    }
    /**
     * 包含类型转换的拷贝
     */
    @Test
    public void doToDtoWithConvert() {
        // 模拟查询出数据
        UserDO userDO = DataUtil.createData();
        log.info("拷贝前:userDO:{}", userDO);
        UserDTO userDTO = UserConvertUtils.INSTANCE.doToDtoWithConvert(userDO);
        log.info("拷贝后:userDTO:{}", userDTO);
    }
    
    • 打印映射结果
    一般拷贝:
    ...拷贝前:userDO:UserDO(id=1, userName=Van, gmtBroth=2020-04-21T21:38:39.376, balance=100)
    ...拷贝后:userDTO:UserDTO(id=1, userName=Van, gmtBroth=2020-04-21T21:38:39.376, balances=null)
    包含类型转换的拷贝:
    ...拷贝前:userDO:UserDO(id=1, userName=Van, gmtBroth=2020-04-21T21:05:19.282, balance=100)
    ...拷贝后:userDTO:UserDTO(id=1, userName=Van, gmtBroth=2020-04-21 21:05:19, balances=100)
    

    通过打印结果可以发现:相较于前者,包含类型转换的拷贝可以自定义转换属性和时间格式等。

    5.3 MapStruct 注解的关键词

    1. @Mapper:只有在接口加上这个注解, MapStruct 才会去实现该接口;
    2. @Mappings:配置多个@Mapping
    3. @Mapping:属性映射,若源对象属性与目标对象名字一致,会自动映射对应属性:
     
    1. source:源属性;
    2. target:目标属性;
    3. dateFormat:字符串与日期之间相互转换;
    4. ignore: 忽略这个,某个属性不想映射,可以加个 ignore=true

    5.4 多对一

    MapStruct 可以将几种类型的对象映射为另外一种类型,比如将多个 DO 对象转换为 DTO

    详见:

    UserDTO doAndInfoToDto(UserDO userDO, UserInfoDO userInfoDO);
    

    5.5 为什么要用 MapStruct

    与手工编写映射代码相比,MapStruct通过生成繁琐且易于编写的代码来节省时间。遵循约定优于配置方法,MapStruct使用合理的默认值,但在配置或实现特殊行为时会采取措施。

    与动态映射框架相比,MapStruct具有以下优势:

    1. 通过使用普通方法调用而不是反射来快速执行
    2. 编译时类型安全:只能映射相互映射的对象和属性,不会将订单实体意外映射到客户DTO等。
    3. 在构建时清除错误报告,如果映射不完整(并非所有目标属性都已映射)映射不正确(找不到合适的映射方法或类型转换)
    展开全文
    zhouzhiwengang 2021-03-11 18:45:06
  • } 复制代码 还有很多属性拷贝的方法例如org.apache.commons.beanutils.BeanUtils的copyProperties(Object dest, Object src)这里不举例了 类似于Spring的属性拷贝 还有使用easymapper来进行对象映射,但在项目中...

    1.引言

    大家在做java开发时,肯定会遇到api层参数对象传递给服务层,

    或者把service层的对象传递给dao层,他们之间又不是同一个类型对象,

    但字段又是一样,如果还是用普通的get、set方式来处理话,比较繁琐,.... 那么来跟我学.....

    "天下武功,唯快不破"....突突突--biubiu---

    2.大全套餐

    equation?tex=%5Ccolor%7B%234285f4%7D%7B1.getter%2Fsetter%7D

    使用get/set不用说了,字段一多脑壳大....

    equation?tex=%5Ccolor%7B%234285f4%7D%7B2.BeanCopier%7D

    使用了cglib的修改字节码,真的是动态Read Writer getter/setter 快的一逼啊 源码过于简单 直接上代码 我使用的最基本的,大家可以自定义Converter,定以后完全按照Converter转换

    需要注意的是:

    1.当源类和目标类的属性名称、类型都相同,拷贝结果棒棒哒。

    2.当源对象和目标对象的属性名称相同、类型不同,那么名称相同而类型不同的属性不会被拷贝。另外注意,原始类型(int,short,char)和 他们的包装类型,在这里都被当成了不同类型。因此不会被拷贝。

    3.源类或目标类的setter比getter少,拷贝没问题,此时setter多余,但是不会报错。

    4.源类和目标类有相同的属性(两者的getter都存在),但是目标类的setter不存在, 此时会抛出NullPointerException(这个在高版本bug已经修改测试通过,我使用的49.0)

    上code

    import lombok.extern.slf4j.Slf4j;

    import org.springframework.cglib.beans.BeanCopier;

    import java.util.Map;

    import java.util.concurrent.ConcurrentHashMap;

    /**

    * @author LiJing

    * @ClassName: BeanCopyUtils

    * @Description: 基于BeanCopier的属性拷贝

    * @date 2019/4/17 9:15

    * 凡是和反射相关的操作,基本都是低性能的。凡是和字节码相关的操作,基本都是高性能的。

    *

    */

    @Slf4j

    public class BeanCopyUtils {

    /**

    * 创建过的BeanCopier实例放到缓存中,下次可以直接获取,提升性能

    */

    private static final Map BEAN_COPIERS = new ConcurrentHashMap<>();

    /**

    * 该方法没有自定义Converter,简单进行常规属性拷贝

    *

    * @param srcObj 源对象

    * @param destObj 目标对象

    */

    public static void copy(Object srcObj, Object destObj) {

    String key = genKey(srcObj.getClass(), destObj.getClass());

    BeanCopier copier;

    if (!BEAN_COPIERS.containsKey(key)) {

    copier = BeanCopier.create(srcObj.getClass(), destObj.getClass(), false);

    BEAN_COPIERS.put(key, copier);

    } else {

    copier = BEAN_COPIERS.get(key);

    }

    copier.copy(srcObj, destObj, null);

    }

    private static String genKey(Class> srcClazz, Class> destClazz) {

    return srcClazz.getName() + destClazz.getName();

    }

    }

    复制代码

    equation?tex=%5Ccolor%7B%234285f4%7D%7B3.spring.BeanUtils%7D

    这个org.springframework.beans.BeanUtils,这个比较骚,使用反射,反射就比较慢了,要加载字节码,反编译,再实例化,再映射属性.....来来上二斤代码,先吃着 有用的地方不多大家看着用哈,copyProperties其实有这个方法就够了,

    这个是把源码改造后的方法:

    import lombok.extern.slf4j.Slf4j;

    import org.springframework.beans.BeanUtils;

    import org.springframework.beans.BeansException;

    import org.springframework.beans.FatalBeanException;

    import org.springframework.util.Assert;

    import org.springframework.util.ClassUtils;

    import java.beans.PropertyDescriptor;

    import java.lang.reflect.Field;

    import java.lang.reflect.Method;

    import java.lang.reflect.Modifier;

    import java.math.BigDecimal;

    import java.sql.Timestamp;

    import java.util.Arrays;

    import java.util.Date;

    import java.util.List;

    /**

    * @author LiJing

    * @ClassName: MyBeanUtils

    * @Description: 属性拷贝工具类

    * @date 2018/4/10 11:54

    */

    @Slf4j

    public class MyBeanUtils extends BeanUtils {

    /**

    * 从org.springframework.beans.BeanUtils类中直接复制过来

    *

    * @param source

    * @param target

    * @throws BeansException

    */

    public static void copyProperties(Object source, Object target) throws BeansException {

    copyProperties(source, target, null, (String[]) null);

    }

    /**

    * 从org.springframework.beans.BeanUtils类中直接复制过来,修改部分代码,不为null才复制

    *

    * @param source

    * @param target

    * @param editable

    * @param ignoreProperties

    * @throws BeansException

    */

    private static void copyProperties(Object source, Object target, Class> editable, String... ignoreProperties)

    throws BeansException {

    Assert.notNull(source, "Source must not be null");

    Assert.notNull(target, "Target must not be null");

    Class> actualEditable = target.getClass();

    if (editable != null) {

    if (!editable.isInstance(target)) {

    throw new IllegalArgumentException("Target class [" + target.getClass().getName() +

    "] not assignable to Editable class [" + editable.getName() + "]");

    }

    actualEditable = editable;

    }

    PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);

    List ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;

    for (PropertyDescriptor targetPd : targetPds) {

    Method writeMethod = targetPd.getWriteMethod();

    if (writeMethod != null && (ignoreProperties == null || (!ignoreList.contains(targetPd.getName())))) {

    PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());

    if (sourcePd != null) {

    Method readMethod = sourcePd.getReadMethod();

    if (readMethod != null && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {

    try {

    if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {

    readMethod.setAccessible(true);

    }

    Object value = readMethod.invoke(source);

    // 判断被复制的属性是否为null, 如果不为null才复制

    if (value != null) {

    if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {

    writeMethod.setAccessible(true);

    }

    writeMethod.invoke(target, value);

    }

    } catch (Throwable ex) {

    throw new FatalBeanException(

    "不能拷贝属性 '" + targetPd.getName() + "' 从原对象给目标对象,详细原因见:", ex);

    }

    }

    }

    }

    }

    }

    /**

    * 构造函数.

    */

    public MyBeanUtils () {

    throw new RuntimeException("this is a util class,can not instance");

    }

    复制代码

    equation?tex=%5Ccolor%7B%234285f4%7D%7B4.apache.BeanUtils%7D

    还有很多属性拷贝的方法例如org.apache.commons.beanutils.BeanUtils的copyProperties(Object dest, Object src)这里不举例了 类似于Spring的属性拷贝

    equation?tex=%5Ccolor%7B%234285f4%7D%7B5.baidu.easymapper%7D

    还有使用easymapper来进行对象映射,但在项目中存在不稳性,偶尔出现映射不上的问题,会报异常com.baidu.unbiz.easymapper.exception.MappingException,大家可自行研究

    bean转map可以:

    /**

    * 将对象装换为map

    * @param bean

    * @return

    */

    public static Map beanToMap(T bean) {

    Map map = Maps.newHashMap();

    if (bean != null) {

    BeanMap beanMap = BeanMap.create(bean);

    for (Object key : beanMap.keySet()) {

    map.put(key+"", beanMap.get(key));

    }

    }

    return map;

    }

    复制代码

    3.小结

    其实有很多种方法进行属性拷贝的,例如dozer等等 下面看下测试性能吧:以:万级进行测试,我觉得Cglib太给力了.可以在遇到属性拷贝瓶颈时考虑.当然他们各有优点哈,功能也不尽相同.还需要多使用体会.

    输出结果:手动Copy > cglibCopy > springBeanUtils > apachePropertyUtils > apacheBeanUtils 可以理解为: 手工复制 > cglib > 反射 > Dozer。

    类型Framework

    测试性能(10000调用次)time

    Pure get/set

    10ms

    Cglib Beancopier

    14ms

    Easy mapper

    46ms

    Spring BeanUtils

    96ms

    Apache BeanUtils

    249ms

    Apache PropertieyUtils

    130ms

    Dozer

    770ms

    展开全文
    weixin_36382556 2021-03-06 22:27:02
  • 需求 有两个类,他们属性数据类型相同,但名字不同,如何数据的拷贝? 举例: 我们在Service层可能用到的是 UserDTO...但是如果需要拷贝对象的属性非常多,且有的属性是集合类型的,这种笨方法处理起来就非常的麻烦.

    需求

    有两个类,他们属性数据类型相同,但名字不同,如何数据的拷贝?

    举例:

    我们在Service层可能用到的是 UserDTO 类,而页面需要的是 UserVO,我们需要将这个 UserDTO 变成 UserVO 怎么做?

    笨方法:

    先 UserVO  vo = new UserVo(),然后调用 vo.setXXX(dto.getXXX()) 挨个往属性中赋值。

    这种方法在 属性少的情况下或许还没什么问题。但是如果需要拷贝对象的属性非常多,且有的属性是集合类型的,这种笨方法处理起来就非常的麻烦了

    实验案例

    定义2个类

    UserDTO 类

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class UserDTO {
    
        private String userName;
        private Integer userAge;
        private Integer weight;
    
    
    }

    UserVO类

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class UserVO {
    
        private String name;
        private Integer age;
        private Integer weight;
    
    }

    定义一个函数式接口

    @FunctionalInterface
    public interface BeanUtilCopyCallBack<S, T> {
    
        /**
         * 定义默认回调方法
         * @param t
         * @param s
         */
        void callBack(S t, T s);
    
    
    }

    定义属性拷贝的工具类

    public class BeanUtilCopy extends BeanUtils {
    
        /**
         * 集合数据的拷贝
         *
         * @param sources: 数据源类
         * @param target:  目标类::new(eg: UserVO::new)
         * @return
         */
        public static <S, T> List<T> copyListProperties(List<S> sources, Supplier<T> target) {
            return copyListProperties(sources, target, null);
        }
    
    
        /**
         * 带回调函数的集合数据的拷贝(可自定义字段拷贝规则)
         *
         * @param sources:  数据源类
         * @param target:   目标类::new(eg: UserVO::new)
         * @param callBack: 回调函数
         * @return
         */
        public static <S, T> List<T> copyListProperties(List<S> sources, Supplier<T> target, BeanUtilCopyCallBack<S, T> callBack) {
            List<T> list = new ArrayList<>(sources.size());
            for (S source : sources) {
                T t = target.get();
                copyProperties(source, t);
                list.add(t);
                if (callBack != null) {
                    // 回调
                    callBack.callBack(source, t);
                }
            }
            return list;
        }
    }

    编写测试用例

        @Test
        public void contextLoads(){
            List<UserDTO> userDTOList = new ArrayList();
            userDTOList.add(new UserDTO("zhangsan", 19, 200));
            userDTOList.add(new UserDTO("lisi", 20, 300));
            List<UserVO> userVOList = BeanUtilCopy.copyListProperties(userDTOList, UserVO::new, (userDTO, userVO) -> {
                userVO.setName(userDTO.getUserName());
                userVO.setAge(userDTO.getUserAge());
            });
            System.out.println(userVOList);
        }

    测试结果

     

    展开全文
    u010559460 2021-10-10 10:17:14
  • 在做业务的时候,为了隔离变化,我们会将DAO查询出来的DO和对前端提供的...大多时候时候使用的是Apache或Spring`BeanUtils,今天,我们来看一下一个更高效的属性拷贝方式:BeanCopier`。一、背景1.1 对象拷贝概念J...

    在做业务的时候,为了隔离变化,我们会将DAO查询出来的DO和对前端提供的DTO隔离开来。大概90%的时候,它们的结构都是类似的;但是我们很不喜欢写很多冗长的b.setF1(a.getF1())这样的代码,于是我们需要简化对象拷贝方式。

    大多时候时候使用的是Apache或Spring`BeanUtils,今天,我们来看一下一个更高效的属性拷贝方式:BeanCopier`。

    一、背景

    1.1 对象拷贝概念

    Java中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括int、double、byte、boolean、char等简单数据类型,引用类型包括类、接口、数组等复杂类型。

    对象拷贝分为浅拷贝(浅克隆)与深拷贝(深克隆)。

    浅拷贝与深拷贝差异

    分类

    浅拷贝

    深拷贝

    区别

    创建一个新对象,然后将当前对象的非静态字段复制到该新对象,如果字段是值类型的,那么对该字段执行复制;如果该字段是引用类型的话,则复制引用但不复制引用的对象。因此,原始对象及其副本引用同一个对象。

    创建一个新对象,然后将当前对象的非静态字段复制到该新对象,无论该字段是值类型的还是引用类型,都复制独立的一份。当你修改其中一个对象的任何内容时,都不会影响另一个对象的内容。

    1.2 示例前准备

    源对象属性类UserDO.class(以下示例,源对象都用这个)

    @Data

    public class UserDO {

    private int id;

    private String userName;

    /**

    * 以下两个字段用户模拟自定义转换

    */

    private LocalDateTime gmtBroth;

    private BigDecimal balance;

    public UserDO(Integer id, String userName, LocalDateTime gmtBroth, BigDecimal balance) {

    this.id = id;

    this.userName = userName;

    this.gmtBroth = gmtBroth;

    this.balance = balance;

    }

    }

    造数据工具类DataUtil.class

    public class DataUtil {

    /**

    * 模拟查询出一条数据

    * @return

    */

    public static UserDO createData() {

    return new UserDO(1, "Van", LocalDateTime.now(),new BigDecimal(100L));

    }

    /**

    * 模拟查询出多条数据

    * @param num 数量

    * @return

    */

    public static List createDataList(int num) {

    List userDOS = new ArrayList<>();

    for (int i = 0; i < num; i++) {

    UserDO userDO = new UserDO(i+1, "Van", LocalDateTime.now(),new BigDecimal(100L));

    userDOS.add(userDO);

    }

    return userDOS;

    }

    }

    二、对象拷贝之BeanUtils

    Apache和Spring均有BeanUtils工具类, Apache的BeanUtils稳定性与效率都不行;Spring的BeanUtils比较稳定,不会因为量大了,耗时明显增加,故一般都使用Spring的BeanUtils。

    2.1 源码解读

    Spring中的BeanUtils,其中实现的方式很简单,就是对两个对象中相同名字的属性进行简单get/set,仅检查属性的可访问性。

    可以看到, 成员变量赋值是基于目标对象的成员列表, 并且会跳过ignore的以及在源对象中不存在的, 所以这个方法是安全的, 不会因为两个对象之间的结构差异导致错误, 但是必须保证同名的两个成员变量类型相同。

    2.2 示例

    @Slf4j

    public class BeanUtilsDemo {

    public static void main(String[] args) {

    long start = System.currentTimeMillis();

    UserDO userDO = DataUtil.createData();

    log.info("拷贝前,userDO:{}", userDO);

    UserDTO userDTO = new UserDTO();

    BeanUtils.copyProperties(userDO,userDTO);

    log.info("拷贝后,userDO:{}", userDO);

    }

    }

    结果

    18:12:11.734 [main] INFO cn.van.parameter.bean.copy.demo.BeanUtilsDemo - 拷贝前,userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T18:12:11.730, balance=100)

    18:12:11.917 [main] INFO cn.van.parameter.bean.copy.demo.BeanUtilsDemo - 拷贝后,userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T18:12:11.730, balance=100)

    三、对象拷贝之BeanCopier

    BeanCopier是用于在两个bean之间进行属性拷贝的。BeanCopier支持两种方式:

    一种是不使用Converter的方式,仅对两个bean间属性名和类型完全相同的变量进行拷贝;

    另一种则引入Converter,可以对某些特定属性值进行特殊操作。

    3.1 基本使用

    依赖

    cglib

    cglib-nodep

    3.3.0

    注意:该依赖非必须,因为Spring中已经集成了cglib,博主使用的就是org.springframework.cglib.beans.BeanCopier。

    3.1.1 属性名称、类型都相同

    目标对象属性类

    @Data

    public class UserDTO {

    private int id;

    private String userName;

    }

    测试方法

    /**

    * 属性名称、类型都相同(部分属性不拷贝)

    */

    private static void normalCopy() {

    // 模拟查询出数据

    UserDO userDO = DataUtil.createData();

    log.info("拷贝前:userDO:{}", userDO);

    // 第一个参数:源对象, 第二个参数:目标对象,第三个参数:是否使用自定义转换器(下面会介绍),下同

    BeanCopier b = BeanCopier.create(UserDO.class, UserDTO.class, false);

    UserDTO userDTO = new UserDTO();

    b.copy(userDO, userDTO, null);

    log.info("拷贝后:userDTO:{}", userDTO);

    }

    结果:拷贝成功

    18:24:24.080 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝前:userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T18:24:24.077, balance=100)

    18:24:24.200 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝后:userDTO:UserDTO(id=1, userName=Van)

    3.1.2 属性名称相同、类型不同

    目标对象属性类

    @Data

    public class UserEntity {

    private Integer id;

    private String userName;

    }

    测试方法

    /**

    * 属性名称相同、类型不同

    */

    private static void sameNameDifferentType() {

    // 模拟查询出数据

    UserDO userDO = DataUtil.createData();

    log.info("拷贝前:userDO:{}", userDO);

    BeanCopier b = BeanCopier.create(UserDO.class, UserEntity.class, false);

    UserEntity userEntity = new UserEntity();

    b.copy(userDO, userEntity, null);

    log.info("拷贝后:userEntity:{}", userEntity);

    }

    结果

    19:43:31.645 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝前:userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T19:43:31.642, balance=100)

    19:43:31.748 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝后:userEntity:UserEntity(id=null, userName=Van)

    分析

    通过日志可以发现:UserDO的int类型的id无法拷贝到UserEntity的Integer的id。

    3.1.3 小节

    BeanCopier只拷贝名称和类型都相同的属性。

    即使源类型是原始类型(int, short和char等),目标类型是其包装类型(Integer, Short和Character等),或反之:都不会被拷贝。

    3.2 自定义转换器

    通过3.1.2可知,当源和目标类的属性类型不同时,不能拷贝该属性,此时我们可以通过实现Converter接口来自定义转换器

    3.2.1 准备

    目标对象属性类

    @Data

    public class UserDomain {

    private Integer id;

    private String userName;

    /**

    * 以下两个字段用户模拟自定义转换

    */

    private String gmtBroth;

    private String balance;

    }

    3.2.2 不使用Converter

    测试方法

    /**

    * 类型不同,不使用Converter

    */

    public static void noConverterTest() {

    // 模拟查询出数据

    UserDO userDO = DataUtil.createData();

    log.info("拷贝前:userDO:{}", userDO);

    BeanCopier copier = BeanCopier.create(UserDO.class, UserDomain.class, false);

    UserDomain userDomain = new UserDomain();

    copier.copy(userDO, userDomain, null);

    log.info("拷贝后:userDomain:{}", userDomain);

    }

    结果

    19:49:19.294 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝前:userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T19:49:19.290, balance=100)

    19:49:19.394 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝后:userDomain:UserDomain(id=null, userName=Van, gmtBroth=null, balance=null)

    分析

    通过打印日志的前后对比,属性类型不同的字段id,gmtBroth,balance未拷贝。

    3.2.3 使用Converter

    实现Converter接口来自定义属性转换

    public class UserConverter implements Converter {

    /**

    * 时间转换的格式

    */

    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    /**

    * 自定义属性转换

    * @param value 源对象属性类

    * @param target 目标对象里属性对应set方法名,eg.setId

    * @param context 目标对象属性类

    * @return

    */

    @Override

    public Object convert(Object value, Class target, Object context) {

    if (value instanceof Integer) {

    return value;

    } else if (value instanceof LocalDateTime) {

    LocalDateTime date = (LocalDateTime) value;

    return dtf.format(date);

    } else if (value instanceof BigDecimal) {

    BigDecimal bd = (BigDecimal) value;

    return bd.toPlainString();

    }

    // 更多类型转换请自定义

    return value;

    }

    }

    测试方法

    /**

    * 类型不同,使用Converter

    */

    public static void converterTest() {

    // 模拟查询出数据

    UserDO userDO = DataUtil.createData();

    log.info("拷贝前:userDO:{}", userDO);

    BeanCopier copier = BeanCopier.create(UserDO.class, UserDomain.class, true);

    UserConverter converter = new UserConverter();

    UserDomain userDomain = new UserDomain();

    copier.copy(userDO, userDomain, converter);

    log.info("拷贝后:userDomain:{}", userDomain);

    }

    结果:全部拷贝

    19:51:11.989 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝前:userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T19:51:11.985, balance=100)

    19:51:12.096 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝后:userDomain:UserDomain(id=1, userName=Van, gmtBroth=2019-11-02 19:51:11, balance=100)

    3.2.4 小节

    一旦使用Converter,BeanCopier只使用Converter定义的规则去拷贝属性,所以在convert()方法中要考虑所有的属性。

    但,使用Converter会使对象拷贝速度变慢。

    3.3 BeanCopier总结

    当源类和目标类的属性名称、类型都相同,拷贝没问题。

    当源对象和目标对象的属性名称相同、类型不同,那么名称相同而类型不同的属性不会被拷贝。注意,原始类型(int,short,char)和 他们的包装类型,在这里都被当成了不同类型,因此不会被拷贝。

    源类或目标类的setter比getter少,拷贝没问题,此时setter多余,但是不会报错。

    源类和目标类有相同的属性(两者的getter都存在),但是目标类的setter不存在,此时会抛出NullPointerException。

    四、BeanUtils与BeanCopier速度对比

    废话不多说,我这里直接演示两种工具10000条数据拷贝的耗时对比

    4.1 BeanUtils

    测试代码

    private static void beanUtil() {

    List list = DataUtil.createDataList(10000);

    long start = System.currentTimeMillis();

    List dtoList = new ArrayList<>();

    list.forEach(userDO -> {

    UserDTO userDTO = new UserDTO();

    BeanUtils.copyProperties(userDO,userDTO);

    dtoList.add(userDTO);

    });

    log.info("BeanUtils cotTime: {}ms", System.currentTimeMillis() - start);

    }

    结果(耗时:232ms)

    20:14:24.380 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopyComparedDemo - BeanUtils cotTime: 232ms

    4.2 BeanCopier

    测试代码

    private static void beanCopier() {

    // 工具类生成10w条数据

    List doList = DataUtil.createDataList(10000);

    long start = System.currentTimeMillis();

    List dtoList = new ArrayList<>();

    doList.forEach(userDO -> {

    BeanCopier b = BeanCopier.create(UserDO.class, UserDTO.class, false);

    UserDTO userDTO = new UserDTO();

    b.copy(userDO, userDTO, null);

    dtoList.add(userDTO);

    });

    log.info("BeanCopier costTime: {}ms", System.currentTimeMillis() - start);

    }

    结果(耗时:116ms)

    20:15:24.380 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopyComparedDemo - BeanCopier costTime: 116ms

    4.3 缓存BeanCopier实例提升性能

    BeanCopier拷贝速度快,性能瓶颈出现在创建BeanCopier实例的过程中。 所以,把创建过的BeanCopier实例放到缓存中,下次可以直接获取,提升性能。

    测试代码

    private static void beanCopierWithCache() {

    List userDOList = DataUtil.createDataList(10000);

    long start = System.currentTimeMillis();

    List userDTOS = new ArrayList<>();

    userDOList.forEach(userDO -> {

    UserDTO userDTO = new UserDTO();

    copy(userDO, userDTO);

    userDTOS.add(userDTO);

    });

    log.info("BeanCopier 加缓存后 costTime: {}ms", System.currentTimeMillis() - start);

    }

    public static void copy(Object srcObj, Object destObj) {

    String key = genKey(srcObj.getClass(), destObj.getClass());

    BeanCopier copier = null;

    if (!BEAN_COPIERS.containsKey(key)) {

    copier = BeanCopier.create(srcObj.getClass(), destObj.getClass(), false);

    BEAN_COPIERS.put(key, copier);

    } else {

    copier = BEAN_COPIERS.get(key);

    }

    copier.copy(srcObj, destObj, null);

    }

    private static String genKey(Class> srcClazz, Class> destClazz) {

    return srcClazz.getName() + destClazz.getName();

    }

    结果(耗时:6ms)

    20:32:31.405 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopyComparedDemo - BeanCopier 加缓存后 costTime: 6ms

    五、总结及源码

    场景

    耗时(10000次调用)

    原理

    BeanUtils

    232ms

    反射

    BeanCopier

    116ms

    修改字节码

    BeanCopier(加缓存)

    6ms

    修改字节码

    技术交流

    关注公众号,了解更多:

    展开全文
    weixin_28799111 2021-02-12 10:27:18
  • weixin_39930557 2021-03-08 20:01:53
  • mark_bin 2021-07-25 12:51:53
  • weixin_35415045 2020-12-23 06:24:35
  • weixin_30801745 2021-03-15 00:04:54
  • weixin_36036925 2021-03-14 10:44:25
  • jlonghou 2021-11-10 14:04:31
  • HS2529077916 2021-07-22 17:49:17
  • lovecuidong 2020-12-31 18:50:55
  • weixin_43392489 2021-03-07 11:47:31
  • lianghecai52171314 2021-06-23 17:35:38
  • weixin_34669755 2021-03-07 03:40:26
  • a3562323 2021-07-15 14:15:20
  • weixin_42558257 2021-02-12 10:27:19
  • lianghecai52171314 2021-12-03 15:52:48
  • weixin_43097056 2021-06-08 06:10:01
  • weixin_42277889 2021-08-25 22:00:22
  • weixin_28862967 2020-12-24 18:49:48
  • Rice_kil 2021-08-31 13:28:55
  • weixin_34624426 2021-03-03 14:09:23
  • weixin_39752434 2021-03-07 00:52:45
  • wuzhenwei0419 2021-05-15 09:43:38
  • cc_zhourenjie 2021-01-05 16:48:10
  • qq_25231683 2021-08-31 14:11:43
  • weixin_32491317 2021-03-22 14:19:18
  • mouday 2020-12-23 18:47:45
  • qq_38807606 2021-03-20 14:10:16

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 452,156
精华内容 180,862
关键字:

属性拷贝