java Map实现的cache manager

最新推荐文章于 2025-10-06 07:11:37 发布

转载最新推荐文章于 2025-10-06 07:11:37 发布 · 328 阅读

Javase基础总结篇专栏收录该内容

12 篇文章

订阅专栏

本文介绍了一个基于Java的虚拟缓存工具，它模仿了memcached的功能，能够存储和缓存Java对象。该工具使用ConcurrentHashMap来实现线程安全的数据存储，并通过序列化实现了对象的深度克隆，以确保数据的一致性和完整性。

一个模仿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);
    }
    
}