Java项目全局缓存实现方案

不念不忘少年蓝@ 2022-02-19 03:25 346阅读 0赞

废话不多说直接上代码，缓存实现的接口：

缓存实体：

public class CacheManagerEntity {
    
        /**
         * 保存的数据
         */
        private Object datas;
    
        /**
         * 设置数据失效时间,为0表示永不失效
         */
        private long timeOut;
    
        /**
         * 最后刷新时间
         */
        private long lastRefeshTime;
    
        public CacheManagerEntity(Object datas) {
            this.datas = datas;
        }
    
        public CacheManagerEntity(Object datas, long timeOut, long lastRefeshTime) {
            this.datas = datas;
            this.timeOut = timeOut;
            this.lastRefeshTime = lastRefeshTime;
        }
    
        public Object getDatas() {
            return datas;
        }
    
        public void setDatas(Object datas) {
            this.datas = datas;
        }
    
        public long getTimeOut() {
            return timeOut;
        }
    
        public void setTimeOut(long timeOut) {
            this.timeOut = timeOut;
        }
    
        public long getLastRefeshTime() {
            return lastRefeshTime;
        }
    
        public void setLastRefeshTime(long lastRefeshTime) {
            this.lastRefeshTime = lastRefeshTime;
        }
    }

缓存接口：

public interface ICacheManager {
    
        /**
         * 存入缓存
         * @param key
         * @param cache
         */
        void putCache(String key, CacheManagerEntity cache);
    
        /**
         * 存入缓存
         * @param key
         * @param datas
         * @param timeOut
         */
        void putCache(String key, Object datas, long timeOut);
    
        /**
         * 获取对应缓存
         * @param key
         * @return
         */
        CacheManagerEntity getCacheByKey(String key);
    
        /**
         * 获取对应缓存
         * @param key
         * @return
         */
        Object getCacheDataByKey(String key);
    
        /**
         * 获取所有缓存
         * @return
         */
        Map<String, CacheManagerEntity> getCacheAll();
    
        /**
         * 判断是否在缓存中
         * @param key
         * @return
         */
        boolean isContains(String key);
    
        /**
         * 清除所有缓存
         */
        void clearAll();
    
        /**
         * 清除对应缓存
         * @param key
         */
        void clearByKey(String key);
    
        /**
         * 缓存是否为空
         */
        boolean isEmpty();
    
        /**
         * 缓存是否超时失效
         * @param key
         * @return
         */
        boolean isTimeOut(String key);
    
        /**
         * 获取所有key
         * @return
         */
        Set<String> getAllKeys();
    
    }

缓存的接口实现服务

@Service
    public class CacheManagerImpl implements ICacheManager {
    
        private static Map<String, CacheManagerEntity> caches = new HashMap<String, CacheManagerEntity>();
    
        /**
         * 存入缓存
         * @param key
         * @param cache
         */
        public void putCache(String key, CacheManagerEntity cache) {
            caches.put(key, cache);
        }
    
        /**
         * 存入缓存
         * @param key
         * @param datas
         * @param timeOut
         */
        public void putCache(String key, Object datas, long timeOut) {
            timeOut = timeOut > 0 ? timeOut : 0L;
            putCache(key, new CacheManagerEntity(datas, timeOut, System.currentTimeMillis()));
        }
    
        /**
         * 获取对应缓存
         * @param key
         * @return
         */
        public CacheManagerEntity getCacheByKey(String key) {
            if (this.isContains(key)) {
                return caches.get(key);
            }
            return null;
        }
    
        /**
         * 获取对应缓存
         * @param key
         * @return
         */
        public Object getCacheDataByKey(String key) {
            if (this.isContains(key)) {
                return caches.get(key).getDatas();
            }
            return null;
        }
    
        /**
         * 获取所有缓存
         * @return
         */
        public Map<String, CacheManagerEntity> getCacheAll() {
            return caches;
        }
    
        /**
         * 判断是否在缓存中
         * @param key
         * @return
         */
        public boolean isContains(String key) {
            return caches.containsKey(key);
        }
    
        /**
         * 清除所有缓存
         */
        public void clearAll() {
            caches.clear();
        }
    
        /**
         * 清除对应缓存
         * @param key
         */
        public void clearByKey(String key) {
            if (this.isContains(key)) {
                caches.remove(key);
            }
        }
    
        /**
         * 缓存是否为空
         */
        public boolean isEmpty(){
            return caches.isEmpty();
        }
    
        /**
         * 缓存是否超时失效
         * @param key
         * @return
         */
        public boolean isTimeOut(String key) {
            if (!caches.containsKey(key)) {
                return true;
            }
            CacheManagerEntity cache = caches.get(key);
            long timeOut = cache.getTimeOut();
            long lastRefreshTime = cache.getLastRefeshTime();
            if (timeOut == 0 || System.currentTimeMillis() - lastRefreshTime >= timeOut) {
                return true;
            }
            return false;
        }
    
        /**
         * 获取所有key
         * @return
         */
        public Set<String> getAllKeys() {
            return caches.keySet();
        }
    }

最后直接注入ICacheManager 既可以使用，下面以springboot项目启动加载数据库数据并存放在缓存中作为示例：

@Component
    public class CacheManagerConfig implements ApplicationRunner{
    
        @Autowired
        private ICacheManager cacheManager;
    
        @Autowired
        private IService service;
    
        @Autowired
        private IConsumerService consumerService;
    
        public boolean storeCache(){
            /**
             * 项目启动加载所有编码
             */
            List<BizCode> bizList = service.getAllBizCode();
            /**
             * 项目启动加载所有消费系统
             */
            List<Consumer> consumerList = consumerService.queryAllConsumer();
    
            /**
             * 清空缓存中现有数据
             */
            cacheManager.clearAll();
    
            /**
             * 项目启动由APPID和编码作为联合主键 存放相对应业务场景(从新存放至缓存)
             */
            bizList.forEach(bizCode -> {
                cacheManager.putCache(bizCode.getAppId()+"-"+bizCode.getServiceCode(),
                        new CacheManagerEntity(bizCode));
            });
            /**
             * 项目启动由APPID 作为key 存放相对应消费系统信息(从新存放至缓存)
             */
            consumerList.forEach(consumer -> {
                cacheManager.putCache(consumer.getAppId(),
                        new CacheManagerEntity(consumer));
            });
            if (cacheManager.isEmpty()){
                return false;
            }
            return true;
        }
    
    
        @Override
        public void run(ApplicationArguments args) throws Exception {
            this.storeCache();
        }
    }

**如有披露或问题欢迎留言或者入群探讨**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz_size_16_color_FFFFFF_t_70]: /images/20220219/a2f9a528518c4dd1833aae181b57bdbd.png