Java的一個高性能快速深拷貝方法。Cloneable?
本人在設計數據庫緩存層的時候,需要對數據進行深拷貝,這樣用戶操作的數據對象就是不共享的。
這個思路實際上和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
{
[email protected]
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?