Java对象拷贝原理剖析及最佳实践

╰+哭是因爲堅強的太久メ 2024-03-31 12:39 45阅读 0赞

## 1 前言 ##

对象拷贝，是我们在开发过程中，绕不开的过程，既存在于Po、Dto、Do、Vo各个表现层数据的转换，也存在于系统交互如序列化、反序列化。

Java对象拷贝分为深拷贝和浅拷贝，目前常用的属性拷贝工具，包括Apache的BeanUtils、Spring的BeanUtils、Cglib的BeanCopier、mapstruct都是浅拷贝。

## 1.1 深拷贝 ##

深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容称为深拷贝。

深拷贝常见有以下四种实现方式:

*  构造函数
 *  Serializable序列化
 *  实现Cloneable接口
 *  JSON序列化

![dcfe9921ab55453f87673c0c65c0bad9.png][]

## 1.2 浅拷贝 ##

浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝称为浅拷贝。通过实现Cloneabe接口并重写Object类中的clone()方法可以实现浅克隆。

![dc2a338643804df0803812d2d7818f73.png][]

## 2 常用对象拷贝工具原理剖析及性能对比 ##

目前常用的属性拷贝工具，包括Apache的BeanUtils、Spring的BeanUtils、Cglib的BeanCopier、mapstruct。

*  Apache BeanUtils:BeanUtils是Apache commons组件里面的成员，由Apache提供的一套开源 api，用于简化对javaBean的操作，能够对基本类型自动转换。
 *  Spring BeanUtils：BeanUtils是spring框架下自带的工具，在org.springframework.beans包下， spring项目可以直接使用。
 *  Cglib BeanCopier：cglib（Code Generation Library）是一个强大的、高性能、高质量的代码生成类库，BeanCopier依托于cglib的字节码增强能力，动态生成实现类，完成对象的拷贝。
 *  mapstruct：mapstruct 是一个 Java注释处理器，用于生成类型安全的 bean 映射类，在构建时，根据注解生成实现类，完成对象拷贝。

## 2.1 原理分析 ##

## 2.1.1 Apache BeanUtils ##

使用方式：BeanUtils.copyProperties(target, source);  
BeanUtils.copyProperties 对象拷贝的核心代码如下:

// 1.获取源对象的属性描述
    PropertyDescriptor[] origDescriptors = this.getPropertyUtils().getPropertyDescriptors(orig);
    PropertyDescriptor[] temp = origDescriptors;
    int length = origDescriptors.length;
    String name;
    Object value;
    
    // 2.循环获取源对象每个属性，设置目标对象属性值
    for(int i = 0; i < length; ++i) {
    PropertyDescriptor origDescriptor = temp[i];
    name = origDescriptor.getName();
    // 3.校验源对象字段可读切目标对象该字段可写
    if (!"class".equals(name) && this.getPropertyUtils().isReadable(orig, name) && this.getPropertyUtils().isWriteable(dest, name)) {
          try {
    // 4.获取源对象字段值
              value = this.getPropertyUtils().getSimpleProperty(orig, name);
    // 5.拷贝属性
              this.copyProperty(dest, name, value);
          } catch (NoSuchMethodException var10) {
          }
       }
    }

循环遍历源对象的每个属性，对于每个属性，拷贝流程为:

*  校验来源类的字段是否可读isReadable
 *  校验目标类的字段是否可写isWriteable
 *  获取来源类的字段属性值getSimpleProperty
 *  获取目标类字段的类型type，并进行类型转换
 *  设置目标类字段的值

由于单字段拷贝时每个阶段都会调用PropertyUtilsBean.getPropertyDescriptor获取属性配置,而该方法通过for循环获取类的字段属性，严重影响拷贝效率。  
获取字段属性配置的核心代码如下：

PropertyDescriptor[] descriptors = this.getPropertyDescriptors(bean);
    if (descriptors != null) {
    for (int i = 0; i < descriptors.length; ++i) {
    if (name.equals(descriptors[i].getName())) {
    return descriptors[i];
    }
    }
    }

## 2.1.2 Spring BeanUtils ##

使用方式: BeanUtils.copyProperties(source, target);  
BeanUtils.copyProperties核心代码如下：

PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
    List<String> ignoreList = ignoreProperties != null ? Arrays.asList(ignoreProperties) : null;
    PropertyDescriptor[] arr$ = targetPds;
    int len$ = targetPds.length;
    for(int i$ = 0; i$ < len$; ++i$) {
        PropertyDescriptor targetPd = arr$[i$];
        Method writeMethod = targetPd.getWriteMethod();
        if (writeMethod != null && (ignoreList == 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);
                        if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                            writeMethod.setAccessible(true);
                        }
                        writeMethod.invoke(target, value);
                    } catch (Throwable var15) {
                        throw new FatalBeanException("Could not copy property '" + targetPd.getName() + "' from source to target", var15);
                    }
                }
            }
        }
    }

拷贝流程简要描述如下:

*  获取目标类的所有属性描述
 *  循环目标类的属性值做以下操作
 *  获取目标类的写方法
 *  获取来源类的该属性的属性描述(缓存获取)
 *  获取来源类的读方法
 *  读来源属性值
 *  写目标属性值

与Apache BeanUtils的属性拷贝相比，Spring通过Map缓存，避免了类的属性描述重复获取加载，通过懒加载，初次拷贝时加载所有属性描述。

## 2.1.3 Cglib BeanCopier ##

使用方式：

BeanCopier beanCopier = BeanCopier.create(AirDepartTask.class, AirDepartTaskDto.class, false); 
    beanCopier.copy(airDepartTask, airDepartTaskDto, null);

create调用链如下:

BeanCopier.create  
\-> BeanCopier.Generator.create  
\-> AbstractClassGenerator.create  
\->DefaultGeneratorStrategy.generate  
\-> BeanCopier.Generator.generateClass

BeanCopier 通过cglib动态代理操作字节码，生成一个复制类，触发点为BeanCopier.create

![d1e5bda84b2c4469b0172602a824b42e.png][]

## 2.1.4 mapstruct ##

使用方式:

*  引入pom依赖
 *  声明转换接口

mapstruct基于注解，构建时自动生成实现类，调用链如下:  
MappingProcessor.process -> MappingProcessor.processMapperElements  
MapperCreationProcessor.process:生成实现类Mapper  
MapperRenderingProcessor:将实现类mapper，写入文件，生成impl文件  
使用时需要声明转换接口，例如：

生成的实现类如下：

public class AirDepartTaskConvertImpl implements AirDepartTaskConvert {
    
        @Override
        public AirDepartTaskDto convertToDto(AirDepartTask airDepartTask) {
            if ( airDepartTask == null ) {
                return null;
            }
    
            AirDepartTaskDto airDepartTaskDto = new AirDepartTaskDto();
    
            airDepartTaskDto.setId( airDepartTask.getId() );
            airDepartTaskDto.setTaskId( airDepartTask.getTaskId() );
            airDepartTaskDto.setPreTaskId( airDepartTask.getPreTaskId() );
            List<String> list = airDepartTask.getTaskBeginNodeCodes();
            if ( list != null ) {
                airDepartTaskDto.setTaskBeginNodeCodes( new ArrayList<String>( list ) );
            }
            // 其他属性拷贝
            airDepartTaskDto.setYn( airDepartTask.getYn() );
    
            return airDepartTaskDto;
        }
    }

## 2.2 性能对比 ##

以航空业务系统中发货任务po到dto转换为例，随着拷贝数据量的增大，研究拷贝数据耗时情况

![0299e899acbd438abb9d43c108f14fdc.png][]

## 2.3 拷贝选型 ##

经过以上分析，随着数据量的增大，耗时整体呈上升趋势

*  整体情况下，Apache BeanUtils的性能最差，日常使用过程中不建议使用
 *  在数据规模不大的情况下，spring、cglib、mapstruct差异不大，spring框架下建议使用spring的beanUtils，不需要额外引入依赖包
 *  数据量大的情况下，建议使用cglib和mapstruct
 *  涉及大量数据转换，属性映射，格式转换的，建议使用mapstruct

## 3 最佳实践 ##

## 3.1 BeanCopier ##

使用时可以使用map缓存，减少同一类对象转换时，create次数

/**
         * BeanCopier的缓存，避免频繁创建，高效复用
         */
        private static final ConcurrentHashMap<String, BeanCopier> BEAN_COPIER_MAP_CACHE = new ConcurrentHashMap<String, BeanCopier>();
    
        /**
         * BeanCopier的copyBean，高性能推荐使用，增加缓存
         *
         * @param source 源文件的
         * @param target 目标文件
         */
        public static void copyBean(Object source, Object target) {
            String key = genKey(source.getClass(), target.getClass());
            BeanCopier beanCopier;
            if (BEAN_COPIER_MAP_CACHE.containsKey(key)) {
                beanCopier = BEAN_COPIER_MAP_CACHE.get(key);
            } else {
                beanCopier = BeanCopier.create(source.getClass(), target.getClass(), false);
                BEAN_COPIER_MAP_CACHE.put(key, beanCopier);
            }
            beanCopier.copy(source, target, null);
        }
    
        /**
         * 不同类型对象数据copylist
         *
         * @param sourceList
         * @param targetClass
         * @param <T>
         * @return
         */
        public static <T> List<T> copyListProperties(List<?> sourceList, Class<T> targetClass) throws Exception {
            if (CollectionUtils.isNotEmpty(sourceList)) {
                List<T> list = new ArrayList<T>(sourceList.size());
                for (Object source : sourceList) {
                    T target = copyProperties(source, targetClass);
                    list.add(target);
                }
                return list;
            }
            return Lists.newArrayList();
        }
    
        /**
         * 返回不同类型对象数据copy,使用此方法需注意不能覆盖默认的无参构造方法
         *
         * @param source
         * @param targetClass
         * @param <T>
         * @return
         */
        public static <T> T copyProperties(Object source, Class<T> targetClass) throws Exception {
            T target = targetClass.newInstance();
            copyBean(source, target);
            return target;
        }
    
        /**
         * @param srcClazz 源class
         * @param tgtClazz 目标class
         * @return string
         */
        private static String genKey(Class<?> srcClazz, Class<?> tgtClazz) {
            return srcClazz.getName() + tgtClazz.getName();
        }

## 3.2 mapstruct ##

mapstruct支持多种形式对象的映射，主要有下面几种

*  基本映射
 *  映射表达式
 *  多个对象映射到一个对象
 *  映射集合
 *  映射map
 *  映射枚举
 *  嵌套映射

@Mapper(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE)
    public interface AirDepartTaskConvert {
        AirDepartTaskConvert INSTANCE = getMapper(AirDepartTaskConvert.class);
    
        // a.基本映射
        @Mapping(target = "createTime", source = "updateTime")
        // b.映射表达式
        @Mapping(target = "updateTimeStr", expression = "java(new SimpleDateFormat( \"yyyy-MM-dd\" ).format(airDepartTask.getCreateTime()))")
        AirDepartTaskDto convertToDto(AirDepartTask airDepartTask);
    }
    
    @Mapper
    public interface AddressMapper {
        AddressMapper INSTANCE = Mappers.getMapper(AddressMapper.class);
    
     // c.多个对象映射到一个对象
        @Mapping(source = "person.description", target = "description")
        @Mapping(source = "address.houseNo", target = "houseNumber")
        DeliveryAddressDto personAndAddressToDeliveryAddressDto(Person person, Address address);
    }
    
    @Mapper
    public interface CarMapper {
      // d.映射集合
        Set<String> integerSetToStringSet(Set<Integer> integers);
    
        List<CarDto> carsToCarDtos(List<Car> cars);
    
        CarDto carToCarDto(Car car);
      // e.映射map
      @MapMapping(valueDateFormat = "dd.MM.yyyy")
      Map<String,String> longDateMapToStringStringMap(Map<Long, Date> source);
    
     // f.映射枚举
        @ValueMappings({
            @ValueMapping(source = "EXTRA", target = "SPECIAL"),
            @ValueMapping(source = "STANDARD", target = "DEFAULT"),
            @ValueMapping(source = "NORMAL", target = "DEFAULT")
        })
        ExternalOrderType orderTypeToExternalOrderType(OrderType orderType);
        // g.嵌套映射
        @Mapping(target = "fish.kind", source = "fish.type")
        @Mapping(target = "fish.name", ignore = true)
        @Mapping(target = "ornament", source = "interior.ornament")
        @Mapping(target = "material.materialType", source = "material")
        @Mapping(target = "quality.report.organisation.name", source = "quality.report.organisationName")
        FishTankDto map( FishTank source );
    }

## 4 总结 ##

以上就是我在使用对象拷贝过程中的一点浅谈。在日常系统开发过程中，要深究底层逻辑，哪怕发现一小点的改变能够使我们的系统更加稳定、顺畅，都是值得我们去改进的。

[dcfe9921ab55453f87673c0c65c0bad9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/10aeb587a83c4a308fd0cfc549d45bc1.png
[dc2a338643804df0803812d2d7818f73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/9d699144ae8c4c82835a3ccb48468a0a.png
[d1e5bda84b2c4469b0172602a824b42e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e063efad0f2e4cdea96dcdb4a3041a07.png
[0299e899acbd438abb9d43c108f14fdc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/43b5c1a006ba49c1af540268ab2bf38d.png