基于Beanutils.copyProperties()的用法及重写提高效率

目录

• Beanutils.copyProperties()用法及重写提高效率
• 一、简介
• 二、用法
• 三、重写
• 原理
• BeanUtils.copyProperties 使用注意
• 示例演示
• 开始进行示例
• 最后强调

Beanutils.copyProperties()用法及重写提高效率

特别说明本文介绍的是Spring（import org.springframework.beans.BeanUtils）中的BeanUtils.copyProperties(A,B)方法。是将A中的值赋给B。apache（org.apache.commons.beanutils.BeanUtils）中的BeanUtils.copyProperties(A,B)方法是将B中的值赋值给A。

一、简介

BeanUtils提供对Java反射和自省API的包装。其主要目的是利用反射机制对JavaBean的属性进行处理。我们知道，一个JavaBean通常包含了大量的属性，很多情况下，对JavaBean的处理导致大量get/set代码堆积，增加了代码长度和阅读代码的难度。

二、用法

如果你有两个具有很多相同属性的JavaBean，一个很常见的情况就是Struts里的PO对象（持久对象）和对应的ActionForm。例如：一个用户注册页面，有一个User实体类和一个UserActionForm，我们一般会在Action里从ActionForm构造一个PO对象，传统的方式是使用类似下面的语句对属性逐个赋值：

// 获取 ActionForm 表单数据
UserActionForm uForm = (UserActionForm) form;
// 构造一个User对象
User user = new User();
// 逐一赋值
user.setUsername(uForm.getUsername);
user.setPassword(uForm.getPassword);
user.setAge(uForm.getAge);
...........
...........
// 然后调用JDBC、或操作Hibernate 持久化对象User到数据库
HibernateDAO.save(user); 

通过这样的方法如果表单数据N多、100、1000（夸张点。哈哈）、、、、那我们不是要写100、、、1000行set、get了。谁都

不愿意这样做。

而我们使用 BeanUtils.copyProperties() 方法以后，代码量大大的减少，而且整体程序看着也简洁明朗，代码如下：

// 获取 ActionForm 表单数据
UserActionForm uForm = (UserActionForm) form;
// 构造一个User对象
User user = new User();
BeanUtils.copyProperties(uForm,user);
// 然后调用JDBC、或操作Hibernate 持久化对象User到数据库
HibernateDAO.save(user); 

注：如果User和UserActionForm 间存在名称不相同的属性，则BeanUtils不对这些属性进行处理，需要手动处理。例如：

User类里面有个createDate 创建时间字段，而UserActionForm里面无此字段。BeanUtils.copyProperties()不会对此字段做任何处理。必须要自己手动处理。

user.setModifyDate(new Date());  

三、重写

ReflectASM，高性能的反射：

什么是ReflectASM ReflectASM是一个很小的java类库，主要是通过asm生产类来实现java反射，执行速度非常快，看了网上很多和反射的对比，觉得ReflectASM比较神奇，很想知道其原理，下面介绍下如何使用及原理；

public static void main(String[] args) {
        User user = new User();
        //使用reflectasm生产User访问类
        MethodAccess access = MethodAccess.get(User.class);
        //invoke setName方法name值
        access.invoke(user, "setName", "张三");
        //invoke getName方法 获得值
        String name = (String)access.invoke(user, "getName", null);
        System.out.println(name);
    }    

原理

上面代码的确实现反射的功能，代码主要的核心是 MethodAccess.get(User.class);

看了下源码，这段代码主要是通过asm生产一个User的处理类 UserMethodAccess（这个类主要是实现了invoke方法）的ByteCode，然后获得该对象，通过上面的invoke操作user类。

private static Map<Class, MethodAccess> methodMap = new HashMap<Class, MethodAccess>();
    private static Map<String, Integer> methodIndexMap = new HashMap<String, Integer>();
    private static Map<Class, List<String>> fieldMap = new HashMap<Class, List<String>>();
    public static void copyProperties(Object desc, Object orgi) {
        MethodAccess descMethodAccess = methodMap.get(desc.getClass());
        if (descMethodAccess == null) {
            descMethodAccess = cache(desc);
        }
        MethodAccess orgiMethodAccess = methodMap.get(orgi.getClass());
        if (orgiMethodAccess == null) {
            orgiMethodAccess = cache(orgi);
        }  

        List<String> fieldList = fieldMap.get(orgi.getClass());
        for (String field : fieldList) {
            String getKey = orgi.getClass().getName() + "." + "get" + field;
            String setkey = desc.getClass().getName() + "." + "set" + field;
            Integer setIndex = methodIndexMap.get(setkey);
            if (setIndex != null) {
                int getIndex = methodIndexMap.get(getKey);
                // 参数一需要反射的对象
                // 参数二class.getDeclaredMethods 对应方法的index
                // 参数对三象集合
                descMethodAccess.invoke(desc, setIndex.intValue(),
                        orgiMethodAccess.invoke(orgi, getIndex));
            }
        }
    }  

    // 单例模式
    private static MethodAccess cache(Object orgi) {
        synchronized (orgi.getClass()) {
            MethodAccess methodAccess = MethodAccess.get(orgi.getClass());
            Field[] fields = orgi.getClass().getDeclaredFields();
            List<String> fieldList = new ArrayList<String>(fields.length);
            for (Field field : fields) {
                if (Modifier.isPrivate(field.getModifiers())
                        && !Modifier.isStatic(field.getModifiers())) { // 是否是私有的，是否是静态的
                    // 非公共私有变量
                    String fieldName = StringUtils.capitalize(field.getName()); // 获取属性名称
                    int getIndex = methodAccess.getIndex("get" + fieldName); // 获取get方法的下标
                    int setIndex = methodAccess.getIndex("set" + fieldName); // 获取set方法的下标
                    methodIndexMap.put(orgi.getClass().getName() + "." + "get"
                            + fieldName, getIndex); // 将类名get方法名，方法下标注册到map中
                    methodIndexMap.put(orgi.getClass().getName() + "." + "set"
                            + fieldName, setIndex); // 将类名set方法名，方法下标注册到map中
                    fieldList.add(fieldName); // 将属性名称放入集合里
                }
            }
            fieldMap.put(orgi.getClass(), fieldList); // 将类名，属性名称注册到map中
            methodMap.put(orgi.getClass(), methodAccess);
            return methodAccess;
        }
    } 

执行1000000条效率80几毫秒，效率已经没问题了。

BeanUtils.copyProperties 使用注意

首先结论说在前头， BeanUtils.copyProperties 是浅拷贝 。

为什么今天我还想把这个BeanUtils.copyProperties 的使用拿出来军训。

因为我意识到了大家（部分）对深拷浅拷还是不清晰，不知道具体的影响。

示例演示

第一个类：

第二个类：

注意！！ 第二个类里面有使用第一个类。

开始进行示例

    public static void main(String[] args) {
        /**
         * 模拟数据 A  complexObject
         */
        ComplexObject complexObjectA=new ComplexObject();
        complexObjectA.setNickName("张一");
        SimpleObject simpleObject=new SimpleObject();
        simpleObject.setName("李四");
        simpleObject.setAge(12);
        complexObjectA.setSimpleObject(simpleObject);
        /**
         * 使用BeanUtils.copyProperties 拷贝 模拟数据 A 生成模拟数据 B
         */
        ComplexObject complexObjectB=new ComplexObject();
        BeanUtils.copyProperties(complexObjectA,complexObjectB);

        System.out.println("拷贝后，查看模拟数据A 和 模拟数据B ：");
        System.out.println(complexObjectA.getSimpleObject().toString());
        System.out.println(complexObjectB.getSimpleObject().toString());

        System.out.println("比较模拟数据A 和 模拟数据B 里面的引用对象simple 是否引用地址一样： ");
        System.out.println(complexObjectA.getSimpleObject()==complexObjectB.getSimpleObject()); 

        System.out.println("修改拷贝出来的模拟数据B里面的引用对象simple的属性 age 为 888888");
        complexObjectB.getSimpleObject().setAge(888888);

        System.out.println("修改后，观察原数据A 和拷贝出来的数据 B 里面引用的 对象 simple的属性 age:");
        System.out.println(complexObjectA.getSimpleObject().toString());
        System.out.println(complexObjectB.getSimpleObject().toString());
    }

最后强调

如果你是使用BeanUtils.copyProperties 进行对象的拷贝复制， 一定要注意！

• 第一点 、你所拷贝的对象内包不包含 其他对象的引用。
• 第二点、如果包含，那么接下来的方法里无论是操作原对象还是操作拷贝出来的对象是否涉及到 对 对象内 的 那个其他对象的 值的修改 。
• 第三点、如果涉及到， 修改了，会不会影响到其他方法 对 修改值的使用情况。

就如文中例子， 如果传入过来的一个复杂对象数据A 里面引用了一个 user对象年龄age是10；拷贝出一份数据B后， 操作 数据B的方法把 年龄age改成了88888；

那么后续其他方法用到数据A ，想用的是最初始的 age 为10 ，那么就用不到了，因为浅拷贝的原因受影响，age都变成88888 了。

ok，就提到这。以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们~