自己实现一个内存缓存

最新推荐文章于 2023-03-28 10:48:37 发布

weixin_30908649

最新推荐文章于 2023-03-28 10:48:37 发布

阅读量292

点赞数

文章标签：操作系统 c/c++ java

原文链接：http://www.cnblogs.com/wchxj/p/8159701.html

版权

最近了解了下缓存技术，主要分为内存缓存和磁盘缓存，然后分布式里面有一些消息的推送，节点的一些处理。现在很多的用OSCache,EhCache 等等，资料很多，暂时就不多说了，我这里仅仅为了了解缓存框架的的知识，自己临时写一个缓存，后面可以实现AOP 和spring 结合。

实现功能：
1.数据都缓存到内存中
2.实现对每个元素Element的缓存时间进行控制
3.对每个缓存Cache 进行创建，以及销毁的管理
4.能对缓存存放个数进行管理
5.通过线程定时检查元素是否过期
6.可以定义缓存清除策略

实现思路：
1.Store 接口：定义常用的存取元素get,put的接口
2.AbstractStore:对接口基本方法进行实现
3.MemoryCache:对具体缓存的存取方法进行实现，并执行一定的逻辑控制
4.Cache:增加对缓存整体进行监听，销毁等操作
5.CacheManager：缓存管理器，负责管理缓存的容器

6.CacheConfiguration ：一些缓存的配置属性
7.CheckManager：一些检查缓存内容的策略方法
8.EvictionType：枚举清空策略
9.CacheListener：缓存的监听，每次创建缓存就启动，然后定时检查缓存元素是否过期
10.Element: 元素的单元

Java代码

package com.cache;
import java.util.Collection;
public interface Store {
// 获得缓存名字
public String getName();
// 存放元素
public Element put(Element e);
public Collection<Element> putAll(Collection<Element> elements);
// 获取元素
public Element get(Object key);
// 清除元素
public void clear();
// 移除元素
public void remove(Object key);
public void removeAll(Object[] keys);
// 获得的元素长度
public Integer size();
}

Java代码

package com.cache;
import java.util.Map;
/**
* 抽象类实现
*/
public abstract class AbstractStore implements Store{
protected Map<Object, Element> map;
public AbstractStore(){}
public AbstractStore(Map<Object, Element> map){
this.map = map;
}
@Override
public Element get(Object key) {
Element e = map.get(key);
return e;
}
public Map<Object, Element> getAll(){
return map;
}
@Override
public void clear() {
map.clear();
}
@Override
public Element put(Element e) {
return map.put(e.getKey(), e);
}
@Override
public void remove(Object key) {
map.remove(key);
}
@Override
public Integer size() {
return map.size();
}
@Override
public void removeAll(Object[] keys) {
for(int i =0;i<keys.length;i++){
remove(keys[i]);
}
}
}

Java代码

package com.cache;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
/**
* 缓存的基本方法
*/
public class MemoryCache extends AbstractStore implements Store{
private final CacheConfiguration configure;
private final static Map<Object, Element> map = new HashMap<Object, Element>();
private final CheckManager checkManager;
// 暂时仅弄一个构造
public MemoryCache(CacheConfiguration configure){
super(map);
this.configure = configure;
this.checkManager = new CheckManager(configure, map);
}
@Override
public String getName() {
return configure.getCacheName();
}
@Override
public Collection<Element> putAll(Collection<Element> elements) {
if(elements == null){
throw new NullPointerException("elements can't be null");
}
check(elements.size());
for(Element e : elements){
putElementStatus(e);
super.put(e);
}
return elements;
}
@Override
public synchronized Element put(Element e) {
check(1);
putElementStatus(e);
return super.put(e);
}
// 使用一次之后刷新使用过期时间，以及使用次数
// 并检查该元素是否过期
public void changeElement(Element e){
e.addHitCount();
if(!configure.getEternal()){
e.refreshLastAccessTime();
}
}
// 如果eternal 为true，表示元素永不过期,默认忽略最小元素控制
public void putElementStatus(Element e){
if(!configure.getEternal() && ! e.getIsOpen()){
e.setTimeToIdle(configure.getTimeToIdleSeconds());
e.setTimeToLive(configure.getTimeToLiveSeconds());
}else{
e.setTimeToIdle(0);
e.setTimeToLive(0);
}
}
@Override
public Element get(Object key) {
Element e = super.get(key);
if(e != null){
if(!e.isExpired()){
changeElement(e);
}else{
synchronized (this) {
remove(e.getKey());
e = null;
}
}
}
return e;
}
// 检查元素是否为空
public boolean checkElement(Element e){
if(e == null){
throw new NullPointerException("Element can't be null ");
}
if(e.getKey() == null){
throw new NullPointerException("Element key can't be null ");
}
return true;
}
@Override
public synchronized void removeAll(Object[] keys) {
super.removeAll(keys);
}
// 检查元素是否超过了
public void check(int checkSize){
if(checkSize <= 0){
return;
}
Object[] keys = checkManager.checkConfigure(checkSize);
if(keys !=null) {
removeAll(keys);
}
}
}

Java代码

package com.cache;
/**
* 这是对缓存级的控制判断
*/
public class Cache extends MemoryCache{
private CacheConfiguration configure;
private CacheListener listener;
public Cache(CacheConfiguration configure) {
super(configure);
this.configure = configure;
if(!configure.getEternal() && configure.getIsNeedCacheCheckListener()){
listener = new CacheListener(this);
listener.start();
}
}
public CacheConfiguration getConfigure() {
return configure;
}
// 销毁
public void destory(){
try{
super.clear();
if(listener != null){
listener.interrupt();
listener.stop();
listener = null;
}
}catch (Exception e) {
}
}
}

Java代码

package com.cache;
import java.util.HashMap;
import java.util.Map;
/**
* 缓存管理类
*/
public class CacheManager {
// 默认单例
private CacheManager(){}
private static class Singleton{
private static CacheManager instance = new CacheManager();
}
public static CacheManager getInstance() {
return Singleton.instance;
}
public static Map<String, Cache> MAP_NAMES_CACHE = new HashMap<String, Cache>();
// 存放取出缓存对象
public Cache getCache(String CacheName){
Cache cache = MAP_NAMES_CACHE.get(CacheName);
return cache;
}
public void putCache(Cache cache){
if(cache != null && !MAP_NAMES_CACHE.containsKey(cache.getName())){
MAP_NAMES_CACHE.put(cache.getName(), cache);
}
}
// 移除
public void remove(String cacheName){
Cache c = MAP_NAMES_CACHE.remove(cacheName);
c.destory();
}
// 关闭所有缓存
public void shutDown(){
removeAllCaches();
MAP_NAMES_CACHE.clear();
}
// 移除所有
public void removeAllCaches(){
String [] cacheNames = getCacheNames();
for(String cacheName : cacheNames){
remove(cacheName);
}
}
// 获得名字
public String[] getCacheNames(){
return MAP_NAMES_CACHE.keySet().toArray(new String[0]);
}
}