实例教程3

本人在设计数据库缓存层的时候，需要对数据进行深拷贝，这样用户操作的数据对象就是不共享的。

这个思路实际上和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更强大！我先放出代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

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，就能够实现深度拷贝。