SivanCache的固定缓存大小实现

代码实现 定义SivanCache接口，实现put方法 @Override @SivanCacheInterceptor(aof = true, evict = true) public V put(K key, V value) { //1.1 尝试驱除 SivanCacheEvictContext<K,V> context = new SivanCacheEvictContext<>(); context.key(key).size(sizeLimit).cache(this);

    ISivanCacheEntry<K,V> evictEntry = evict.evict(context);

    // 添加拦截器调用
    if(ObjectUtil.isNotNull(evictEntry)) {
        // 执行淘汰监听器
        ISivanCacheRemoveListenerContext<K,V> removeListenerContext = SivanCacheRemoveListenerContext.<K,V>newInstance().key(evictEntry.key())
                .value(evictEntry.value())
                .type(SivanCacheRemoveType.EVICT.code());
        for(ISivanCacheRemoveListener<K,V> listener : context.cache().removeListeners()) {
            listener.listen(removeListenerContext);
        }
    }

    //2. 判断驱除后的信息
    if(isSizeLimit()) {
        throw new SivanCacheRuntimeException("当前队列已满，数据添加失败！");
    }

    //3. 执行添加
    return map.put(key, value);
}

淘汰策略 先实现一个简单的缓存淘汰策略 package com.xin.cache.support.evict;

import com.xin.cache.api.ISivanCache; import com.xin.cache.api.ISivanCacheEvictContext; import com.xin.cache.model.SivanCacheEntry;

import java.util.LinkedList; import java.util.Queue;

/**

• 丢弃策略-先进先出
• @author sivan

*/ public class SivanCacheEvictFifo<K,V> extends AbstractSivanCacheEvict<K,V> {

/**
 * queue 信息
 *  
 */
private final Queue<K> queue = new LinkedList<>();

@Override
public SivanCacheEntry<K,V> doEvict(ISivanCacheEvictContext<K, V> context) {
    SivanCacheEntry<K,V> result = null;

    final ISivanCache<K,V> cache = context.cache();
    // 超过限制，执行移除
    if(cache.size() >= context.size()) {
        K evictKey = queue.remove();
        // 移除最开始的元素
        V evictValue = cache.remove(evictKey);
        result = new SivanCacheEntry<>(evictKey, evictValue);
    }

    // 将新加的元素放入队尾
    final K key = context.key();
    queue.add(key);

    return result;
}

}

缓存引导类 package com.xin.cache.bs;

import com.github.houbb.heaven.util.common.ArgUtil; import com.xin.cache.api.*; import com.xin.cache.core.SivanCache; import com.xin.cache.support.evict.SivanCacheEvicts; import com.xin.cache.support.listener.remove.SivanCacheRemoveListeners; import com.xin.cache.support.listener.slow.SivanCacheSlowListeners; import com.xin.cache.support.load.SivanCacheLoads; import com.xin.cache.support.persist.SivanCachePersists; import com.xin.cache.support.proxy.SivanCacheProxy;

import java.util.HashMap; import java.util.List; import java.util.Map;

/**

• 缓存引导类
• @author sivan

*/ public final class SivanCacheBs<K,V> {

private SivanCacheBs(){}

/**
 * 创建对象实例
 * @param <K> key
 * @param <V> value
 * @return this
 *  
 */
public static <K,V> SivanCacheBs<K,V> newInstance() {
    return new SivanCacheBs<>();
}

/**
 * map 实现
 *  
 */
private Map<K,V> map = new HashMap<>();

/**
 * 大小限制
 *  
 */
private int size = Integer.MAX_VALUE;

/**
 * 驱除策略
 *  
 */
private ISivanCacheEvict<K,V> evict = SivanCacheEvicts.fifo();

/**
 * 删除监听类
 *  
 */
private final List<ISivanCacheRemoveListener<K,V>> removeListeners = SivanCacheRemoveListeners.defaults();

/**
 * 慢操作监听类
 *  
 */
private final List<ISivanCacheSlowListener> slowListeners = SivanCacheSlowListeners.none();

/**
 * 加载策略
 *  
 */
private ISivanCacheLoad<K,V> load = SivanCacheLoads.none();

/**
 * 持久化实现策略
 *  
 */
private ISivanCachePersist<K,V> persist = SivanCachePersists.none();

/**
 * map 实现
 * @param map map
 * @return this
 *  
 */
public SivanCacheBs<K, V> map(Map<K, V> map) {
    ArgUtil.notNull(map, "map");

    this.map = map;
    return this;
}

/**
 * 设置 size 信息
 * @param size size
 * @return this
 *  
 */
public SivanCacheBs<K, V> size(int size) {
    ArgUtil.notNegative(size, "size");

    this.size = size;
    return this;
}

/**
 * 设置驱除策略
 * @param evict 驱除策略
 * @return this
 *  
 */
public SivanCacheBs<K, V> evict(ISivanCacheEvict<K, V> evict) {
    ArgUtil.notNull(evict, "evict");

    this.evict = evict;
    return this;
}

/**
 * 设置加载
 * @param load 加载
 * @return this
 *  
 */
public SivanCacheBs<K, V> load(ISivanCacheLoad<K, V> load) {
    ArgUtil.notNull(load, "load");

    this.load = load;
    return this;
}

/**
 * 添加删除监听器
 * @param removeListener 监听器
 * @return this
 *  
 */
public SivanCacheBs<K, V> addRemoveListener(ISivanCacheRemoveListener<K,V> removeListener) {
    ArgUtil.notNull(removeListener, "removeListener");

    this.removeListeners.add(removeListener);
    return this;
}

/**
 * 添加慢日志监听器
 * @param slowListener 监听器
 * @return this
 *  
 */
public SivanCacheBs<K, V> addSlowListener(ISivanCacheSlowListener slowListener) {
    ArgUtil.notNull(slowListener, "slowListener");

    this.slowListeners.add(slowListener);
    return this;
}

/**
 * 设置持久化策略
 * @param persist 持久化
 * @return this
 *  
 */
public SivanCacheBs<K, V> persist(ISivanCachePersist<K, V> persist) {
    this.persist = persist;
    return this;
}

/**
 * 构建缓存信息
 * @return 缓存信息
 *  
 */
public ISivanCache<K,V> build() {
    SivanCache<K,V> cache = new SivanCache<>();
    cache.map(map);
    cache.evict(evict);
    cache.sizeLimit(size);
    cache.removeListeners(removeListeners);
    cache.load(load);
    cache.persist(persist);
    cache.slowListeners(slowListeners);

    // 初始化
    cache.init();
    return SivanCacheProxy.getProxy(cache);
}

}

编写测试类 /** * 大小指定测试 *
*/ @Test public void helloTest() { ISivanCache<String, String> cache = SivanCacheBs.<String,String>newInstance() .size(2) .build();

    cache.put("1", "1");
    cache.put("2", "2");
    cache.put("3", "3");
    cache.put("4", "4");

    Assert.assertEquals(2, cache.size());
    System.out.println(cache.keySet());
}