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("获取失败..");
        }
    }
}

大功告成

猜你喜欢