java缓存类实现_Java三个类实现内存缓存

有一个需求，本来打算用redis来做，但是发现redis的list不支持某一项超时设置，

所以就用java自己写了一个简单的缓存，操作类似redis，总共只有3个类：

项目名：group-cache

简单的内存缓存实现，实现group概念，一个group里面是个有序的集合，集合支持key-value expire弥补redis list的不足

总共有3个类：

GroupCacheFactory 工厂用于获取Group

Group 组，存放多个key和value

CacheEntity 缓存实体，所有缓存的数据都是以CacheEntity为载体放入Group中

测试代码：

package com.qikenet.cache;

import java.util.Random;

public class CacheTest {

public static void main(String[] args) {

/**

* 概念：

* 组缓存，在传统redis、memcached 这一类的缓存容器中，都是key-value类型的

* 所谓的组缓存，就是在key-value的外层加一个标识

* 用list来做比较，在redis中，list的结构是这样的，并且list的某一项不能设置存活时间：

* abc

* 1

* 2

* 3

*

* 在GroupCache中结构是这样的 :

* abc

* a 1 10

* b 2 5

* c 3 1

* 第一行：a代表key，1代表value，10代表存活10秒，存活时间以秒为单位

*/

//创建一个工厂，暂时不支持持久化

GroupCacheFactory factory=new GroupCacheFactory();

//获取一个组

Group group1=factory.group("group1");

group1.push("a", 123);//默认永久存活

group1.push("b", 321, 10);//存活10秒

//查看还有多久失效

System.out.println("group 1 的元素b 剩余失效时间："+group1.ttl("b"));

//检测值是否存在

System.out.println("a是否存在："+group1.exist("a"));

System.out.println("c是否存在："+group1.exist("c"));

//获取有效的key

System.out.println("group1 keys:"+group1.getKeys());

//获取有效的value

System.out.println("group1 values:"+group1.getValues());

//通过key获取值

System.out.println("通过a获取："+group1.getValue("a"));

//获取一个组，并设置容量为100，默认容量为1000,不同的group中数据不能共享

Group group2=factory.group("group2",100);

//如果push的数据大于容量，则会丢弃

for(int i=0;i<101;i++){

group2.push(String.valueOf(i), i, new Random().nextInt(10));

}

//获取存活的元素的数量

System.out.println("group2大小:"+group2.size());

//设置元素的存活时间

group2.expire("2", 100);

//删除一个元素

group2.delete("3");

System.out.println("group删除后的元素大小："+group2.size());

//获取group容量大小

System.out.println("group2容量："+group2.getCapacity());

System.out.println(group2.getKeys());

}

}

具体代码：

缓存工厂：

package com.qikenet.cache;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Random;

/**

* 简单的内存缓存实现，实现group概念，

* 一个group里面是个有序的集合，

* 集合支持key-value expire弥补redis list的不足

*

* @author panjing

* @date 2016年8月6日 上午9:27:22

* @project qikenet-group-cache

*/

public class GroupCacheFactory {

// 数据容器

private Map container;

public GroupCacheFactory() {

container = new LinkedHashMap();

}

/**

* 如果组存在就返回，不存在就创建，保证不为null

*

* @param key

* @return

*/

public Group group(String key, int capacity) {

Group group = null;

Object entry = container.get(key);

if (entry != null) {

group = (Group) entry;

} else {

group = new Group(capacity);

container.put(key, group);

}

return group;

}

/**

* 如果组存在就返回，不存在就创建，默认容量1000

*

* @param key

* @return

*/

public Group group(String key) {

return this.group(key, 1000);

}

}

缓存Group:

package com.qikenet.cache;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.concurrent.ArrayBlockingQueue;

/**

* 组操作，内部数据有序队列

*

* @author panjing

* @date 2016年8月6日 上午9:33:34

* @project qikenet-group-cache

* @param

*/

public class Group {

private ArrayBlockingQueue queue;// 缓存队列

private Integer capacity;

public Group(int capacity) {

queue = new ArrayBlockingQueue(capacity);

this.capacity = capacity;

}

/**

* 尾部进

*

* @param object

* @param second

*/

public void push(String key, Object object, int second) {

// 放入队列，

queue.offer(new CacheEntity(key, object, System.currentTimeMillis(), second, this));

}

/**

* 尾部进

*

* @param object

*/

public void push(String key, Object object) {

push(key, object, 0);

}

/**

* 返回并移除头部出

*

* @return

*/

public Object poll() {

CacheEntity entity = queue.poll();

// 如果有效期超过，返回null

if (!entity.isExpire()) {

return null;

}

return entity.getValue();

}

/**

* 返回头部元素并放到末尾

*

* @return

*/

public Object rPoll() {

CacheEntity entity = queue.poll();

// 如果有效期超过，返回null

if (!entity.isExpire()) {

return null;

}

Object object = entity.getValue();

queue.offer(entity);

return object;

}

/**

* 通过key寻找有效的缓存实体

*

* @param key

* @return

*/

private CacheEntity find(String key) {

synchronized (queue) {

Iterator iterator = queue.iterator();

while (iterator.hasNext()) {

CacheEntity entity = iterator.next();

if (key.equals(entity.getKey())) {

return entity;

}

}

return null;

}

}

/**

* 删除key

*

* @param key

*/

public void delete(String key) {

synchronized (queue) {

CacheEntity entity = find(key);

if (entity != null) {

queue.remove(entity);

}

}

}

/**

* 根据key获取

*

* @param key

* @return

*/

public Object getValue(String key) {

CacheEntity entity = find(key);

if (entity != null && entity.isExpire()) {

return entity.getValue();

}

return null;

}

/**

* 获取有效的缓存实体

*

* @return

*/

private List getCacheEntitys() {

List keys = new ArrayList();

Iterator iterator = queue.iterator();

while (iterator.hasNext()) {

CacheEntity cacheEntity = iterator.next();

if (cacheEntity.isExpire()) {

keys.add(cacheEntity);

}

}

return keys;

}

/**

* 获取key列表

*

* @return

*/

public List getKeys() {

List keys = new ArrayList();

List caches = getCacheEntitys();

for (CacheEntity cacheEntity : caches) {

keys.add(cacheEntity.getKey());

}

return keys;

}

/**

* 获取值列表

*

* @return

*/

public List getValues() {

List values = new ArrayList();

List caches = getCacheEntitys();

for (CacheEntity cacheEntity : caches) {

values.add(cacheEntity.getValue());

}

return values;

}

/**

* 查看元素存活时间，-1 失效，0 长期有效

*

* @param key

* @return

*/

public int ttl(String key) {

CacheEntity entity = find(key);

if (entity != null) {

return entity.ttl();

}

return -1;

}

/**

* 返回头部的元素

*

* @return

*/

public Object peek() {

CacheEntity entity = queue.peek();

if (entity != null) {

return entity.getValue();

}

return null;

}

/**

* 设置元素存活时间

*

* @param key

* @param second

*/

public void expire(String key, int second) {

CacheEntity entity = find(key);

if (entity != null) {

entity.setTimestamp(System.currentTimeMillis());

entity.setExpire(second);

}

}

/**

* 查看key是否存在

*

* @param key

* @return

*/

public boolean exist(String key) {

return find(key) != null;

}

/**

* 查看组是否为空

*

* @return

*/

public boolean isEmpty() {

return queue.isEmpty();

}

/**

* 获取存活元素的大小

*

* @return

*/

public int size() {

return getCacheEntitys().size();

}

/**

* 获取容量

*

* @return

*/

public Integer getCapacity() {

return capacity;

}

}缓存实体：

package com.qikenet.cache;

import java.io.Serializable;

/**

* 缓存实体

*

* @author panjing

* @date 2016年8月6日 上午9:33:25

* @project qikenet-group-cache

*/

public class CacheEntity implements Serializable {

private static final long serialVersionUID = 2082223810638865724L;

private String key; // key

private Object value;// 值

private Long timestamp;// 缓存的时候存的时间戳，用来计算该元素是否过期

private int expire = 0; // 默认长期有效

private Group group;// 容器

public CacheEntity(String key, Object value, Long timestamp, int expire, Group group) {

super();

this.key = key;

this.value = value;

this.timestamp = timestamp;

this.expire = expire;

this.group = group;

}

public void setTimestamp(Long timestamp) {

this.timestamp = timestamp;

}

public Long getTimestamp() {

return timestamp;

}

public String getKey() {

return key;

}

public void setKey(String key) {

this.key = key;

}

public Object getValue() {

return value;

}

public void setValue(Object value) {

this.value = value;

}

public int getExpire() {

return expire;

}

public void setExpire(int expire) {

this.expire = expire;

}

/**

* 获取剩余时间

*

* @return

*/

public int ttl() {

if (this.expire == 0) {

return this.expire;

}

return this.expire - getTime();

}

/**

* 获取当前时间和元素的相差时间

* @return

*/

private int getTime() {

if (this.expire == 0) {

return this.expire;

}

Long current = System.currentTimeMillis();

Long value = current - this.timestamp;

return (int) (value / 1000) + 1;

}

/**

* 是否到期

*

* @return

*/

public boolean isExpire() {

if (this.expire == 0) {

return true;

}

if (getTime() > this.expire) {

// 失效了就移除

group.delete(key);

return false;

}

return true;

}

}