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

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

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

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

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

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

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

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

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

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

如果對具體的測試方式沒有興趣，可以跳過直接看結果哦~

首先，為了測試方便，讓我們來定義一個接口，并將幾種實現統一起來：

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);
    }
}
// 全局靜態 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);
    }
}

然后寫一個參數化的單元測試：

@RunWith(Parameterized.class)
public class PropertiesCopierTest {
    @Parameterized.Parameter(0)
    public PropertiesCopier propertiesCopier;
    // 測試次數
    private static List testTimes = Arrays.asList(100, 1000, 10_000, 100_000, 1_000_000);
    // 測試結果以 markdown 表格的形式輸出
    private static StringBuilder resultBuilder = new StringBuilder("|實現|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("測試結果：");
        System.out.println(resultBuilder);
    }
}

時間單位毫秒

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

結果真是讓人大跌眼鏡。

但是它們為什么會有這么大的差異呢？

查看源碼，我們會發現 CommonsBeanUtils 主要有以下幾個耗時的地方：

輸出了大量的日志調試信息

重復的對象類型檢查

類型轉換

  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) {
                ...
                // 這里每個屬性都調一次 copyProperty
                copyProperty(dest, name, value);
            }
        }
    }

    public void copyProperty(final Object bean, String name, Object value)
        throws IllegalAccessException, InvocationTargetException {
        ...
        // 這里又進行一次類型檢查
        if (target instanceof DynaBean) {
            ...
        }
        ...
        // 需要將屬性轉換為目標類型
        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源碼實現：https://www.jianshu.com/p/f8b...

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

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

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

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);

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

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

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