BeanCopyUtils工具类

已于 2023-09-06 14:23:34 修改
阅读量1.2k 收藏
点赞数 1
分类专栏： 经验总结 文章标签： mysql 数据库 database
于 2021-11-30 11:08:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42093488/article/details/121628062
版权 
package com.kyexpress.crm.marketing.provider.utils;

import java.beans.PropertyDescriptor;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.stream.Collector;
import java.util.stream.Stream;

import com.kyexpress.framework.exception.ApplicationException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.cglib.core.Converter;
import org.springframework.util.CollectionUtils;

/**
 * bean复制工具类
 *
 * @author chencl
 * @version 1.0
 * @date 2021/11/29 14:54
 */
@Slf4j
public abstract class BeanCopyUtils {
    public BeanCopyUtils() {
    }

    public static <T> List<T> copyList(Class<T> dest, List orig) {
        if(CollectionUtils.isEmpty(orig)) {
            return new ArrayList();
        } else {
            BeanCopier beanCopier = BeanCopier.create(orig.get(0).getClass(), dest, false);
            ArrayList resultList = new ArrayList(orig.size());

            try {
                Iterator var4 = orig.iterator();

                while(var4.hasNext()) {
                    Object o = var4.next();
                    if(o != null) {
                        T destObject = dest.newInstance();
                        beanCopier.copy(o, destObject, (Converter)null);
                        resultList.add(destObject);
                    }
                }

                return resultList;
            } catch (Exception var7) {
                log.error("copyList error", var7);
                return resultList;
            }
        }
    }

    public static <D, O> List<D> copyList(Class<D> dest, List<O> orig, Consumer<D> d) {
        if(CollectionUtils.isEmpty(orig)) {
            return new ArrayList();
        } else {
            BeanCopier beanCopier = BeanCopier.create(orig.get(0).getClass(), dest, false);
            ArrayList resultList = new ArrayList(orig.size());

            try {
                Iterator var5 = orig.iterator();

                while(var5.hasNext()) {
                    Object o = var5.next();
                    if(o != null) {
                        D destObject = dest.newInstance();
                        beanCopier.copy(o, destObject, (Converter)null);
                        if(d != null) {
                            d.accept(destObject);
                        }

                        resultList.add(destObject);
                    }
                }
            } catch (Exception var8) {
                log.error("copyList error", var8);
            }

            return resultList;
        }
    }

    public static <D, O> List<D> copyList(Class<D> dest, List<O> orig, BiConsumer<O, D> d) {
        if(CollectionUtils.isEmpty(orig)) {
            return new ArrayList();
        } else {
            BeanCopier beanCopier = BeanCopier.create(orig.get(0).getClass(), dest, false);
            ArrayList resultList = new ArrayList(orig.size());

            try {
                Iterator var5 = orig.iterator();

                while(var5.hasNext()) {
                    O o = (O) var5.next();
                    if(o != null) {
                        D destObject = dest.newInstance();
                        beanCopier.copy(o, destObject, (Converter)null);
                        if(d != null) {
                            d.accept(o, destObject);
                        }

                        resultList.add(destObject);
                    }
                }
            } catch (Exception var8) {
                log.error("copyList error", var8);
            }

            return resultList;
        }
    }

    public static <T> List<T> copyListAndDetail(Class<T> dest, List orig, Map<String, String> transformKey) {
        return copyListAndDetail(dest, orig, transformKey, (BiConsumer)null);
    }

    public static <T, C> List<T> copyListAndDetail(Class<T> dest, List orig, Map<String, String> transformKey, BiConsumer<T, C> consumer) {
        try {
            List<T> resultList = new ArrayList();
            if(orig != null && orig.size() > 0) {
                Field[] originFields = null;
                Field[] destFields = null;
                int i = 0;
                if(!CollectionUtils.isEmpty(transformKey)) {
                    originFields = new Field[transformKey.size()];
                    destFields = new Field[transformKey.size()];
                    Class origClass = orig.get(0).getClass();
                    Set<Entry<String, String>> entries = transformKey.entrySet();

                    for(Iterator iterator = entries.iterator(); iterator.hasNext(); ++i) {
                        Entry<String, String> entry = (Entry)iterator.next();
                        String key = (String)entry.getKey();
                        String value = (String)entry.getValue();
                        originFields[i] = origClass.getDeclaredField(key);
                        destFields[i] = dest.getDeclaredField(value);
                    }

                    AccessibleObject.setAccessible(originFields, true);
                    AccessibleObject.setAccessible(destFields, true);
                }

                Iterator var18 = orig.iterator();

                while(true) {
                    Object o;
                    Object destObject;
                    do {
                        if(!var18.hasNext()) {
                            if(originFields != null && destFields != null) {
                                AccessibleObject.setAccessible(originFields, false);
                                AccessibleObject.setAccessible(destFields, false);
                            }

                            return resultList;
                        }

                        o = var18.next();
                        destObject = dest.newInstance();
                    } while(o == null);

                    copyProperties(destObject, o);

                    for(int a = 0; a < i; ++a) {
                        Field originField = originFields[a];
                        List o1 = (List)originField.get(o);
                        Field destField = destFields[a];
                        Class childClass = (Class)((ParameterizedType)destField.getGenericType()).getActualTypeArguments()[0];
                        List destList = copyList(childClass, o1);
                        destField.set(destObject, destList);
                    }

                    resultList.add((T) destObject);
                }
            } else {
                return resultList;
            }
        } catch (Exception var17) {
            log.error("copyListAndDetail error", var17);
            return null;
        }
    }

    private static <T, O> List<T> copyList(Class<T> dest, List orig, O out, BiConsumer<O, T> consumer) {
        if(CollectionUtils.isEmpty(orig)) {
            return new ArrayList();
        } else {
            BeanCopier beanCopier = BeanCopier.create(orig.get(0).getClass(), dest, false);
            ArrayList resultList = new ArrayList(orig.size());

            try {
                Iterator var6 = orig.iterator();

                while(var6.hasNext()) {
                    Object o = var6.next();
                    if(o != null) {
                        T destObject = dest.newInstance();
                        beanCopier.copy(o, destObject, (Converter)null);
                        resultList.add(destObject);
                        if(out != null && consumer != null) {
                            consumer.accept(out, destObject);
                        }
                    }
                }

                return resultList;
            } catch (Exception var9) {
                log.error("copyList error", var9);
                return resultList;
            }
        }
    }

    public static <T> T copyProperties(Class<T> dest, Object... orig) {
        if(orig == null) {
            return null;
        } else {
            try {
                T destObject = dest.newInstance();
                Object[] var3 = orig;
                int var4 = orig.length;

                for(int var5 = 0; var5 < var4; ++var5) {
                    Object o = var3[var5];
                    copyProperties(destObject, o);
                }

                return destObject;
            } catch (Exception var7) {
                log.error("copyProperties error", var7);
                return null;
            }
        }
    }

    public static <T> T copyProperties(Class<T> dest, Object orig) {
        if(orig == null) {
            return null;
        } else {
            try {
                T destObject = dest.newInstance();
                copyProperties(destObject, orig);
                return destObject;
            } catch (Exception var3) {
                log.error("copyProperties error", var3);
                return null;
            }
        }
    }

    public static void copyProperties(Object dest, Object orig) {
        try {
            BeanCopier copier = BeanCopier.create(orig.getClass(), dest.getClass(), false);
            copier.copy(orig, dest, (Converter)null);
        } catch (Exception var3) {
            log.error("copyProperties error", var3);
        }

    }

    public static void populate(Object bean, Map properties) {
        try {
            BeanMap beanMap = BeanMap.create(bean);
            beanMap.putAll(properties);
        } catch (Exception var3) {
            log.error("populate bean property error", var3);
        }

    }

    public static <T> T populate(Class<T> c, Map properties) {
        try {
            T o = c.newInstance();
            BeanMap beanMap = BeanMap.create(o);
            beanMap.putAll(properties);
            return (T) beanMap.getBean();
        } catch (Exception var4) {
            log.error("populate bean property error", var4);
            return null;
        }
    }

    public static <T> List<T> populateList(Class<T> dest, List<Map<String, Object>> orig) {
        if(CollectionUtils.isEmpty(orig)) {
            return new ArrayList();
        } else {
            ArrayList resultList = new ArrayList(orig.size());

            try {
                BeanMap beanMap = BeanMap.create(dest.newInstance());
                Iterator var4 = orig.iterator();

                while(var4.hasNext()) {
                    Map o = (Map)var4.next();
                    if(o != null) {
                        T destObject = dest.newInstance();
                        beanMap.setBean(destObject);
                        beanMap.putAll(o);
                        resultList.add(destObject);
                    }
                }

                return resultList;
            } catch (Exception var7) {
                log.error("copyList error", var7);
                return resultList;
            }
        }
    }

    public static <T> T getSingleResult(List<T> list) {
        if(CollectionUtils.isEmpty(list)) {
            return null;
        } else if(list.size() == 1) {
            return list.get(0);
        } else {
            throw new ApplicationException();
        }
    }

    public static <T> T getFirstResult(List<T> list) {
        return CollectionUtils.isEmpty(list)?null:list.get(0);
    }

    public static <K, V, T> Map<K, V> transformListToMap(List<T> stat, Collector<T, Map, Map> collector) {
        Map<K, V> hashMap = null;
        if(!CollectionUtils.isEmpty(stat)) {
            Stream<T> stream = null;
            if(stat.size() > 1000) {
                stream = stat.parallelStream();
            } else {
                stream = stat.stream();
            }

            hashMap = (Map)stream.collect(collector);
        }

        return hashMap;
    }

    public static <T> Map<String, T> getAssemblyResult(Map<String, T> finalResult, Map<String, T> intoResult, Class<T> c, String[] params) throws InvocationTargetException, IllegalAccessException {
        if(!CollectionUtils.isEmpty(intoResult)) {
            Iterator var4 = intoResult.entrySet().iterator();

            while(true) {
                while(var4.hasNext()) {
                    Entry<String, T> entry = (Entry)var4.next();
                    String key = (String)entry.getKey();
                    T value = entry.getValue();
                    T statPerDayOrder = finalResult.get(key);
                    if(statPerDayOrder == null) {
                        finalResult.put(key, value);
                    } else {
                        String[] var9 = params;
                        int var10 = params.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String param = var9[var11];
                            PropertyDescriptor propertyDescriptor = BeanUtils.getPropertyDescriptor(c, param);
                            Method readMethod = propertyDescriptor.getReadMethod();
                            Method writeMethod = propertyDescriptor.getWriteMethod();
                            Object oldValue = readMethod.invoke(statPerDayOrder, new Object[0]);
                            Object paramValue = readMethod.invoke(value, new Object[0]);
                            if(oldValue != null && paramValue != null) {
                                if(BigDecimal.class.isInstance(paramValue)) {
                                    BigDecimal old = (BigDecimal)oldValue;
                                    paramValue = old.add((BigDecimal)paramValue);
                                } else if(Integer.class.isInstance(paramValue)) {
                                    Integer old = (Integer)oldValue;
                                    paramValue = Integer.valueOf(old.intValue() + ((Integer)paramValue).intValue());
                                } else if(Long.class.isInstance(paramValue)) {
                                    Long old = (Long)oldValue;
                                    paramValue = Long.valueOf(old.longValue() + ((Long)paramValue).longValue());
                                }
                            }

                            writeMethod.invoke(statPerDayOrder, new Object[]{paramValue});
                        }
                    }
                }

                return finalResult;
            }
        } else {
            return finalResult;
        }
    }

}
探索高性能Java Bean复制神器：BeanUtils库
gitblog_00001的博客
06-02 459
探索高性能Java Bean复制神器：BeanUtils库 BeanUtilsBeanUtils library is a Java bean copy utility with powerful functionality and high performance.项目地址:https://gitcode.com/gh_mirrors/be/BeanUtils 在日常的Java开发中，我们经常...
「Java工具类」BeanCopyUtil对象复制工具类
热门推荐
Java Farmer
10-31 1万+
介绍语 本号主要是Java常用关键技术点，通用工具类的分享；以及springboot+springcloud+Mybatisplus+druid+mysql+redis+swagger+maven+docker等集成框架的技术分享；datax、kafka、flink等大数据处理框架的技术分享。文章会不断更新，欢迎码友关注点赞收藏转发！ 望各位码友点击关注，冲1000粉。后面会录制一些视频教程，图文和视频结合，比如：图书介绍网站系统、抢购系统、大数据中台系统等。技术才是程序猿的最爱，码友们冲啊 如果码友
Java BeanUtils.copyProperties() 详解及应用
最新发布
m0_73467713的博客
08-17 4943
方法用于将一个 Java 对象的属性复制到另一个对象。它在处理数据传输对象（DTO）、视图对象（VO）和实体对象（Entity）之间的数据传递时非常有用。source：源对象，属性值从这个对象中提取。target：目标对象，将属性值复制到这个对象中。是一个强大的工具，可以简化对象属性的拷贝操作。它在 Java 开发中扮演着重要的角色，尤其是在对象转换、数据封装和自动化测试等场景中。虽然它提供了很大的便利，但在性能要求较高的情况下，可能需要评估其他解决方案。
BeanUtil属性拷贝工具类
04-05
BeanUtil属性拷贝工具类，支持基本的javabean属性拷贝，通过java反射和泛型编程实现了list属性拷贝
BeanCopyUtil工具类
weixin_43032247的博客
05-31 999
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
BeanCopyUtils.java
03-17
继承org.springframework.beans.BeanUtils 修改copyProperties方法赋值时，为null时不进行处理，方便开发工具类
CopyUtil（java复合bean的copy）
qq_37276508的博客
10-08 3332
诞生由来 之前项目里就经常有bean之间的属性copy，一直都是用spring自带的工具类来解决，方法如下： org.springframework.beans.BeanUtils#copyProperties(java.lang.Object, java.lang.Object); 该方法只能对一个bean中普通属性字段进行copy，如果这个bean中有其他的bean，即bean中bean，就...
BeanUtils工具类实现Bean拷贝详解
这里是Mae。
02-07 8832
BeanUtils工具类实现Bean拷贝使用详解。 真正学会Bean拷贝！
beancopyutils
07-28
BeanCopyUtils是一个对BeanUtils进行进一步封装的工具类，用于实现Bean的拷贝操作。通过封装，我们可以避免每次都重复编写冗余的代码，并且可以实现对每一个PO类的Bean拷贝。\[1\]在使用BeanCopyUtils时，我们可以...
帮我写一个工具类专门BeanCopy
04-04
* Bean属性复制工具类 */ public class BeanCopyUtils { /** * 将source对象中的属性值复制到target对象中对应的属性中 * * @param source 源对象 * @param target 目标对象 */ public static void ...
beancopyutils.copylist用法
08-05
BeanCopyUtils.copyList 是 CSDN 开发的一个工具类方法，用于将一个列表中的对象复制到另一个列表中。 使用方法如下： ```javaList<T> sourceList = new ArrayList(); // 原始列表List<T> targetList = ...
BeanUtilsBean对象复制使用（类型可以自动转化）
05-01
NULL 博文链接：https://yuhuiblog695685688425687986842568269.iteye.com/blog/2396139
BeanCopierUtils.java
09-24
bean copy。
RuoYi-Vue-Plus（基础知识点jackson、mybatisplus、redis以及Redisson 工具类）
javaxueba的博客
03-19 3473
时区#日期格式#默认转json的属性，这里设置为非空才转json#设置属性命名策略,对应jackson下PropertyNamingStrategy中的常量值，SNAKE_CASE-返回的json驼峰式转下划线，json body下划线传到后端自动转驼峰式#对象为空时是否报错，默认true#返回的java.util.date转换成timestamp#json中含pojo不存在属性时是否失败报错,默认true#是否允许出现单引号,默认false。
spring的beanutils工具类_BeanCopy工具类 - BeanCopyUtils
weixin_39746552的博客
02-04 1783
核心使用Spring的org.springframework.beans.BeanUtils实现拷贝。import org.springframework.beans.BeanUtils;import java.lang.reflect.InvocationTargetException;/*** @author jfp* @create 2020/11/19 15:04* @desc BeanC...
BeanCopyUtils 实现单个对象，多个对象属性Copy
Nba_3210的博客
03-18 1134
import lombok.extern.slf4j.Slf4j; import org.springframework.beans.BeanUtils; import org.springframework.util.CollectionUtils; import java.util.ArrayList; import java.util.List; /** * * @version ...
对象拷贝类PropertyUtils，BeanUtils，BeanCopier的技术沉淀
专注、专心、专业
05-17 9795
功能简介   对象拷贝的应用现状简介： 业务系统中经常需要两个对象进行属性的拷贝，不能否认逐个的对象拷贝是最快速最安全的做法，但是当数据对象的属性字段数量超过程序员的容忍的程度，代码因此变得臃肿不堪，使用一些方便的对象拷贝工具类将是很好的选择。 目前流行的较为公用认可的工具类： Apache的两个版本：（反射机制） org.apache.commons.beanutils.Pr
对象拷贝 工具类 BeansCopyUtils
鱼皮小刘博客
03-21 3662
依赖 <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.4.2</version> </dependency> 类 package com.jsy.basic.util.utils; impo
Bean拷贝工具类推荐
Mamba的博客
09-17 2626
springboot，拷贝工具类，Bean拷贝
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值