Apache Commons BeanUtils 笔记

package me.test.beanutils;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * 测试环境：
 * BeanUtils ：1.8.3
 *
 * 结论：
 *   1.8.3版本的BeanUtils可以读取一个Bean进行任意层次的属性值。
 * 但是对于写入，若某个Bean的所有属性都是null，则BeanUtils只能对基本数据类型、
 * 基本数据类型的数组类型，List类型的属性进行实例化，然后再赋值；
 * 对于其他类型（如Map，自定义JavaBean类型的属性）则不进行实例化，进而无法赋值。
 * 但是如果你事先先将这些复杂类型的变量示例化好了之后，则可以进行赋值。
 *
 * 背景：
 *    都不知道业界同类现在在做Java Web项目的时候，都在使用什么框架。不过，偶现在还在
 * 使用Struts 1.2.9。是不是太老旧了些？？
 * 想起些JSP页面，那个叫头疼啊，各种自定义JSP标签（Struts的一堆），JS脚本，CSS式样，
 * HTML标签，恶心死了，都。
 *    决定，自己慢慢尝试不使用JSP扩展标签的路线。比如：Restful + JS框架？ without JSP？？
 *    哦，题外话了。回到正题吧。
 *
 *    还是那个Struts。遇到一个业务，先查询到一个记录的List，List中的每个元素都是自己定义的POJO，
 * 然后呈现到JSP页面上，但是，需要允许用户修改部分记录的几个值。
 * 不过，这里的ActionForm都是使用Struts的DynamicActionForm的。
 * Struts 会自动从request中取得参数，然后将参数填充到动态form的基本数据类型和基本数据类型的数组类型的字段里，
 * 对于其他复杂类型的字段，比如List、Map、或自定义Javabean，Struts不会为其创建对象实例，
 * 因此，request中的参数也无法填充到这些动态Form的级联属性中。
 *
 *    但是，假若我执行完查询，我负责将这些复杂属性初始化，并将Form的Scope设为Session，
 * 然后在下一次提交时，能够通过参数修改这里复杂属性中的属性值？
 *
 *    看了下Struts的源码，在RequestUtils#populate()方法中使用了 Appache Commons BeanUtils
 * 中  BeanUtils#populate(Object bean, Map properties) 方法。在Struts中，bean指的是
 * Struts创建/从指定作用域取得的ActionForm，properties则指的是request中的参数。
 *
 *    看来，上述疑问能否解答，就看BeanUtils行不行啦。趁机也认真学习下BeanUtils。
 *
 * 参考：
 *
 *
 * PS : Struts 1.2.9 使用的是BeanUtils的版本是 1.7.0，可是在最初的测试时发现该版本不少问题，
 * 瞅了瞅Apache官网的archive站点，返现1.7.0版本是2004年8月发布的呢，可真有些年头了。
 * 后来，使用了最新的 1.8.3进行测试。如果你还在使用Struts 1.2.9，可以更新其中的
 * Commons BeanUtils的jar包，或使用Struts 1.X 的最新版 1.3.10。
 *
 * BeanUtils 1.7.0 的部分问题：
 * 0. 对于Map类型的成员变量，BeanUtils总是先尝试将Map填充为 Map 类型。
 * 1. 对于Map类型的成员变量，如果重新的值为 String[]，则只会使用第一个数组元素的值，而不是使用整个数组，
 *    且数组长度不可以为0，否则报 java.lang.ArrayIndexOutOfBound***ception: 0
 * 2. 对于Map类型的成员变量，将无法使用 "." "[]"等级联表达式设置新值。
 *
 *
 */
public class JavaBeanTest {

    public static class Person {
        private String name = "";
        private int age = 0;
        private String[] alias = null;
        private List<String> hobby = null;
        private List<Person> friends = null;

        // 如果默认为null，则 "IllegalArgumentException: Null property value for 'addr'"
        // 因为Map是一个接口，BeanUtils不知道该使用哪一个实现类来实例化。
        private Map<String, String> addr = new LinkedHashMap<String, String>(); // 需要事先手动实例化好
        private Map<String, Object[]> friendGroups = new LinkedHashMap<String, Object[]>(); // 需要事先手动实例化好
        private Person father = null;

        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 String[] getAlias() {
            return alias;
        }
        public void setAlias(String[] alias) {
            this.alias = alias;
        }
        public List<String> getHobby() {
            return hobby;
        }
        public void setHobby(List<String> hobby) {
            this.hobby = hobby;
        }
        public List<Person> getFriends() {
            return friends;
        }
        public void setFriends(List<Person> friends) {
            this.friends = friends;
        }
        public Map<String, String> getAddr() {
            return addr;
        }
        public void setAddr(Map<String, String> addr) {
            this.addr = addr;
        }
        public Map<String, Object[]> getFriendGroups() {
            return friendGroups;
        }
        public void setFriendGroups(Map<String, Object[]> friendGroups) {
            this.friendGroups = friendGroups;
        }
        public Person getFather() {
            return father;
        }
        public void setFather(Person father) {
            this.father = father;
        }
    }

    /**
     * 建立测试环境
     */
    @Before
    public void setUp() throws Exception {
    }

    /**
     * 清理测试环境
     */
    @After
    public void tearDown() {
    }

    /**
     * 写入基本数据类型 —— String
     */
    @Test
    public void testPopulate01() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();
        Map<String, Object> props = new LinkedHashMap<String, Object>();
        props.put("name", "Zhang3");

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果
        TestCase.assertEquals("Zhang3", person.getName());

        // ■ 验证环境
    }

    /**
     * 写入基本数据类型 —— Integer，
     * 但是实际JavaBean声明的是String，这时，由BeanUtils自动完成类型转换。
     */
    @Test
    public void testPopulate02() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();
        Map<String, Object> props = new LinkedHashMap<String, Object>();
        props.put("name", 111);

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果
        TestCase.assertEquals("111", person.getName());

        // ■ 验证环境
    }

    /**
     * 写入基本数据类型 —— String
     * 注意：如果写入的基本数据类型是String，则写入的变量可以是一个String[]，
     * 但是只使用第一个元素的值。
     *
     * 在Struts 1.3.9 中，在没有上传文件的情况下，就总是每个参数使用
     * request.getParameterValues(name) 获取一个String[]的。
     */
    @Test
    public void testPopulate03() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();
        Map<String, Object> props = new LinkedHashMap<String, Object>();
        props.put("name", new String[]{"Zhang3", "Zhang4"});

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果
        TestCase.assertEquals("Zhang3", person.getName());

        // ■ 验证环境
    }

    /**
     * 写入基本数据类型 —— Integer，
     */
    @Test
    public void testPopulate04() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();
        Map<String, Object> props = new LinkedHashMap<String, Object>();
        props.put("age", new String[]{"111", "222"});

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果
        TestCase.assertEquals(111, person.getAge());

        // ■ 验证环境
    }

    /**
     * 写入基本数据类型的数组 —— String[]
     * 由于此时能通过反射机制获取JavaBean声明的实际类型就是 String[]，
     * 此时，就原原本本的赋值过去。
     */
    @Test
    public void testPopulate05() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();
        Map<String, Object> props = new LinkedHashMap<String, Object>();
        props.put("alias", new String[]{"DaXingXing", "XiaoZhang"});

        // ■ 执行
        //
        BeanUtils.populate(person, props);

        // ■ 验证结果
        TestCase.assertEquals(2, person.getAlias().length);
        TestCase.assertEquals("DaXingXing", person.getAlias()[0]);
        TestCase.assertEquals("XiaoZhang", person.getAlias()[1]);

        // ■ 验证环境
    }

    /**
     * 写入List —— VALUE : String。
     * 注意：由于泛型信息在编译后丢失，所以使用时需要注意写入变量的类型
     * 需与POJO对应属性声明的类型保持一致。
     */
    @Test
    public void testPopulate06() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();
        Map<String, Object> props = new LinkedHashMap<String, Object>();

        List<Object> hobby = new ArrayList<Object>();
        hobby.add("basketball");
        hobby.add("ride");
        // java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
        // hobby.add(111);

        // 不能使用String[]，否则java.lang.IllegalArgumentException:... argument type mismatch
        // 因此，在使用Struts的动态Form的时候，如果用来接收表单中的数组值的话，
        // 该属性只能声明为数组类型，而不能是List类型。
        //props.put("hobby", new String[]{"basketball", "ride"});
        props.put("hobby", hobby);

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果
        TestCase.assertEquals(2, person.getHobby().size());
        TestCase.assertEquals("basketball", person.getHobby().get(0));
        TestCase.assertEquals("ride", person.getHobby().get(1));
        //TestCase.assertEquals("111", person.getHobby().get(2));

        // ■ 验证环境
    }

    /**
     * 写入List —— VALUE : Person。
     * 说明：这种情况一般是在Struts中自己的将大量查询结构设置到Form中，
     * 然后呈现给用户。但是假如允许用户级联修改其中个别值时，该如何做？
     */
    @Test
    public void testPopulate07() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        // 先构模拟构建查询后的结果列表，这里的Person相当于Struts中的ActionForm。
        List<Person> friends = new LinkedList<Person>();
        Person friend = new Person();
        friend.setName("F1");
        friend.setAge(21);
        friend.setAlias(new String[]{"AA", "BB"});
        friends.add(friend);
        friend = new Person();
        friend.setName("F2");
        friend.setAge(22);
        friend.setAlias(new String[]{"XX", "YY"});
        friends.add(friend);

        Person person = new Person();
        person.setName("Zhang3");
        person.setAge(23);
        person.setFriends(friends);

        // 模拟构建JSP页面用户修改的部分值
        Map<String, Object> props = new LinkedHashMap<String, Object>();
        props.put("friends[0].alias", new String[]{"BB", "CC"});

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果

        // 需要改变的被改变，不需要改变的仍然没有变
        TestCase.assertEquals("Zhang3", person.getName());
        TestCase.assertEquals(23, person.getAge());
        friends = person.getFriends();
        TestCase.assertEquals(2, friends.size());

        friend = friends.get(0);
        TestCase.assertEquals("F1", friend.getName());
        TestCase.assertEquals(21, friend.getAge());
        String[] alias = friend.getAlias();
        TestCase.assertEquals(2, alias.length);
        TestCase.assertEquals("BB", alias[0]);
        TestCase.assertEquals("CC", alias[1]);

        friend = friends.get(1);
        TestCase.assertEquals("F2", friend.getName());
        TestCase.assertEquals(22, friend.getAge());
        alias = friend.getAlias();
        TestCase.assertEquals(2, alias.length);
        TestCase.assertEquals("XX", alias[0]);
        TestCase.assertEquals("YY", alias[1]);

        // ■ 验证环境
    }

    /**
     * 写入Map —— KEY : String, VALUE : String。
     * 注意：由于泛型信息在编译后丢失，所以使用时需要注意写入变量的类型
     * 需与POJO对应属性声明的类型保持一致，否则，如下所示，可能会出现一些意外。
     */
    @Test
    public void testPopulate08() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();
        Map<String, Object> props = new LinkedHashMap<String, Object>();

        // 对于Map，不能使用"addr.birth"，只能使用"addr(birth)"
        props.put("addr( birth )", "AA");
        // BeanUtils 1.7.0 OK, 但是 1.8.0 则在从Map中取值的时候出现 ClassCastException，
        // props.put("addr(nurserySchool)", (Integer) 111);
        // props.put("addr(primarySchool)", false);
        // props.put("addr(juniorHighSchool)", new String[]{"BB", "CC"});

        // java.lang.ClassCastException: [Ljava.lang.Integer; cannot be cast to java.lang.String
        //props.put("addr(seniorHighSchool)", new Integer[]{ 111});

        // java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.String
        //props.put("addr(university)", new Object());

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果
        Map<String, String> addr = person.getAddr();

        TestCase.assertEquals(1, addr.size());

        // 注意：KEY前后有空格，因为在props.put()的时候，就有空格。
        TestCase.assertEquals("AA", addr.get(" birth "));

        // 注意：通过DEBUG可以看到addr内部实际存储的还是 Integer类型，
        //TestCase.assertEquals("111", addr.get("nurserySchool"));  // BeanUtils 1.7.0  通过
        //TestCase.assertEquals("false", addr.get("primarySchool"));// BeanUtils 1.7.0  通过
        //TestCase.assertEquals("BB", addr.get("juniorHighSchool"));// BeanUtils 1.7.0  通过
        //TestCase.assertEquals("[Ljava.lang.Integer;@TESTTEST?", addr.get("seniorHighSchool")); // BeanUtils 1.7.0 不通过
        //TestCase.assertEquals("java.lang.Object@TESTTEST", addr.get("university")); // BeanUtils 1.7.0 不通过

        // ■ 验证环境
    }

    /**
     * 写入Map —— KEY : String, VALUE : (Object)Array。
     */
    @Test
    public void testPopulate09() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();

        Map<String, Object> props = new LinkedHashMap<String, Object>();

        // 在 BeanUitls 1.7.0 中：
        // 不管自定义的JavaBean中的Map属性的类型是什么，
        // 如果Map某个Key的值是 String[]，则只取第一个值，
        // 好在1.8.3版本中，对Map 中填充的值不再进行类型转换了。
        props.put("friendGroups(family)", new String[]{"Zhang1", "Zhang2"});
        props.put("friendGroups(colleague)", new Object[]{"Wang2", "Li2"});

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果

        Map<String, Object[]> friendGroups = person.getFriendGroups();
        TestCase.assertEquals(2, friendGroups.size());
        TestCase.assertEquals(2, friendGroups.get("family").length);
        TestCase.assertEquals("Zhang1", friendGroups.get("family")[0]);
        TestCase.assertEquals("Zhang2", friendGroups.get("family")[1]);

        TestCase.assertEquals(2, friendGroups.get("colleague").length);
        TestCase.assertEquals("Wang2", friendGroups.get("colleague")[0]);
        TestCase.assertEquals("Li2", friendGroups.get("colleague")[1]);

        // ■ 验证环境
    }

    /**
     * 写入Map —— KEY : String, VALUE : (Object)Array。
     */
    @SuppressWarnings("unchecked")
    @Test
    public void testPopulate10() throws Exception {

        // ■ 准备环境
        // 初始化已有值的JavaBean/Form

        // Map(TEST) —— Object[]
        Object[] objArr = new Object[3];

        // Map(TEST)[0] —— Person
        Person p = new Person();
        p.setName("F0");
        p.setAge(20);
        p.setAlias(new String[]{"00", "11"});
        objArr[0] = p;

        // Map(TEST)[1] —— List
        List<Person> pList = new LinkedList<Person>();

        p = new Person();
        p.setName("F1");
        p.setAge(21);
        p.setAlias(new String[]{"AA", "BB"});
        pList.add(p);

        p = new Person();
        p.setName("F2");
        p.setAge(22);
        p.setAlias(new String[]{"XX", "YY"});
        pList.add(p);
        objArr[1] = pList;

        // Map(TEST)[1] —— Map
        Map<String, Person> pMap = new LinkedHashMap<String, Person>();
        p = new Person();
        p.setName("F4");
        p.setAge(24);
        p.setAlias(new String[]{"44", "55"});
        pMap.put("F4", p);

        p = new Person();
        p.setName("F5");
        p.setAge(25);
        p.setAlias(new String[]{"55", "66"});
        pMap.put("F5", p);
        objArr[2] = pMap;

        Map<String, Object[]> friendGroups = new LinkedHashMap<String, Object[]>();
        friendGroups.put("TEST", objArr);
        System.out.println(friendGroups.hashCode());
        Person person = new Person();
        person.setName("Zhang3");
        person.setAge(23);
        person.setFriendGroups(friendGroups);

        // ■ 准备参数
        // 初始化要更新的参数
        Map<String, Object> props = new LinkedHashMap<String, Object>();
        props.put("friendGroups(TEST)[0].age", 999);
        props.put("friendGroups(TEST)[1][0].alias[0]", "A1");
        props.put("friendGroups(TEST)[2](F4).alias", new String[]{"404", "505"});

        // ■ 执行
        BeanUtils.populate(person, props);
        System.out.println("========"
                + PropertyUtils.getProperty(person, "friendGroups").hashCode());
        //System.out.println(((Person)BeanUtils.getProperty(person, "friendGroups(TEST)[0]")).getAge());
        // ■ 验证结果
        TestCase.assertEquals("Zhang3", person.getName());
        TestCase.assertEquals(23, person.getAge());

        friendGroups = person.getFriendGroups();
        TestCase.assertEquals(1, friendGroups.size());

        // Map(TEST) —— Object[]
        objArr = friendGroups.get("TEST");
        TestCase.assertEquals(3, objArr.length);

        // Map(TEST)[0] —— Person
        p = (Person) objArr[0];
        TestCase.assertEquals("F0", p.getName());
        TestCase.assertEquals(999, p.getAge());
        String[] alias = p.getAlias();
        TestCase.assertEquals(2, alias.length);
        TestCase.assertEquals("00", alias[0]);
        TestCase.assertEquals("11", alias[1]);

        // Map(TEST)[1] —— List
        pList = (List<Person>) objArr[1];
        TestCase.assertEquals(2, pList.size());

        p = pList.get(0);
        TestCase.assertEquals("F1", p.getName());
        TestCase.assertEquals(21, p.getAge());
        alias = p.getAlias();
        TestCase.assertEquals(2, alias.length);
        TestCase.assertEquals("A1", alias[0]);
        TestCase.assertEquals("BB", alias[1]);

        p = pList.get(1);
        TestCase.assertEquals("F2", p.getName());
        TestCase.assertEquals(22, p.getAge());
        alias = p.getAlias();
        TestCase.assertEquals(2, alias.length);
        TestCase.assertEquals("XX", alias[0]);
        TestCase.assertEquals("YY", alias[1]);

        // Map(TEST)[1] —— Map
        pMap = (Map<String, Person>) objArr[2];
        TestCase.assertEquals(2, pMap.size());

        p = pMap.get("F4");
        TestCase.assertEquals("F4", p.getName());
        TestCase.assertEquals(24, p.getAge());
        alias = p.getAlias();
        TestCase.assertEquals(2, alias.length);
        TestCase.assertEquals("404", alias[0]);
        TestCase.assertEquals("505", alias[1]);

        p = pMap.get("F5");
        TestCase.assertEquals("F5", p.getName());
        TestCase.assertEquals(25, p.getAge());
        alias = p.getAlias();
        TestCase.assertEquals(2, alias.length);
        TestCase.assertEquals("55", alias[0]);
        TestCase.assertEquals("66", alias[1]);

        // ■ 验证环境
    }

    /**
     * 写入Person
     */
    @Test
    public void testPopulate11() throws Exception {

        // ■ 准备环境

        // ■ 准备参数
        Person person = new Person();

        Map<String, Object> props = new LinkedHashMap<String, Object>();
        person.setFather(new Person()); // 需要事先手动实例化好
        props.put("father.name", new String[]{"Zhang1", "Zhang2"});

        // ■ 执行
        BeanUtils.populate(person, props);

        // ■ 验证结果
        TestCase.assertEquals("Zhang1", person.getFather().getName());

        // ■ 验证环境
    }
}