作為一個新員工，一個首要的工作就是閱讀別人的代碼，閱讀代碼的諸多好處就不說了，我就直奔主題，通過預讀代碼，發現了幾種實現兩個不同類型的Bean之間實現值復制的幾種方式，上網查詢后發現性能上會有差異，于是就萌生自己深入了解幾種實現的想法。第一步就是先本著實事求是的原則去探求一下大家總結出來的性能差異是否正確。

比較的是四種復制的方式，分別為Apache的BeanUtils和PropertyUtils,Spring的BeanUtils,Cglib的BeanCopier。做法是在Eclipse新建了一個Project，專門用于專門測試幾種代碼的性能。具體的代碼如下：

一個FromBean和一個ToBean，兩個的代碼基本上一樣，除了類名稱不一樣，所以只是貼出來了一份。 

public class FromBean {  
    private String name;  
    private int age;  
    private String address;  
    private String idno;  
    private double money;   
    public double getMoney() {  
        return money;  
    }   
    public void setMoney(double money) {  
        this.money = money;  
    }  
    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 getAddress() {  
        return address;  
    }  
    public void setAddress(String address) {  
        this.address = address;  
    }  
    public String getIdno() { 
         return idno;  
    } 
    public void setIdno(String idno) {  
        this.idno = idno;  
    }   
} 

一個用于測試的BenchmarkTest類，為了減少重復代碼，寫了一個策略模式 

public class BenchmarkTest {  
    private int count;  
    public BenchmarkTest(int count) {  
        this.count = count;  
        System.out.println("性能測試" + this.count + "==================");  
    }  
    public void benchmark(IMethodCallBack m, FromBean frombean) {  
        try {  
            long begin = new java.util.Date().getTime();  
            ToBean tobean = null;  
            System.out.println(m.getMethodName() + "開始進行測試");  
            for (int i = 0; i < count; i++) {  
                tobean = m.callMethod(frombean);  
            }  
            long end = new java.util.Date().getTime();  
            System.out.println(m.getMethodName() + "耗時" + (end - begin));  
            System.out.println(tobean.getAddress());  
            System.out.println(tobean.getAge());  
            System.out.println(tobean.getIdno());  
            System.out.println(tobean.getMoney());  
            System.out.println(tobean.getName());  
            System.out.println("                                      ");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
} 

策略中使用的接口聲明 

public interface IMethodCallBack {  
    String getMethodName();  
    ToBean callMethod(FromBean frombean)  throws Exception;  
} 

使用的測試類 

public class TestMain {  
    /**  
     * @param args  
     */  
    public static void main(String[] args) {  
        FromBean fb = new FromBean();  
        fb.setAddress("北京市朝陽區大屯路");  
        fb.setAge(20);  
        fb.setMoney(30000.111);  
        fb.setIdno("110330219879208733");  
        fb.setName("測試");  
        IMethodCallBack beanutilCB = new IMethodCallBack() {  
            @Override  
            public String getMethodName() {  
                return "BeanUtil.copyProperties";  
            }  
            @Override  
            public ToBean callMethod(FromBean frombean) throws Exception {  
                ToBean toBean = new ToBean();  
                BeanUtils.copyProperties(toBean, frombean);  
                return toBean;  
            }  
        };  
        IMethodCallBack propertyCB = new IMethodCallBack() {  
            @Override  
            public String getMethodName() {  
                return "PropertyUtils.copyProperties";  
            }  
            @Override  
            public ToBean callMethod(FromBean frombean) throws Exception {  
                ToBean toBean = new ToBean();  
                PropertyUtils.copyProperties(toBean, frombean);  
                return toBean;  
            }  
        };  
        IMethodCallBack springCB = new IMethodCallBack() {  
            @Override  
            public String getMethodName() {  
                return "org.springframework.beans.BeanUtils.copyProperties";  
            }  
            @Override  
            public ToBean callMethod(FromBean frombean) throws Exception {  
                ToBean toBean = new ToBean();  
                org.springframework.beans.BeanUtils.copyProperties(frombean,  
                        toBean);  
                return toBean;  
            }  
        };  
        IMethodCallBack cglibCB = new IMethodCallBack() {  
            BeanCopier bc = BeanCopier.create(FromBean.class, ToBean.class,  
                    false);  
            @Override 
             public String getMethodName() {  
                return "BeanCopier.create";  
            }  
            @Override  
            public ToBean callMethod(FromBean frombean) throws Exception {  
                ToBean toBean = new ToBean();  
                bc.copy(frombean, toBean, null);  
                return toBean;  
            }  
        };  
        // 數量較少的時候，測試性能  
        BenchmarkTest bt = new BenchmarkTest(10);  
        bt.benchmark(beanutilCB, fb);  
        bt.benchmark(propertyCB, fb);  
        bt.benchmark(springCB, fb);  
        bt.benchmark(cglibCB, fb);  
        // 測試一萬次性能測試  
        BenchmarkTest bt10000 = new BenchmarkTest(10000);  
        bt10000.benchmark(beanutilCB, fb);  
        bt10000.benchmark(propertyCB, fb);  
        bt10000.benchmark(springCB, fb);  
        bt10000.benchmark(cglibCB, fb);  
        // 擔心因為順序問題影響測試結果  
        BenchmarkTest bt1000R = new BenchmarkTest(10000);  
        bt1000R.benchmark(cglibCB, fb);  
        bt1000R.benchmark(springCB, fb);  
        bt1000R.benchmark(propertyCB, fb);  
        bt1000R.benchmark(beanutilCB, fb);  
    }  
} 

進行了三次測試，最后的結果如下：

不過需要注意的是，Cglib在測試的時候，先進行了實例的緩存，這個也是他性能較好的原因之一。如果把緩存去掉的話，性能就會出現了一些的差異，但是整體的性能還是很好，不過奇怪的是10000次反而比10次少，而且后面的反轉1萬次反而耗時最少，進行多次測試效果也是如此。

從整體的表現來看，Cglib的BeanCopier的性能是最好的無論是數量較大的1萬次的測試，還是數量較少10次，幾乎都是趨近與零損耗，Spring是在次數增多的情況下，性能較好，在數據較少的時候，性能比PropertyUtils的性能差一些。

PropertyUtils的性能相對穩定，表現是呈現線性增長的趨勢。而Apache的BeanUtil的性能最差，無論是單次Copy還是大數量的多次Copy性能都不是很好。

性能測試就到這里，數據也展示如上，后續會繼續編寫剩余兩篇文章，這一片關注性能，后面的一篇是就每種方式的使用上的差異進行詳解，最后一篇想進行探討是什么早就了這四種方式的性能差異。