1. 基本知识

BeanCopier是一个Java库，用于在Java Bean之间进行属性复制，它可以自动将一个Java Bean对象的属性值复制到另一个Java Bean对象中，而无需手动编写属性复制的代码

作用	优点	缺点
简化属性复制: BeanCopier能够自动将一个Java Bean对象的属性值复制到另一个Java Bean对象中，省去了手动编写属性复制代码的繁琐工作 提高效率: 由于BeanCopier利用了反射机制，因此能够实现高效的属性复制，避免了手动编写大量的getter和setter方法的耗时工作 灵活性: BeanCopier可以根据需求灵活地配置属性复制的行为，例如可以选择性地复制某些属性，或者自定义属性复制的规则	简单易用: BeanCopier提供了简单易用的API，使得属性复制变得非常简单 高效性能: 利用了反射机制，能够实现高效的属性复制，提高了程序的执行效率 灵活性: 可以根据需求灵活配置属性复制的行为，使得其适用于各种不同的场景	不支持复杂属性: BeanCopier虽然能够处理简单的属性复制，但是对于复杂的属性，例如嵌套对象或集合对象，可能需要额外的处理 不支持类型转换: BeanCopier在属性复制时不支持类型转换，如果源对象和目标对象的属性类型不一致，可能需要额外的类型转换处理 不支持属性名称不同的情况: 如果源对象和目标对象的属性名称不一致，BeanCopier无法自动匹配属性，需要手动指定属性映射关系

2. 同属性Demo

package com.example.test;

import org.springframework.cglib.beans.BeanCopier;

public class test {
    static class SourceBean {
        private String name;
        private int age;

        // getters and setters
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        public int getAge() { return age; }
        public void setAge(int age) { this.age = age; }
    }

    static class TargetBean {
        private String name;
        private int age;

        // getters and setters
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        public int getAge() { return age; }
        public void setAge(int age) { this.age = age; }
    }

    public static void main(String[] args) {
        // 创建BeanCopier对象
        BeanCopier copier = BeanCopier.create(SourceBean.class, TargetBean.class, false);

        // 创建源对象
        SourceBean source = new SourceBean();
        source.setName("码农研究僧");
        source.setAge(18);

        // 创建目标对象
        TargetBean target = new TargetBean();

        // 属性复制
        copier.copy(source, target, null);

        // 打印目标对象属性值
        System.out.println("Name: " + target.getName()); // 输出：Name: John
        System.out.println("Age: " + target.getAge());   // 输出：Age: 30
    }
}

截图如下：

3. 不同属性Demo

这是不同属性，但不需要转换的Demo

package com.example.test;


import java.io.Serializable;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

// 定义一个源对象类
class CheckOrder implements Serializable {
    private String orderId;

    public CheckOrder() {
    }

    public CheckOrder(String orderId) {
        this.orderId = orderId;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }
}

// 定义一个目标对象类，继承自源对象类
class CheckOrderVO extends CheckOrder implements Serializable {
    private String orderName;

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }
}

// 模拟BeanUtil工具类
class BeanUtil {
    private static final Map<BeanCopierKey, BeanCopier> BEAN_COPIER_MAP = new HashMap<>();

    public static <T> T copy(Object source, Class<T> clazz) {
        return source == null ? null : copy(source, source.getClass(), clazz);
    }

    public static <T> T copy(Object source, Class sourceClazz, Class<T> targetClazz) {
        if (source == null) {
            return null;
        } else {
            BeanCopier copier = BeanCopier.create(sourceClazz, targetClazz, false);
            T to = newInstance(targetClazz);
            copier.copy(source, to, null);
            return to;
        }
    }

    public static <T> T newInstance(Class<T> clazz) {
        try {
            return clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

// 模拟BeanCopier类
class BeanCopier {
    public static BeanCopier create(Class source, Class target, boolean useConverter) {
        return create(source, target, useConverter, false);
    }

    public static BeanCopier create(Class source, Class target, boolean useConverter, boolean nonNull) {
        return new BeanCopier();
    }

    public void copy(Object source, Object target, Object converter) {
        if (source == null || target == null) {
            throw new IllegalArgumentException("Source and target objects cannot be null.");
        }

        Field[] sourceFields = source.getClass().getDeclaredFields();
        Field[] targetFields = target.getClass().getDeclaredFields();

        Map<String, Field> targetFieldMap = new HashMap<>();
        for (Field sourceField : sourceFields) {
            sourceField.setAccessible(true);
            targetFieldMap.put(sourceField.getName(), sourceField);
        }

        for (Field sourceField : sourceFields) {
            sourceField.setAccessible(true);
            Field targetField = targetFieldMap.get(sourceField.getName());
            if (targetField != null && sourceField.getType().equals(targetField.getType())) {
                try {
                    Object value = sourceField.get(source);
                    targetField.set(target, value);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }

        System.out.println("Copying from " + source + " to " + target);
    }


}

class BeanCopierKey {
    private Class<?> source;
    private Class<?> target;
    private boolean useConverter;
    private boolean nonNull;

    public BeanCopierKey(Class<?> source, Class<?> target, boolean useConverter, boolean nonNull) {
        this.source = source;
        this.target = target;
        this.useConverter = useConverter;
        this.nonNull = nonNull;
    }

    public Class<?> getSource() {
        return source;
    }

    public Class<?> getTarget() {
        return target;
    }

    public boolean isUseConverter() {
        return useConverter;
    }

    public boolean isNonNull() {
        return nonNull;
    }
}

public class Demo {
    public static void main(String[] args) {
        // 创建一个源对象
        CheckOrder checkOrder = new CheckOrder("12345");

        // 使用BeanUtil进行对象拷贝
        CheckOrderVO checkOrderVOCopy = BeanUtil.copy(checkOrder, CheckOrderVO.class);

        // 手动设置目标对象的属性
        checkOrderVOCopy.setOrderName("码农研究僧");

        // 输出拷贝后的目标对象的属性值
        System.out.println("Copied order ID: " + checkOrderVOCopy.getOrderId());
        // 因为目标对象类继承自源对象类，所以也可以访问源对象的属性
        System.out.println("Copied order name: " + checkOrderVOCopy.getOrderName());
    }
}

截图如下：

如果需要用到转换，可以看如下函数：

class BeanCopier {
    public static BeanCopier create(Class source, Class target, boolean useConverter) {
        return create(source, target, useConverter, false);
    }
    public static BeanCopier create(Class source, Class target, boolean useConverter, boolean nonNull) {
        return new BeanCopier();
    }
    public void copy(Object source, Object target, Object converter) {
        if (source == null || target == null) {
            throw new IllegalArgumentException("Source and target objects cannot be null.");
        }
        Field[] sourceFields = source.getClass().getDeclaredFields();
        Field[] targetFields = target.getClass().getDeclaredFields();

        Map<String, Field> targetFieldMap = new HashMap<>();
        for (Field targetField : targetFields) {
            targetField.setAccessible(true);
            targetFieldMap.put(targetField.getName(), targetField);
        }
		
		// 修改变动位置
        Converter customConverter = (Converter) converter;

        for (Field sourceField : sourceFields) {
            sourceField.setAccessible(true);
            Field targetField = targetFieldMap.get(sourceField.getName());
            if (targetField != null && sourceField.getType().equals(targetField.getType())) {
                try {
                    Object value = sourceField.get(source);
                    
                    // 修改变动位置
                    if (customConverter != null) {
                        value = customConverter.convert(value, targetField.getType(), null);
                    }
                    
                    targetField.set(target, value);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("Copying from " + source + " to " + target);
    }
}

4. 实战场景

实战中的运用如下：

数据库的字段等都建立好了，并且其实体类如下：

使用过程中，可能还需要添加额外的字段，但又不影响到数据库，只想显示在前端而已，可以通过如下

最后结合工具类来复刻整个数据库拥有的属性，并添加新的字段值，并返回给前端操作