java Map实现的cache manager

一个模仿memcached的JAVA虚拟缓存工具，可以缓存java对象

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

/**
 * java Map cache manager 改进版
 * 特点：无线程，取出时判断过期，系列化实现的深度克隆，覆盖原则
 * 问题: 线程安全，克隆带来的时效损耗
 * @author frank
 *
 */
public class VirtualCache{
    
    /**
     * 开发模式
     */
    private boolean isdev = false;
    
    private static String ERROR_SET = "VirtualCache缓存数据异常:key=";
    
    private static String ERROR_GET= "VirtualCache取出数据异常:key=";
    
    /**
     * 虚拟缓存
     */
    private Map<String,Object> cache = new ConcurrentHashMap<String, Object>();
    
    /**
     * 过期时间
     */
    private Map<String,Long> tasks = new ConcurrentHashMap<String,Long>();
    
    public VirtualCache(boolean isdev){
        this.isdev = isdev;
    }
    
    public VirtualCache(){
        
    }
    
    /**
     * 深度克隆
     */
    private Object clone(String key,Object obj,boolean isSet){
        if(obj == null)
            return null;
        ByteArrayOutputStream bo = null;
        ObjectOutputStream oo = null;
        ByteArrayInputStream bi = null;
        ObjectInputStream oi = null;
        Object value = null;
        try {
            bo=new ByteArrayOutputStream();
            oo = new ObjectOutputStream(bo);
            oo.writeObject(obj);
            bi=new ByteArrayInputStream(bo.toByteArray());
            oi=new ObjectInputStream(bi);
            value = oi.readObject();
        } catch (Exception e) {
            this.printError(e, key,isSet);
        } finally{
            if(oo != null)
                try {
                    oo.close();
                } catch (Exception e) {
                    this.printError(e, key,isSet);
                }
            if(oi != null)
                try {
                    oi.close();
                } catch (Exception e) {
                    this.printError(e, key,isSet);
                }
        }
        return value;
    }
    
    /**
     * 日志输出
     */
    private void printError(Exception e,String key,boolean isSet){
        if(isSet)
            System.err.println(ERROR_SET + key);
        else
            System.err.println(ERROR_GET + key);
        if(this.isdev)
            e.printStackTrace();
    }
    
    /**
     * 存入缓存
     */
    public void set(String key,Object value,long timeout){
        this.delete(key);
        this.cache.put(key, this.clone(key,value,true));
        if(timeout > 0l)
            this.tasks.put(key,timeout*1000l + System.currentTimeMillis());
    }
    
    /**
     * 获取缓存
     */
    public Object get(String key){
        Long timeout = this.tasks.get(key);
        if(timeout != null && timeout <= System.currentTimeMillis())
            this.delete(key);
        return this.clone(key,this.cache.get(key),false);
    }

    /**
     * 删除缓存
     */
    public void delete(String key){
        this.cache.remove(key);
        this.tasks.remove(key);
    }
    
}