實際專案中常常需要用到本地快取，特別是一些固定不變的資料，不想頻繁調介面，因為http請求本身需要耗時，下面幾個類對本地快取作了簡單實現，支援自動過期功能

LocalCache.java

interface LocalCache {

	public void refresh();
}

LocalCacheItem.java

/**
 * 快取項
 * @author: 
 * @date: 2018年2月6日 下午6:01:33
 */
public class LocalCacheItem {

	// 快取時間：單位毫秒
	private long cacheTime;
	// 建立時間：單位毫秒
	private long createTime;
	// 快取值
	private Object value;
	
	public LocalCacheItem() {
		super();
	}

	public LocalCacheItem(long cacheTime, long createTime, Object value) {
		super();
		this.cacheTime = cacheTime;
		this.createTime = createTime;
		this.value = value;
	}

	public long getCacheTime() {
		return cacheTime;
	}
	public void setCacheTime(long cacheTime) {
		this.cacheTime = cacheTime;
	}
	public long getCreateTime() {
		return createTime;
	}
	public void setCreateTime(long createTime) {
		this.createTime = createTime;
	}
	public Object getValue() {
		return value;
	}
	public void setValue(Object value) {
		this.value = value;
	}
	
}
 

LocalCacheManage.java

import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * 本地快取管理器,CommandLineRunner應用啟動執行
 * @author:  
 * @date: 2017年12月20日 上午11:54:53
 */
@Component
public class LocalCacheManage implements CommandLineRunner{

	@Autowired private List<LocalCache> localCaches;
	private Logger logger = LoggerFactory.getLogger(this.getClass());
	/**
	 * 應用啟動初始化
	 */
	@Override
	public void run(String... args) throws Exception {
		// 1分鐘重新整理一次，時間可以自定義。這裡作為心跳執行緒，定時重新整理快取
		Timer timer = new Timer();
		timer.scheduleAtFixedRate(new TimerTask() {
			public void run() {
				if(localCaches!=null && !localCaches.isEmpty()){
					for(LocalCache cache : localCaches){
						try {
							cache.refresh();
						} catch (Exception e) {
							logger.error("本地快取更新異常", e);
						}
					}
				}
			}
		}, 0, 60000);
	}
	
}
 

CommomLocalCache.java

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import org.springframework.stereotype.Component;

/**
 * 公用本地快取
 * @author:  
 * @date: 2017年12月20日 下午2:18:25
 */
@Component
public class CommomLocalCache implements LocalCache{

	private static ConcurrentHashMap<String, LocalCacheItem> cache = new ConcurrentHashMap<>();
	
	public static boolean containsKey(String key){
		return cache.containsKey(key);
	}
	
	/**
	 * 快取值
	 * @author:  
	 * @date: 2018年2月6日 下午5:24:20 
	 * @param key
	 * @param value
	 */
	public static void put(String key, Object value){
		LocalCacheItem item = new LocalCacheItem(0, System.currentTimeMillis(), value);
		cache.put(key, item);
	}
	
	/**
	 * 快取值-指定快取時間
	 * @author:  
	 * @date: 2018年2月6日 下午5:35:05 
	 * @param key
	 * @param value
	 * @param cacheTime 快取時間
	 * @param unit 快取時間單位
	 */
	public static void put(String key, Object value, long cacheTime, TimeUnit unit){
		LocalCacheItem item = new LocalCacheItem(unit.toMillis(cacheTime), System.currentTimeMillis(), value);
		cache.put(key, item);
	}
	
	/**
	 * 獲取值
	 * @author:  
	 * @date: 2018年2月6日 下午5:34:28 
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <T>T get(String key){
		LocalCacheItem item = cache.get(key);
		if(item==null){
			return null;
		}
		return (T)item.getValue();
	}

	@Override
	public void refresh() {
		for(String key : cache.keySet()){
		    LocalCacheItem item = cache.get(key);
		    // 過期了移除快取
		    long currentTime = System.currentTimeMillis();
	            if(item.getCacheTime()>0 && currentTime - item.getCreateTime() > item.getCacheTime()) {
	        	cache.remove(key);
	            }    
		}
	}

}
 

拓展：上面的本地快取控制是通過CommomLocalCache工具類操作key、value，還有一種是嵌入到具體的類中，對類中的map、list進行過期控制，下面是實現方式和示例

AbstractLocalCache.java

import java.util.concurrent.TimeUnit;

/**
 * 本地快取抽象類
 * LocalCacheManage每隔一分鐘執行一次重新整理，cacheTime，createTime不設定的，預設就是一分鐘更新一次
 * @author:  
 * @date: 2017年12月20日 上午11:53:58
 */
public abstract class AbstractLocalCache implements LocalCache{

	// 快取時間：單位毫秒
	private long cacheTime;
	// 建立時間：單位毫秒
	private long createTime;
	
	@Override
	public void refresh() {
		// 過期了重新整理快取
		long currentTime = System.currentTimeMillis();
        if(currentTime - createTime > cacheTime) {
            doRefresh();
            this.createTime = System.currentTimeMillis();
        }
	}

	public abstract void doRefresh();

	/**
	 * 指定單位
	 * @author:  
	 * @date: 2017年12月20日 下午12:09:10 
	 * @param cacheTime
	 * @param unit
	 */
	public void setCacheTime(long cacheTime, TimeUnit unit) {
		this.cacheTime = unit.toMillis(cacheTime);
	}

	/**
	 * 毫秒
	 * @author:  
	 * @date: 2017年12月20日 下午12:07:46 
	 * @param cacheTime
	 */
	public void setCacheTime(long cacheTime) {
		this.cacheTime = cacheTime;
	}
	
}

Simple.java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 下面示例表示本地快取cache 每10分鐘清一次
 * @author:  
 * @date: 2018年1月25日 下午2:50:51
 */
public class Simple extends AbstractLocalCache{

	private static Map<String, Object> cacheMap = new HashMap<>();
	private static List<Object> cacheList = new ArrayList<>();
	
	@Override
	public void doRefresh() {
		// 清空
		cacheMap.clear();
		cacheList.clear();
		// TODO 重新更新
		// 10分鐘
		super.setCacheTime(10, TimeUnit.MINUTES);
	}

}