Java代码模拟Redis

Redis是C语言编写的NoSQL 存储形式是K->V 可以搭建集群(健壮) 相比memcached一个key对应的value最大只能存储1M而言Redis则十分慷慨可以支持1G(如果你内存足够大未尝不可)
Redis能够存储String,List,Set(无序),ZSet(有序).Redis支持push/pop,add/remove等操作,并且这些操作都是原子性的.Redis是单进程单线程的
说个题外话,记得吉利集团有一次面试,有个面试官一直质疑我Redis怎么可能是单进程单线程的,我坚持了一番最后笑而不语.当然面试顺理成章地就挂了….

闲来无事在家用Java代码模拟了一个Redis.
先定义一个POJO 定义一个Object来模拟存入的对象,定义了过期时间的值和存入的时间的时间戳.

package com.unsc;
import java.io.Serializable;
/**
* Created by DELL on 2017/12/16.
* 模拟Redis存入的对象的POJO
* @author 犯罪嫌疑人卢某
*/
public class RedisPOJO implements Serializable {
/**
* 存入的对象
*/
private Object value;
/**
* 对象存入时 / 修改时的时间戳
*/
private long modifyTime;
/**
* 过期时间 单位int:秒
*/
private int expireTime;
public RedisPoJO(Object value, long modifyTime, int expireTime) {
this.value = value;
this.modifyTime = modifyTime;
this.expireTime = expireTime;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
public long getModifyTime() {
return modifyTime;
}
public void setModifyTime(long modifyTime) {
this.modifyTime = modifyTime;
}
public int getExpireTime() {
return expireTime;
}
public void setExpireTime(int expireTime) {
this.expireTime = expireTime;
}
}

再定义一个类来模拟Redis的功能

package com.unsc;
import java.io.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
/**
* Created by DELL on 2017/12/16.
* 模拟Redis的功能
* @author 犯罪嫌疑人卢某
*/
public class RedisCache {
//默认的缓存容量

private static int DEFAULT_CAPACITY = 512;
//最大容量

private static int MAX_CAPACITY = 100000;
//刷新缓存的频率
秒
private static int MONITOR_DURATION = 180;
// 启动监控线程

static {
new Thread(new TimeoutTimerThread()).start();
}
//使用默认容量创建一个Map

private static ConcurrentHashMap<String, RedisPOJO> cache = new ConcurrentHashMap<String, RedisPOJO>(
DEFAULT_CAPACITY);
/**
* 将key-value 保存到本地缓存并制定该缓存的过期时间
*
* @param key
* @param value
* @param expireTime 过期时间，如果是-1 则表示永不过期
单位秒
* @return
*/
public boolean putValue(String key, Object value, int expireTime) {
return putCloneValue(key, value, expireTime);
}
/**
* 将值通过序列化clone 处理后保存到缓存中，可以解决值引用的问题
*
* @param key
* @param value
* @param expireTime
* @return
*/
private boolean putCloneValue(String key, Object value, int expireTime) {
try {
if (cache.size() >= MAX_CAPACITY) {
return false;
}
// 序列化赋值

RedisPOJO entityClone = clone(new RedisPOJO(value, System.nanoTime(), expireTime));
cache.put(key, entityClone);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
*
* 序列化 克隆处理
* @param object
* @return
*/
private <T extends Serializable> T clone(T object) {
T cloneObject = null;
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(object);
oos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
cloneObject = (T) ois.readObject();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
return cloneObject;
}
/**
*从本地缓存中获取key对应的值，如果该值不存在则返回null
*
* @param key
* @return
*/
public Object getValue(String key) {
return cache.get(key).getValue();
}
/**
* 清空所有
*/
public void clear() {
cache.clear();
}
/**
* 过期处理线程
*
* @author Lenovo
* @version
*/
static class TimeoutTimerThread implements Runnable {
@Override
public void run() {
while (true) {
try {
System.out.println("监控缓存是否过期...");
TimeUnit.SECONDS.sleep(MONITOR_DURATION);
checkTime();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 过期缓存的具体处理方法
* @throws Exception
*/
private void checkTime() throws Exception {
//"开始处理过期 ";

for (String key : cache.keySet()) {
RedisPOJO tce = cache.get(key);
long timoutTime = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime()
- tce.getModifyTime());
//" 过期时间 : "+timoutTime);

if (tce.getExpireTime() > timoutTime) {
continue;
}
System.out.println(" 清除过期缓存 ： " + key);
//清除过期缓存和删除对应的缓存队列

cache.remove(key);
}
}
}
}

最后写一个测试类来测试一下

package com.unsc;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* Created by DELL on 2017/12/16.
* 模拟Redis测试类
* @author 犯罪嫌疑人卢某
*/
public class RedisTest {
public static void main(String[] args) {
RedisCache cache = new RedisCache();
List<Object> list = new ArrayList<>();
Map<String, Object> map = new ConcurrentHashMap<>();
map.put("Key1" , "Value1");
map.put("Key2" , "Value2");
list.add(map);
cache.putValue("R1" , "12345" , 1);
try {
Thread.sleep(3000);
System.out.println("获取成功 : " + cache.getValue("R1"));
} catch (Exception e) {
System.out.println("获取失败..");
}
}
}

大功告成

最后

以上就是辛勤花瓣为你收集整理的Java代码模拟Redis的全部内容，希望文章能够帮你解决Java代码模拟Redis所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。