从来没写过泛型方法，这次项目中用到了。
泛型方法理解：
（1）对比泛型类，List<E>，我的理解是：泛型为了防止不必要的强制类型转换，降低出错几率。
（2）public static <T> void verifyObject(T actualObject, T expectObject, List<Object> ignore) {...}
传给这个方法什么类型，它就是什么类型，不需要类型转换。
如果此处换成verifyObject(Object actualObject)... 使用时可能需要强制类型转换

    /**
     * 比较两个list中每个对象的每个属性（被忽略的除外）的值是否一致
     * @param actualObject
     * @param expectObject
     * @param ignore
     */
    public static <T> void verifyObject(T actualObject, T expectObject, List<Object> ignore) {
        try {
            List<Object> actualList = new ArrayList<Object>();
            List<Object> expectList = new ArrayList<Object>();
            // 判断actualObject的类型，如果是List，就强制转换成List，如果不是，就放到一个List里面
            if(actualObject instanceof List && expectObject instanceof List) {
                actualList = (List<Object>)actualObject;
                expectList = (List<Object>)expectObject;
            } else {
                actualList.add(actualObject);
                expectList.add(expectObject);
            }
            // 如果为空，不校验
            if((actualList == null && expectList == null)) {
                return ;
            } else {
                for(int j=0; j<actualList.size(); j++) {
                    Object actual = actualList.get(j);
                    Object expect = expectList.get(j);
                    if(actual == null && expect == null) {
                        return ;
                    }
                    verifySingleObject(actual, expect, ignore);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            String errorMessage = "表里的记录和预期记录验证不一致";
            Assert.fail(errorMessage);
        }
    }
    
    /**
     * 比较两个对象的属性值是否一致
     * @param actual
     * @param expect
     * @param ignore
     */
    private static void verifySingleObject(Object actual, Object expect, List<Object> ignore) {
        try {
            Class cla = actual.getClass();
            Field[] actualFields = actual.getClass().getDeclaredFields();
            Field[] expectFields = expect.getClass().getDeclaredFields();
            // 遍历get方法
            for(Field f : actualFields) {
                pd = new PropertyDescriptor(f.getName(), cla);
                getMethod = pd.getReadMethod();
                if(ignore==null || ignore.contains(getMethod.invoke(actual))) {
                    Assert.assertEquals(getMethod.invoke(actual), getMethod.invoke(expect), 
                            "["+getMethod.getName()+"]实际值："+getMethod.invoke(actual) + "和预期值：" + getMethod.invoke(expect) + "验证不一致");
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage());
            String errorMessage = "表里的记录和预期记录验证不一致";
            Assert.fail(errorMessage);
        }finally{
            pd = null;
            getMethod =null;
        }
    }