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

{

　　@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，就可以實現深度拷貝。