從來沒寫過泛型方法，這次項目中用到了。
泛型方法理解：
（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;
        }
    }