摘要：于是我建議這位小伙伴使用了進行屬性拷貝，這為我們的程序挖了一個坑阿里代碼規(guī)約當我們開啟阿里代碼掃描插件時，如果你使用了進行屬性拷貝，它會給你一個非常嚴重的警告。大名鼎鼎的提供的包，居然會存在性能問題，以致于阿里給出了嚴重的警告。

聲明：本文屬原創(chuàng)文章，始發(fā)于公號：程序員自學之道，并同步發(fā)布于 https://blog.csdn.net/dadiyang，特此，同步發(fā)布到 sf，轉(zhuǎn)載請注明出處。

有一次開發(fā)過程中，剛好看到一個小伙伴在調(diào)用 set 方法，將一個數(shù)據(jù)庫中查詢出來的 PO 對象的屬性拷貝到 Vo 對象中，類似這樣：

可以看出，Po 和 Vo 兩個類的字段絕大部分是一樣的，我們一個個地調(diào)用 set 方法只是做了一些重復的冗長的操作。這種操作非常容易出錯，因為對象的屬性太多，有可能會漏掉一兩個，而且肉眼很難察覺。

類似這樣的操作，我們可以很容易想到，可以通過反射來解決。其實，如此普遍通用的功能，一個 BeanUtils 工具類就可以搞定了。

于是我建議這位小伙伴使用了 Apache BeanUtils.copyProperties 進行屬性拷貝，這為我們的程序挖了一個坑！

當我們開啟阿里代碼掃描插件時，如果你使用了 Apache BeanUtils.copyProperties 進行屬性拷貝，它會給你一個非常嚴重的警告。因為，Apache BeanUtils性能較差，可以使用 Spring BeanUtils 或者 Cglib BeanCopier 來代替。

看到這樣的警告，有點讓人有點不爽。大名鼎鼎的 Apache 提供的包，居然會存在性能問題，以致于阿里給出了嚴重的警告。

那么，這個性能問題究竟是有多嚴重呢？畢竟，在我們的應(yīng)用場景中，如果只是很微小的性能損耗，但是能帶來非常大的便利性，還是可以接受的。

帶著這個問題。我們來做一個實驗，驗證一下。

如果對具體的測試方式?jīng)]有興趣，可以跳過直接看結(jié)果哦~

首先，為了測試方便，讓我們來定義一個接口，并將幾種實現(xiàn)統(tǒng)一起來：

public interface PropertiesCopier {
    void copyProperties(Object source, Object target) throws Exception;
}
public class CglibBeanCopierPropertiesCopier implements PropertiesCopier {
    @Override
    public void copyProperties(Object source, Object target) throws Exception {
        BeanCopier copier = BeanCopier.create(source.getClass(), target.getClass(), false);
        copier.copy(source, target, null);
    }
}
// 全局靜態(tài) BeanCopier，避免每次都生成新的對象
public class StaticCglibBeanCopierPropertiesCopier implements PropertiesCopier {
    private static BeanCopier copier = BeanCopier.create(Account.class, Account.class, false);
    @Override
    public void copyProperties(Object source, Object target) throws Exception {
        copier.copy(source, target, null);
    }
}
public class SpringBeanUtilsPropertiesCopier implements PropertiesCopier {
    @Override
    public void copyProperties(Object source, Object target) throws Exception {
        org.springframework.beans.BeanUtils.copyProperties(source, target);
    }
}
public class CommonsBeanUtilsPropertiesCopier implements PropertiesCopier {
    @Override
    public void copyProperties(Object source, Object target) throws Exception {
        org.apache.commons.beanutils.BeanUtils.copyProperties(target, source);
    }
}
public class CommonsPropertyUtilsPropertiesCopier implements PropertiesCopier {
    @Override
    public void copyProperties(Object source, Object target) throws Exception {
        org.apache.commons.beanutils.PropertyUtils.copyProperties(target, source);
    }
}

然后寫一個參數(shù)化的單元測試：

@RunWith(Parameterized.class)
public class PropertiesCopierTest {
    @Parameterized.Parameter(0)
    public PropertiesCopier propertiesCopier;
    // 測試次數(shù)
    private static List testTimes = Arrays.asList(100, 1000, 10_000, 100_000, 1_000_000);
    // 測試結(jié)果以 markdown 表格的形式輸出
    private static StringBuilder resultBuilder = new StringBuilder("|實現(xiàn)|100|1,000|10,000|100,000|1,000,000|
").append("|----|----|----|----|----|----|
");

    @Parameterized.Parameters
    public static Collection data() {
        Collection params = new ArrayList<>();
        params.add(new Object[]{new StaticCglibBeanCopierPropertiesCopier()});
        params.add(new Object[]{new CglibBeanCopierPropertiesCopier()});
        params.add(new Object[]{new SpringBeanUtilsPropertiesCopier()});
        params.add(new Object[]{new CommonsPropertyUtilsPropertiesCopier()});
        params.add(new Object[]{new CommonsBeanUtilsPropertiesCopier()});
        return params;
    }

    @Before
    public void setUp() throws Exception {
        String name = propertiesCopier.getClass().getSimpleName().replace("PropertiesCopier", "");
        resultBuilder.append("|").append(name).append("|");
    }

    @Test
    public void copyProperties() throws Exception {
        Account source = new Account(1, "test1", 30D);
        Account target = new Account();
        // 預熱一次
        propertiesCopier.copyProperties(source, target);
        for (Integer time : testTimes) {
            long start = System.nanoTime();
            for (int i = 0; i < time; i++) {
                propertiesCopier.copyProperties(source, target);
            }
            resultBuilder.append((System.nanoTime() - start) / 1_000_000D).append("|");
        }
        resultBuilder.append("
");
    }

    @AfterClass
    public static void tearDown() throws Exception {
        System.out.println("測試結(jié)果：");
        System.out.println(resultBuilder);
    }
}

時間單位毫秒

結(jié)果表明，Cglib 的 BeanCopier 的拷貝速度是最快的，即使是百萬次的拷貝也只需要 10 毫秒！
相比而言，最差的是 Commons 包的 BeanUtils.copyProperties 方法，100 次拷貝測試與表現(xiàn)最好的 Cglib 相差 400 倍之多。百萬次拷貝更是出現(xiàn)了 2800 倍的性能差異！

結(jié)果真是讓人大跌眼鏡。

但是它們?yōu)槭裁磿羞@么大的差異呢？

查看源碼，我們會發(fā)現(xiàn) CommonsBeanUtils 主要有以下幾個耗時的地方：

輸出了大量的日志調(diào)試信息

重復的對象類型檢查

類型轉(zhuǎn)換

  public void copyProperties(final Object dest, final Object orig)
        throws IllegalAccessException, InvocationTargetException {
        // 類型檢查 
        if (orig instanceof DynaBean) {
            ...
        } else if (orig instanceof Map) {
           ...
        } else {
            final PropertyDescriptor[] origDescriptors = ...
            for (PropertyDescriptor origDescriptor : origDescriptors) {
                ...
                // 這里每個屬性都調(diào)一次 copyProperty
                copyProperty(dest, name, value);
            }
        }
    }

    public void copyProperty(final Object bean, String name, Object value)
        throws IllegalAccessException, InvocationTargetException {
        ...
        // 這里又進行一次類型檢查
        if (target instanceof DynaBean) {
            ...
        }
        ...
        // 需要將屬性轉(zhuǎn)換為目標類型
        value = convertForCopy(value, type);
        ...
    }
    // 而這個 convert 方法在日志級別為 debug 的時候有很多的字符串拼接
    public  T convert(final Class type, Object value) {
        if (log().isDebugEnabled()) {
            log().debug("Converting" + (value == null ? "" : " "" + toString(sourceType) + """) + " value "" + value + "" to type "" + toString(targetType) + """);
        }
        ...
        if (targetType.equals(String.class)) {
            return targetType.cast(convertToString(value));
        } else if (targetType.equals(sourceType)) {
            if (log().isDebugEnabled()) {
                log().debug("No conversion required, value is already a " + toString(targetType));
            }
            return targetType.cast(value);
        } else {
            // 這個 convertToType 方法里也需要做類型檢查
            final Object result = convertToType(targetType, value);
            if (log().isDebugEnabled()) {
                log().debug("Converted to " + toString(targetType) + " value "" + result + """);
            }
            return targetType.cast(result);
        }
    }

具體的性能和源碼分析，可以參考這幾篇文章：

幾種copyProperties工具類性能比較：https://www.jianshu.com/p/bcb...

CGLIB中BeanCopier源碼實現(xiàn)：https://www.jianshu.com/p/f8b...

Java Bean Copy框架性能對比：https://yq.aliyun.com/article...

除了性能問題之外，在使用 CommonsBeanUtils 時還有其他的坑需要特別小心！

在進行屬性拷貝時，雖然 CommonsBeanUtils 默認不會給原始包裝類賦默認值的，但是在使用低版本(1.8.0及以下)的時候，如果你的類有 Date 類型屬性，而且來源對象中該屬性值為 null 的話，就會發(fā)生異常：

org.apache.commons.beanutils.ConversionException: No value specified for "Date"

解決這個問題的辦法是注冊一個 DateConverter：

ConvertUtils.register(new DateConverter(null), java.util.Date.class);

然而這個語句，會導致包裝類型會被賦予原始類型的默認值，如 Integer 屬性默認賦值為 0，盡管你的來源對象該字段的值為 null。

在高版本(1.9.3)中，日期 null 值的問題和包裝類賦默認值的問題都被修復了。

這個在我們的包裝類屬性為 null 值時有特殊含義的場景，非常容易踩坑！例如搜索條件對象，一般 null 值表示該字段不做限制，而 0 表示該字段的值必須為0。

當我們看到阿里的提示，或者你看了這篇文章之后，知道了 CommonsBeanUtils 的性能問題，想要改用 Spring 的 BeanUtils 時，要小心：

org.apache.commons.beanutils.BeanUtils.copyProperties(Object target, Object source);
org.springframework.beans.BeanUtils.copyProperties(Object source, Object target);

從方法簽名上可以看出，這兩個工具類的名稱相同，方法名也相同，甚至連參數(shù)個數(shù)、類型、名稱都相同。但是參數(shù)的位置是相反的。因此，如果你想更改的時候，千萬要記得，將 target 和 source 兩個參數(shù)也調(diào)換過來！

另外，可能由于種種原因，你獲取的堆棧信息不完整找不到問題在哪，所以這里順便提醒一下：

如果你遇到 java.lang.IllegalArgumentException: Source must not be null 或者 java.lang.IllegalArgumentException: Target must not be null 這樣的異常信息卻到處找不到原因時，不用找了，這是由于你在 copyProperties 的時候傳了 null 值導致的。