自定义缓存学习

女爷i 2023-02-19 09:26 14阅读 0赞

package cache;
    
    /**
     * 缓存的实体类
     */
    public class Cache {
        /*
        键
         */
        private String key;
        /*
        值
         */
        private Object value;
        /*
        缓存时间限制
         */
        private Long timeout;
    
        public void setKey(String key) {
            this.key = key;
        }
    
        public void setValue(Object value) {
            this.value = value;
        }
    
        public void setTimeout(Long timeout) {
            this.timeout = timeout;
        }
    
        public String getKey() {
            return key;
        }
    
        public Object getValue() {
            return value;
        }
    
        public Long getTimeout() {
            return timeout;
        }
    
        @Override
        public String toString() {
            return "Cache{" +
                    "key='" + key + '\'' +
                    ", value=" + value +
                    ", timeout=" + timeout +
                    '}';
        }
    }

package cache;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class CacheManagement{
        //定义一个Map,相当于缓存池
        private Map<String,Cache> cacheMap = new HashMap<String,Cache>();
    
        /**
         *放入的缓存内容会过期
         * @param key  缓存的key值
        * @param value  缓存的value值
         * @param timeout  缓存失效的时间间隔
         */
        public synchronized void put(String key,Object value, Long timeout){
            Cache cache = new Cache();
            cache.setKey(key);
            cache.setValue(value);
            if(null != timeout){
                //设置cache失效的时间点
                cache.setTimeout(System.currentTimeMillis()+timeout);
            }
            cacheMap.put(key,cache);
        }
    
        /**
         *放入的缓存内容不会过期
         * @param key  缓存的key值
         * @param cache  缓存的value值
         */
        public synchronized void put(String key,Object cache){
            put(key,cache,null);
        }
    
        /**
         * 删除某个缓存内容
         * @param key
         */
        public synchronized void del(String key){
            cacheMap.remove(key);
        }
    
        /**
         * 获取某个缓存值
         * @param key
         * @return
         */
        public synchronized Object get(String key){
            Cache cache = (Cache) cacheMap.get(key);
            if(null == cache){
                return null;
            }
            return cache.getValue();
        }
    
        /**
         * 定时删除过期缓存
         */
        public synchronized void scheduleDelExpired(){
            for (String key :cacheMap.keySet()) {
                Cache cache = cacheMap.get(key);
                if(null == cache){
                    break;
                }
                Long timeout = cache.getTimeout();
                if(System.currentTimeMillis()-timeout > 0){
                    del(key);
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            final CacheManagement cacheManagement = new CacheManagement();
            cacheManagement.put("username","sunny",5000L);
            System.out.println("保存完成");
            String username = (String) cacheManagement.get("username");
            System.out.println(username);
    
    
            /*
            开启线程，定期执行任务
             */
            ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
            scheduledExecutorService.schedule(new Runnable() {
                public void run() {
                    cacheManagement.scheduleDelExpired();
                }
            },5000,TimeUnit.MILLISECONDS);
    
            //模拟休息6秒中
            Thread.sleep(6000);
            System.out.println("删除之后");
            String username2 = (String) cacheManagement.get("username");
            System.out.println(username2);
    
        }
    
    
    }

package cache;
    
    import java.util.UUID;
    
    /**
     * 生成Session的工具
     * 可以理解后台服务器往session中存值，客户端会需要拿jsessionId去获取session中存的东西
     */
    public class SessionUtils {
        private static CacheManagement cacheManagement;
    
        /**
         * 初始化方法
         */
        private static void init(){
            if(null == cacheManagement){
                cacheManagement = new CacheManagement();
            }
        }
    
        /**
         * 存session
         * @param value
         * @return
         */
        public static String setAttribute(Object value){
            init();
            String jsessionId = UUID.randomUUID().toString();
            cacheManagement.put(jsessionId,value);
            return jsessionId;
        }
    
        /**
         * 通过sessionId获取session存的值
         * @param key
         * @return
         */
        public static Object get(String key){
            Object o = cacheManagement.get(key);
            if(null != o){
                return o;
            }
            return  null;
        }
    
        public static void main(String[] args) {
            Cache cache = new Cache();
            cache.setKey("username");
            cache.setValue("sunn");
            String s = SessionUtils.setAttribute(cache);
            System.out.println(SessionUtils.get(s));
        }
    }

说明：

1、CacheManagement类理论情况上模拟的秒数应该和定时任务线程的延迟时间是相同的，这里主要想理解一下缓存的底层实现，加synchronized 是为了在main方法中验证时同步执行，然后能看出删除之后的效果。