java对象本地缓存机制的实现

本地缓存机制，利用java.util.concurrent，很好的管理本地内存存储的对象内容。

创建属性：

 /**
     * 具体内容存放的地方
     */
    private ConcurrentHashMap[] caches;
    /**
     * 超期信息存储
     */
    private ConcurrentHashMap expiryCache;

    /**
     * 清理超期内容的服务
     */
    private ScheduledExecutorService scheduleService;


    /**
     * 清理超期信息的时间间隔，默认10分钟
     */
    private int expiryInterval = 5;


    /**
     * 内部cache的个数，根据key的hash对module取模来定位到具体的某一个内部的Map，
     */
    private int moduleSize = 10;

创建构造器：    

  public MyLocalCache() {
        caches = new ConcurrentHashMap[moduleSize];
        for (int i = 0; i < moduleSize; i++) {
            caches[i] = new ConcurrentHashMap();
        }
        expiryCache = new ConcurrentHashMap();


        scheduleService = Executors.newScheduledThreadPool(1);
        //后台定时维护线程
        scheduleService.scheduleAtFixedRate(getRemoveLocalCacheTask(), 0, 60L * expiryInterval, TimeUnit.SECONDS);
    }

定义缓存的get和put方法：

  /**
     * 将数据放入缓存中
     * @param key
     * @param value
     * @param TTL 秒
     * @return
     */
    public Object put(String key, Object value, int TTL) {
        Object result = null;
        ConcurrentHashMap cache = getCache(key);
        if (cache != null && cache.size() < 10240) {
            result = cache.put(key, value);
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.SECOND, TTL);
            expiryCache.put(key, calendar.getTime().getTime());
        }
        return result;
    }


    public Object get(String key) {
        checkValidate(key);
        return getCache(key).get(key);
    }

//根据key获取cache容器
    private ConcurrentHashMap getCache(String key) {
        long hashCode = (long) key.hashCode();
        if (hashCode < 0) {
            hashCode = -hashCode;
        }
        int moudleNum = (int) (hashCode % moduleSize);
        return caches[moudleNum];
    }

校验key是否过期，如果过期了，就要移除

 private void checkValidate(String key) {
        if (key != null) {
            Long expiryTime = expiryCache.get(key);
            if (expiryTime != null && expiryTime != -1
                    && new Date(expiryTime).before(new Date())) {
                ConcurrentHashMap cache = getCache(key);
                if (cache != null) {
                    cache.remove(key);
                }
                expiryCache.remove(key);
            }
        }
    }

清除所有的缓存：    key和内容  全部清空

 public boolean clear() {
        if (caches != null) {
            for (ConcurrentHashMap cache : caches) {
                cache.clear();
            }
        }


        if (expiryCache != null) {
            expiryCache.clear();
        }
        return true;
    }

定时器：  检查过期内容

 public Runnable getRemoveLocalCacheTask() {
        return new Runnable() {
            @Override
            public void run() {
                try {
                    for (ConcurrentHashMap cache : caches) {
                        Iterator keys = cache.keySet().iterator();
                        while (keys.hasNext()) {
                            String key = keys.next();
                            if (expiryCache.get(key) == null) {
                                continue;
                            }
                            long date = expiryCache.get(key);
                            if ((date > 0) && (new Date(date).before(new Date()))) {
                                expiryCache.remove(key);
                                cache.remove(key);
                            }
                        }
                    }
                    logger.debug("MingpinLocalCache CheckService check() is run!");
                } catch (Exception ex) {
                    logger.error(ex);
                }
            }
        };
    }