Java的一個高效能快速深拷貝方法。Cloneable?

標籤：查詢   sar   資料   儲存   原來   interface   equals   isarray   類型   

本人在設計資料庫緩衝層的時候，需要對資料進行深拷貝，這樣使用者操作的資料對象就是不共用的。

這個思路實際上和Erlang類似，就是用資料不共用解決並發問題。

 

1. 序列化？

原來的做法，是用序列化，我用了Json的序列化，lib-json。一個再傳統不過的方法。把資料欄位序列化成json儲存。取出來的時候進行還原序列化。

測試100條資料，100次迴圈，竟然TM的用了15秒。

這個是個啥概念？簡直慘不忍睹。

於是網上搜，找到個Jackson，號稱效能XXX的，比Google的gson高XXX。

替換之後，速度下降到3700ms。恩。有那麼點意思。

但是才100次全查詢，消耗了接近4秒，不可接受。

備忘：

為什麼不直接序列化？因為我設計表結構是變動的，使用json的key-value很容易進行表結構的擴充伸縮。

gson這貨，竟然一步到位把json字串轉化成了對象。我只能說，太over-architecture了。過分的api設計了。

jackson使用了JsonNode，本質還是索引值對，這種恰到好處的設計，非常方便。

結論：

如果要使用json， json-lib就是一坨屎，簡直就是實驗室作品。。。用jackson吧。

 

2. Cloneable介面？

我一向有個觀點，Java提供的原生API效能一定比自己無論怎麼搞也高效。

很可惜，Cloneable介面第一，沒有public object clone。不知道他搞什麼飛機。繼承介面還不是public的。要自己調用object.clone. 第二，是淺拷貝，如果有對象數組，還是指標引用。

Usr_Equipment implements CLoneable

{

　　@Override

　　public Object clone() { super.clone();}
}

可惜了，真心不知道這個Cloneable設計出來是幹什麼的。

於是自己設計一個ICloneable extends Cloneable介面，把clone暴露出來。

 

3. 淺拷貝變成深拷貝？

為了實現深拷貝，必然需要使用遞迴對整個對象的屬性遍曆。整個魔法的核心，就是BeanCopier。效能比BeanMap更強大！我先放出代碼：

package com.xtar.common.structure; import java.lang.reflect.Array;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentMap; import net.sf.cglib.beans.BeanCopier;import net.sf.cglib.core.Converter; import com.xtar.common.interfaces.ICloneable;import com.xtar.common.tool.ParserHelper; public class CloneableBase implements ICloneable{    private static ConcurrentMap<Class<?>, BeanCopier> beanCopiers = new ConcurrentHashMap<Class<?>, BeanCopier>();     @Override    public Object clone()    {        try        {            Object clone = this.getClass().newInstance();             BeanCopier copier = _createCopier(this.getClass());             copier.copy(this, clone, new Converter()            {                @Override                public Object convert(Object pojo, Class fieldType, Object fieldName)                {                    return _clone(pojo);                }            });             return clone;        }        catch (Exception e)        {            throw new RuntimeException(e);        }    }     private static Object _clone(Object bean)    {        if (bean == null)        {            return null;        }        else if (bean instanceof ICloneable)        {            return ((ICloneable) bean).clone();        }        else        {                     if (bean.getClass().isArray() && !bean.getClass().getComponentType().equals(byte.class))                    {                        int length = Array.getLength(bean);                        Object clone = Array.newInstance(bean.getClass().getComponentType(), length);                        for (int i = 0; i < length; i++)                        {                            Array.set(clone, i, _clone(Array.get(bean, i)));                        }                        return clone;                    }                    else                    {                        return bean;                    }            }        }    }     private static BeanCopier _createCopier(Class<?> clz)    {        if (beanCopiers.containsKey(clz))            return beanCopiers.get(clz);        beanCopiers.putIfAbsent(clz, BeanCopier.create(clz, clz, true));        return beanCopiers.get(clz);     }}

上面就是整個深拷貝的魔法核心。

1）使用了BeanCopier，並緩衝這個對象，效能提升50%，從1s下降到600ms。

2）判斷array，如果是byte[]類型，直接使用淺拷貝。這個是個特殊對象。

測試下來，比用BeanMap快2倍。相同的對象，BeanMap需要1700ms，而BeanCopier只需要500ms。

　

4. 結論

我自認為，這個方法已經做到極致了。（沒測試二進位序列化）。只要自己的對象繼承了CloneableBase，就能夠實現深度拷貝。

Java的一個高效能快速深拷貝方法。Cloneable?