JavaBean对象属性copy

最新推荐文章于 2025-09-21 16:55:19 发布

原创最新推荐文章于 2025-09-21 16:55:19 发布 · 6.1k 阅读

1 ·

CC 4.0 BY-SA版权

Java提高专栏收录该内容

30 篇文章

订阅专栏

本文对比了多种对象属性拷贝方法的性能，包括HardCode、BeanCopier及BeanUtils等，并介绍了BeanCopier的工作原理及如何处理不同字段名的情况。

1.对象属性拷贝的常见方式及其性能

在日常编码中，经常会遇到DO、DTO对象之间的转换，如果对象本身的属性比较少的时候，那么采用Hard Code工作量也不大，但如果对象的属性比较多的情况下，Hard Code效率就比较低。这时候就要使用其它工具类来进行对象属性的拷贝。
常用的对象属性拷贝的方式和性能测试如下：

拷贝方式	copy次数1000	copy次数100000	copy次数1000000
Hard Code	1 ms	18 ms	43 ms
net.sf.cglib.beans.BeanCopier#copy	117 ms	107 ms	110 ms
org.springframework.beans.BeanUtils#copyProperties	137 ms	246 ms	895 ms
org.apache.commons.beanutils.PropertyUtils#copyProperties	212 ms	601 ms	7869 ms
org.apache.commons.beanutils.BeanUtils#copyProperties	275 ms	1732 ms	12380 ms

结论：采用Hard Code方式进行对象属性Copy性能最佳；采用net.sf.cglib.beans.BeanCopier#copy方式进行对象属性copy性能最稳定；而org.apache.commons.beanutils.BeanUtils.copyProperties 方式在数据量大时性能下降最厉害。所以在日常编程中遇到具有较多属性的对象进行属性复制时优先考虑采用net.sf.cglib.beans.BeanCopier#copy。

以上的数据之所以产生巨大差距的原因在于其实现原理与方式的不同而导致的，Hard Code直接调用getter & setter方法值，cglib采用的是字节码技术，而后三种均采用反射的方式。前两者性能优异众所周知，但为何同样采用反射的方式进行属性Copy时产生的差异如此巨大呢？

2.Introspector

org.apache.commons.beanutils.BeanUtils与org.springframework.beans.BeanUtils均采用反射技术实现，也都调用了Java关于反射的高级API——Introspector(内省)。Introspector(内省)是jdk提供的用于描述Java bean支持的属性、方法以及事件的工具；利用此类可得到BeanInfo接口的实现对象:

        BeanInfo beanInfo = Introspector.getBeanInfo(Client.class);

        BeanDescriptor beanDescriptor = beanInfo.getBeanDescriptor();
        System.out.println(beanDescriptor.getBeanClass());

        PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
        for(PropertyDescriptor descriptor: descriptors) {
            Method readMethod = descriptor.getReadMethod();
            Method writeMethod = descriptor.getWriteMethod();

            System.out.println(descriptor.getName()); // address
            System.out.println(readMethod); // public java.lang.String xxx.Client.getAddress()
            System.out.println(writeMethod); // public void xxx.Client.setAddress(java.lang.String)
        }

getBeanDescriptor()返回的BeanDescriptor提供了java bean的一些全局的信息，如class类型、类名称等。getPropertyDescriptors()返回PropertyDescriptor[]，PropertyDescriptor描述了java bean中一个属性和它们的getter & setter方法的SoftReference。

3.BeanCopier#copy的使用

        Client client = new Client();
        client.setAddress("adc");
        client.setEmail("@163.com");
        BeanCopier copier = BeanCopier.create(Client.class, ClientDO.class, false);
        ClientDO clientDO = new ClientDO();
        copier.copy(client, clientDO, null);

BeanCopier#copy的使用示例有很多，注意BeanCopier只拷贝名称和类型都相同的属性，使用Converter可以解决类型不同的字段拷贝。
那么，如果字段名称不一样，但是需要BeanCopier#copy来拷贝怎么弄呢？这里给一个解法，可能不是最优解。我们知道BeanCopier#copy是使用了asm来生成了一个转换类来做属性的拷贝，只要修改生成的类里面的逻辑即可，来看代码：

    public static BeanCopier create(Class source, Class target, boolean useConverter) {
        Generator gen = new Generator();
        gen.setSource(source);
        gen.setTarget(target);
        gen.setUseConverter(useConverter);
        return gen.create();
    }

默认情况下，使用了net.sf.cglib.beans.BeanCopier.Generator，注意它是ClassGenerator的实现类，那么在生成类的使用就会调用它的generateClass方法：

        public void generateClass(ClassVisitor v) {
            Type sourceType = Type.getType(source);
            Type targetType = Type.getType(target);
            ClassEmitter ce = new ClassEmitter(v);
            ce.begin_class(Constants.V1_2,
                           Constants.ACC_PUBLIC,
                           getClassName(),
                           BEAN_COPIER,
                           null,
                           Constants.SOURCE_FILE);

            EmitUtils.null_constructor(ce);
            CodeEmitter e = ce.begin_method(Constants.ACC_PUBLIC, COPY, null);
            PropertyDescriptor[] getters = ReflectUtils.getBeanGetters(source);
            PropertyDescriptor[] setters = ReflectUtils.getBeanSetters(target);

            Map names = new HashMap();
            for (int i = 0; i < getters.length; i++) {
                names.put(getters[i].getName(), getters[i]);
            }
            Local targetLocal = e.make_local();
            Local sourceLocal = e.make_local();
            if (useConverter) {
                e.load_arg(1);
                e.checkcast(targetType);
                e.store_local(targetLocal);
                e.load_arg(0);                
                e.checkcast(sourceType);
                e.store_local(sourceLocal);
            } else {
                e.load_arg(1);
                e.checkcast(targetType);
                e.load_arg(0);
                e.checkcast(sourceType);
            }
            for (int i = 0; i < setters.length; i++) {
                PropertyDescriptor setter = setters[i];
                PropertyDescriptor getter = (PropertyDescriptor)names.get(setter.getName());
                if (getter != null) {
                    MethodInfo read = ReflectUtils.getMethodInfo(getter.getReadMethod());
                    MethodInfo write = ReflectUtils.getMethodInfo(setter.getWriteMethod());
                    if (useConverter) {
                        Type setterType = write.getSignature().getArgumentTypes()[0];
                        e.load_local(targetLocal);
                        e.load_arg(2);
                        e.load_local(sourceLocal);
                        e.invoke(read);
                        e.box(read.getSignature().getReturnType());
                        EmitUtils.load_class(e, setterType);
                        e.push(write.getSignature().getName());
                        e.invoke_interface(CONVERTER, CONVERT);
                        e.unbox_or_zero(setterType);
                        e.invoke(write);
                    } else if (compatible(getter, setter)) {
                        e.dup2();
                        e.invoke(read);
                        e.invoke(write);
                    }
                }
            }
            e.return_value();
            e.end_method();
            ce.end_class();
        }

asm不熟悉也不要紧，关键在于

                PropertyDescriptor setter = setters[i];
                PropertyDescriptor getter = (PropertyDescriptor)names.get(setter.getName());
                if (getter != null) {
                    MethodInfo read = ReflectUtils.getMethodInfo(getter.getReadMethod());
                    MethodInfo write = ReflectUtils.getMethodInfo(setter.getWriteMethod());

根据target中的setter的name，即字段名，去source中取getter，取不到就拉倒。那比如target有个字段是gender，但是实际对应source字段应该是sex，实际上可以在gender这个字段上加一个注解，值是sex，用注解值去source中取getter，然后做后面流程：

            PropertyDescriptor getter = (PropertyDescriptor) names.get(setter.getName());
            if (getter == null) {
                try {
                    Field field = target.getDeclaredField(setter.getName());
                    Alias alias = field.getAnnotation(Alias.class);
                    if (alias != null) {
                        getter = (PropertyDescriptor) names.get(alias.value());
                    }
                } catch (NoSuchFieldException err) {
                    err.printStackTrace();
                }
            }

为了避免对源码的修改，可以自定义一个ConsumerGenerator extends BeanCopier.Generator，在创建BeanCopier时使用ConsumerGenerator生成。

参考：https://blog.youkuaiyun.com/u010209217/article/details/84837821#1__2