（一）

Map
    
     
      > cache = new ConcurrentHashMap
      
       >();
      
     
    

cache.remove("str"); cache.put("str",getCmsCfgAll());

List
    
      name = cache.get("str"); (二)
    

package com.jdjinsui.controlservice.tool; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; /**  * 缓存管理类  * Created by zxy on 2017/5/16.  */ public class CacheMgr {
      private static Map cacheMap = new HashMap();     private static Map cacheConfMap = new HashMap();     private static CacheMgr cm = null;     //构造方法     private CacheMgr(){
      }     public static CacheMgr getInstance(){
          if(cm==null){
              cm = new CacheMgr();             Thread t = new ClearCache();             t.start();         }         return cm;     }     /**      * 增加缓存      * @param key      * @param value      * @param ccm 缓存对象      * @return      */     public static boolean addCache(Object key,Object value,CacheConfModel ccm){
          System.out.println("开始增加缓存－－－－－－－－－－－－－");         boolean flag = false;         try {
              cacheMap.put(key, value);             cacheConfMap.put(key, ccm);             System.out.println("增加缓存结束－－－－－－－－－－－－－");             System.out.println("now addcache=="+cacheMap.size());             flag=true;         } catch (Exception e) {
              e.printStackTrace();         }         return flag;     }     /**      * 获取缓存实体      */     public static Object getValue(String key){
          Object ob=cacheMap.get(key);         if(ob!=null){
              return ob;         }else{
              return null;         }     }     /**      * 获取缓存数据的数量      * @return      */     public static int getSize(){
          return cacheMap.size();     }     /**      * 删除缓存      * @param key      * @return      */     public static boolean removeCache(Object key){
          boolean flag=false;         try {
              cacheMap.remove(key);             cacheConfMap.remove(key);             flag=true;         } catch (Exception e) {
              e.printStackTrace();         }         return flag;     }     /**      * 清除缓存的类      * 继承Thread线程类      */     private static class ClearCache extends Thread{
          public void run(){
              while(true){
                  Set tempSet = new HashSet();                 Set set = cacheConfMap.keySet();                 Iterator it = set.iterator();                 while(it.hasNext()){
                      Object key = it.next();                     CacheConfModel ccm = (CacheConfModel)cacheConfMap.get(key);                     //比较是否需要清除                     if(!ccm.isForever()){
                          if((new Date().getTime()-ccm.getBeginTime())>= ccm.getDurableTime()*60*1000){
                              //可以清除，先记录下来                             tempSet.add(key);                         }                     }                 }                 //真正清除                 Iterator tempIt = tempSet.iterator();                 while(tempIt.hasNext()){
                      Object key = tempIt.next();                     cacheMap.remove(key);                     cacheConfMap.remove(key);                 }                 System.out.println("now thread================>"+cacheMap.size());                 //休息                 try {
                      Thread.sleep(60*1000L);                 } catch (InterruptedException e) {
                      e.printStackTrace();                 }             }         }     } }

package com.jdjinsui.controlservice.tool; /**  * 缓存属性类  * Created by zxy on 2017/5/17.  */ public class CacheConfModel implements java.io.Serializable {
      private long beginTime;//缓存开始时间     private boolean isForever = false;//是否持久     private int durableTime;//持续时间     public long getBeginTime() {
          return beginTime;     }     public void setBeginTime(long beginTime) {
          this.beginTime = beginTime;     }     public boolean isForever() {
          return isForever;     }     public void setForever(boolean isForever) {
          this.isForever = isForever;     }     public int getDurableTime() {
          return durableTime;     }     public void setDurableTime(int durableTime) {
          this.durableTime = durableTime;     } }

//测试方法

Gson gson=new Gson(); CacheMgr cm=CacheMgr.getInstance(); CacheConfModel cModel=new CacheConfModel(); Date d=new Date(); cModel.setBeginTime(d.getTime()); cModel.setDurableTime(60); cModel.setForever(true); cm.addCache("cms", getCmsCfgAll(), cModel);//在缓存加值 CacheMgr cn=CacheMgr.getInstance(); String js=gson.toJson(cn.getValue("cms")); List
    
      user=gson.fromJson(js,new TypeToken
     
      
       >() {}.getType());
      
     
    

（三）

package com.jdjinsui.controlservice.tool; import java.util.AbstractMap; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; /**  * Created by zxy on 2017/5/17.  */ public class CacheMap
    
      extends AbstractMap
     
       {
      private static final long DEFAULT_TIMEOUT = 30000;     private static CacheMap
      
        defaultInstance;     public static synchronized final CacheMap
       
         getDefault() {
          if (defaultInstance == null) {
              defaultInstance = new CacheMap
        
         (DEFAULT_TIMEOUT);         }         return defaultInstance;     }     private class CacheEntry implements Entry
         
           { long time; V value; K key; CacheEntry(K key, V value) { super(); this.value = value; this.key = key; this.time = System.currentTimeMillis(); } @Override public K getKey() { return key; } @Override public V getValue() { return value; } @Override public V setValue(V value) { return this.value = value; } } private class ClearThread extends Thread { ClearThread() { setName("clear cache thread"); } public void run() { while (true) { try { long now = System.currentTimeMillis(); Object[] keys = map.keySet().toArray(); for (Object key : keys) { CacheEntry entry = map.get(key); if (now - entry.time >= cacheTimeout) { synchronized (map) { map.remove(key); } } } Thread.sleep(cacheTimeout); } catch (Exception e) { e.printStackTrace(); } } } } private long cacheTimeout; private Map
          
            map = new HashMap
           
            (); public CacheMap(long timeout) { this.cacheTimeout = timeout; new ClearThread().start(); } @Override public Set
            
             
              > entrySet() { Set
              
               
                > entrySet = new HashSet
                
                 
                  >(); Set
                  
                   
                    > wrapEntrySet = map.entrySet(); for (Entry
                    
                      entry : wrapEntrySet) { entrySet.add(entry.getValue()); } return entrySet; } @Override public V get(Object key) { CacheEntry entry = map.get(key); return entry == null ? null : entry.value; } @Override public V put(K key, V value) { CacheEntry entry = new CacheEntry(key, value); synchronized (map) { map.put(key, entry); } return value; } }