本地缓存LRU

最新推荐文章于 2023-04-26 17:31:12 发布
最新推荐文章于 2023-04-26 17:31:12 发布
阅读量426 收藏
点赞数

1、缓存管理接口定义

public interface CacheManager {

    /**
     * 设置缓存.
     * 
     * @param type
     * @param key
     * @param data
     * @param expired 缓存有效时间，单位ms
     */
    void put(CacheEnum type, String key, Object data, long cacheTime);

    /**
     * 获取数据.
     * <p>
     * <B>返回实际缓存数据，非封装数据.</B>
     * 当数据过期，返回<code>NULL</code>
     * </p>
     * @param type
     * @param key
     * @return
     */
    Object get(CacheEnum type, String key);

    /**
     * 删除本地KEY.
     * 
     * @param type
     * @param key
     */
    void remove(CacheEnum type, String key);

    /**
     * 删除某一类本地缓存.
     * 
     * @param type
     */
    void clean(CacheEnum type);

    /**
     * dump数据.
     * 
     * @return
     */
    Map<String, String> dump();
}

2、定义缓存类别

</pre><p><pre name="code" class="java">public enum CacheEnum {

    /** 默认枚举. */
    DEFAULT("DEFAULT"),

    ……

    private String code;

    CacheEnum(String code) {
        this.code = code;
    }

    /**
     * 根据code获取枚举.
     * 
     * @param code
     * @return
     */
    public static CacheEnum getEnumByCode(String code) {
        if (StringUtils.isEmpty(code)) {
            return null;
        }

        for (CacheEnum cache : values()) {
            if (StringUtils.equals(code, cache.getCode())) {
                return cache;
            }
        }

        return null;
    }

    /**
     * Getter method for property <tt>code</tt>.
     * 
     * @return property value of code
     */
    public String getCode() {
        return code;
    }

}
3、本地缓存实际存储位置 

public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {

    /** serialVersionUID. */
    private static final long  serialVersionUID    = -8176202087056001991L;

    /** 加载因子. */
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /** 最大容量. */
    private int                maxCapacity;

    /** 植入锁. */
    private final Lock         lock                = new ReentrantLock();

    /**
     * 构造器.
     * @param maxCapacity 最大容量
     */
    public LRULinkedHashMap(int maxCapacity) {
        super(maxCapacity, DEFAULT_LOAD_FACTOR, Boolean.TRUE);
        this.maxCapacity = maxCapacity;
    }

    /**
     * 
     * @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry)
     */
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > maxCapacity;
    }

    /**
     * 
     * @see java.util.HashMap#containsKey(java.lang.Object)
     */
    public boolean containsKey(Object key) {
        lock.lock();
        try {
            return super.containsKey(key);
        } finally {
            lock.unlock();
        }
    }

    /**
     * 
     * @see java.util.LinkedHashMap#get(java.lang.Object)
     */
    public V get(Object key) {
        lock.lock();
        try {
            return super.get(key);
        } finally {
            lock.unlock();
        }
    }

    /**
     * 
     * @see java.util.HashMap#put(java.lang.Object, java.lang.Object)
     */
    public V put(K key, V value) {
        lock.lock();
        try {
            return super.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    /**
     * 
     * @see java.util.HashMap#size()
     */
    public int size() {
        lock.lock();
        try {
            return super.size();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 
     * @see java.util.LinkedHashMap#clear()
     */
    public void clear() {
        lock.lock();
        try {
            super.clear();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 
     * @see java.util.HashMap#remove(java.lang.Object)
     */
    public V remove(Object key) {
        lock.lock();
        try {
            return super.remove(key);
        } finally {
            lock.unlock();
        }
    }

    /** 
     * 批量删除对象.
     * 
     * @param objArrs
     */
    public void batchDelete(Object[] objArrs) {
        lock.lock();
        try {
            for (int i = 0; i < objArrs.length; i++) {
                remove(objArrs[i]);
            }
        } finally {
            lock.unlock();
        }
    }
}
4、Cache对象 

class CacheData {

    /** 缓存实际数据. */
    private Object data;

    /** 过期时间. */
    private long   expired;

    /**
     * Getter method for property <tt>data</tt>.
     * 
     * @return property value of data
     */
    public Object getData() {
        return data;
    }

    /**
     * Setter method for property <tt>data</tt>.
     * 
     * @param data value to be assigned to property data
     */
    public void setData(Object data) {
        this.data = data;
    }

    /**
     * Getter method for property <tt>expired</tt>.
     * 
     * @return property value of expired
     */
    public long getExpired() {
        return expired;
    }

    /**
     * Setter method for property <tt>expired</tt>.
     * 
     * @param expired value to be assigned to property expired
     */
    public void setExpired(long expired) {
        this.expired = expired;
    }

}
5、实际本地缓存类 

public class LocalCacheManager implements CacheManager, InitializingBean {

    private final Logger                                        logger       = LoggerFactory
                                                                                 .getLogger(LocalCacheManager.class);

    private static final int                                    DEFAULT_SIZE = 1000;

    /** 缓存模块及对应模块缓存数据上限的配置. */
    private Map<String, Integer>                                cacheConfigs;

    private Map<CacheEnum, LRULinkedHashMap<String, CacheData>> instances;

    private static final String                                 TIPS         = "invalid cache type=";

    public LocalCacheManager() {
        this(CacheEnum.DEFAULT, DEFAULT_SIZE);
    }

    public LocalCacheManager(CacheEnum type, int size) {
        if (null == type || size <= 0) {
            throw new IllegalArgumentException("type=" + type + ",size=" + size);
        }
        cacheConfigs = new HashMap<String, Integer>();
        cacheConfigs.put(type.getCode(), Integer.valueOf(size));

        try {
            afterPropertiesSet();
        } catch (Exception e) {
            logger.error("init local cache failed!", e);
        }
    }

    /**
     * 
     * @see com.lenovo.appstore.biz.cache.CacheManager#put(com.lenovo.appstore.biz.cache.CacheEnum, java.lang.String, java.lang.Object, long)
     */
    @Override
    public void put(CacheEnum type, String key, Object data, long cacheTime) {
        if (null == type || null == data || StringUtils.isEmpty(key)) {
            LoggerUtil.warn(logger, "put fail,key=" + key + ",type=" + type + ",data=" + data);
            return;
        }

        if (null == instances) {
            return;
        }

        LRULinkedHashMap<String, CacheData> instance = instances.get(type);
        if (null == instance) {
            LoggerUtil.warn(logger, TIPS + type);
            return;
        }

        CacheData cache = new CacheData();
        cache.setData(data);
        cache.setExpired(cacheTime + System.currentTimeMillis());

        instance.put(key, cache);
    }

    /** 
     * @see com.lenovo.appstore.biz.cache.CacheManager#get(com.lenovo.appstore.biz.cache.CacheEnum, java.lang.String)
     */
    @Override
    public Object get(CacheEnum type, String key) {
        if (null == type || StringUtils.isEmpty(key)) {
            LoggerUtil.warn(logger, "get failed,key=" + key, ",type=" + type);
            return null;
        }

        if (null == instances) {
            LoggerUtil.warn(logger, "no cache config");
            return null;
        }

        LRULinkedHashMap<String, CacheData> instance = instances.get(type);
        if (null == instance) {
            LoggerUtil.warn(logger, TIPS + type);
            return null;
        }

        CacheData data = instance.get(key);
        //没有缓存
        if (null == data) {
            return null;
        }

        //缓存过期
        if (System.currentTimeMillis() > data.getExpired()) {
            //从本地缓存删除
            instance.remove(key);
            LoggerUtil.info(logger, "cache expire,key=" + key + ",data=" + data.getData(), ",type=" + type);
            return null;
        }

        return data.getData();
    }

    /**
     * 
     * @see com.lenovo.appstore.biz.cache.CacheManager#remove(com.lenovo.appstore.biz.cache.CacheEnum, java.lang.String)
     */
    @Override
    public void remove(CacheEnum type, String key) {
        if (null == type || StringUtils.isEmpty(key)) {
            return;
        }

        if (null == instances) {
            LoggerUtil.warn(logger, "no cache config");
            return;
        }

        LRULinkedHashMap<String, CacheData> instance = instances.get(type);
        if (null == instance) {
            LoggerUtil.warn(logger, TIPS + type);
            return;
        }

        LoggerUtil.info(logger, "delete key=" + key, "|type=" + type);
        instance.remove(key);
    }

    /** 
     * @see com.lenovo.appstore.biz.cache.CacheManager#clean(com.lenovo.appstore.biz.cache.CacheEnum)
     */
    @Override
    public void clean(CacheEnum type) {
        if (null == type) {
            return;
        }

        if (null == instances) {
            LoggerUtil.warn(logger, "no cache config");
            return;
        }

        LRULinkedHashMap<String, CacheData> instance = instances.get(type);
        if (null == instance) {
            LoggerUtil.warn(logger, TIPS + type);
            return;
        }

        LoggerUtil.warn(logger, "clean local cache for type=" + type);
        instance.clear();
    }

    /**
     * 
     * @see com.lenovo.appstore.biz.cache.CacheManager#dump()
     */
    public Map<String, String> dump() {
        Map<String, String> stats = new HashMap<String, String>();
        if (null == instances || instances.size() == 0) {
            LoggerUtil.info(logger, "no local cache");
            stats.put("msg", "no local cache");
            return stats;
        }

        for (Map.Entry<CacheEnum, LRULinkedHashMap<String, CacheData>> entry : instances.entrySet()) {
            LoggerUtil.info(logger, "cache type=" + entry.getKey(), "|current cache size=" + entry.getValue().size());
            stats.put("cache type=" + entry.getKey(), " current cache size=" + entry.getValue().size());
        }

        return stats;
    }
}
6、配置初始化 

    @Override
    public void afterPropertiesSet() throws Exception {
        if (null == cacheConfigs || cacheConfigs.size() == 0) {
            LoggerUtil.warn(logger, "no local cache config");
            return;
        }

        instances = new HashMap<CacheEnum, LRULinkedHashMap<String, CacheData>>();
        for (Map.Entry<String, Integer> entry : cacheConfigs.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            CacheEnum cache = CacheEnum.getEnumByCode(key);
            if (null == cache) {
                LoggerUtil.warn(logger, "invalid cache type");
                continue;
            }

            if (null == value) {
                LoggerUtil.warn(logger, "invalid cache capacity");
                continue;
            }

            LRULinkedHashMap<String, CacheData> instance = new LRULinkedHashMap<String, CacheData>(value.intValue());
            instances.put(cache, instance);
        }

        dump();
    }

    /**
     * Setter method for property <tt>cacheConfigs</tt>.
     * 
     * @param cacheConfigs value to be assigned to property cacheConfigs
     */
    public void setCacheConfigs(Map<String, Integer> cacheConfigs) {
        this.cacheConfigs = cacheConfigs;
    }







txx3258
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中LocalCache本地缓存实现代码
08-30
本篇文章主要介绍了Java中LocalCache本地缓存实现代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
本地缓存与LRU
weixin_30514745的博客
07-20 263
　　LRU这是一种内存淘汰算法，实际上解释它也挺简单的，分为两个维度：1.容量；2.时间。 　　我们有一个有界队列，如果不断地往其中写入数据，总会满的，这个时候需要对数据进行淘汰。如果超过了容量，在插入数据的时候应该淘汰哪些数据。那就是不经常用的，冷数据。LRU的主旨是保存最近经常使用的数据，经常使用的数据叫做热点数据，保留它们的价值在于：它们经常被访问，从缓存中取就不用去频繁访问数据...
本地缓存是新LRUMap，最早最先回收缓存Java代码实现
java技术专家全栈成长之路
02-01 424
可以使用Java里面的Map结构进行实现LRU。可以参考Aviator里面的代码实现。
算法题（2）- 本地缓存的实现（LRU）
justeie的博客
09-28 160
LRU 的实现
Springboot 自定义缓存配置 CacheManager 及redis集成
Ricardo.M.Yu的博客
04-26 3426
现有项目中经常遇到的缓存集成问题，Springboot提供了统一的接口抽象与缓存管理器，可集成多种缓存类型，如 ConcurrentMap 缓存、redis缓存，并可以随时无缝替换底层缓存存储。
Caffeine本地缓存
最新发布
04-27
Caffeine是一个高性能的本地缓存库，专为Java 8设计，被广泛应用于需要快速访问数据的场景，尤其在Spring 5之后成为了默认的缓存实现，替代了原本的Guava缓存。本地缓存的优势在于它可以避免网络通信带来的延迟，...
Java利用ConcurrentHashMap实现本地缓存demo
05-25
Java利用ConcurrentHashMap实现本地缓存demo； 基本功能有缓存有效期、缓存最大数、缓存存入记录、清理线程、过期算法删除缓存、LRU算法删除、获取缓存值等功能。 复制到本地项目的时候，记得改包路径哦~
redis本地缓存与redis缓存
02-14
然而，由于涉及网络通信，Redis缓存的读写速度相对于本地缓存略慢，但可以通过设置合适的缓存策略（如LRU、LFU）和主从复制、分片等技术来优化性能。 在实际应用中，本地缓存通常用于短期、频繁访问且对数据一致性...
Android开发之ImageLoader本地缓存
09-02
本篇文章将深入探讨ImageLoader的本地缓存机制。 ImageLoader的本地缓存主要分为两部分：内存缓存和磁盘缓存。内存缓存用于快速读取最近使用的图片，而磁盘缓存则用于长期存储图片，即使应用关闭后也能重新加载。这...
android本地缓存
08-16
在Android开发中，本地缓存是一种常见的技术，用于提高应用性能和用户体验。本地缓存能够减少网络请求，避免频繁的数据加载，特别是在用户离线时也能访问之前加载过的数据。本篇文章将详细介绍Android本地缓存的基本...
Java进阶篇缓存底层设计(LRU、LFU、FIFOCache)
Dream_it_possible！的博客
04-17 2380
采用策略模式和工厂模式生成并创建缓存 函数式编程的应用 有效加锁提升并发能力 通过降低锁粒度提升并发能力 读多写少的场景采用乐观锁
分桶策略清理SpringCache中的缓存
并发笔记 - ofcoder.com
06-06 957
背景介绍我们使用SpringCache框架 + Redis来实现项目中的缓存实现，它能实现自动对数据缓存，也可以自动清理过期的缓存。大多数情况下，它都运行非常好。这是因为我们需要缓存的数据，通常都是可序列化的，但是我们迟早会遇到不可序列化的对象。那么我们只能选择SpringCache中的ConcurrentMapCache才能缓存这些不可序列化的对象，但是Concurre...
LRU缓存机制算法实现
Chris'blog
07-10 624
问题描述： 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近...
[Spring预加载]InitializingBean接口
weixin_43303530的博客
06-22 633
很多时候我们程序要查询的数据量太大了，无论怎么进行SQL优化，查询的时间仍可能达到数秒，这个时候对于用户的体验就是非常不好的，这个时候我们就可以采用预加载的方法，在Web容器启动时加载相应的数据查询方法，将得到的数据放入缓存，这样当用户来请求数据的时候，我们就可以将缓存中的数据返回给用户，从而提高用户体验。 实现InitializingBean接口是实现Spring预加载的采用手段，实现流程： 创建一个bean(注：InitializingBean接口是基于bean实现的)，实现Initializi.
Java LocalCache 本地缓存的实现实例
lemonrel的博客
11-11 1675
使用场景 在Java应用中，对于访问频率高，更新少的数据，通常的方案是将这类数据加入缓存中。相对从数据库中读取来说，读缓存效率会有很大提升。 在集群环境下，常用的分布式缓存有Redis、Memcached等。但在某些业务场景上，可能不需要去搭建一套复杂的分布式缓存系统，在单机环境下，通常是会希望使用内部的缓存（LocalCache）。 实现 这里提供了两种LocalCache的实现，一种是基于Co...
vue的 sessionStorage 数据缓存
漏网之鱼的博客
09-16 962
存储缓存： sessionStorage.setItem(“iszan”, this.zanon); 获取缓存： sessionStorage.getItem(“iszan”) 删除缓存： sessionStorage.removeItem(“iszan”); 页面加载： created() { if (sessionStorage.getItem("iszan")) { this.zanon = sessionStorage.getItem("iszan"); /
spring cloud中redis多数据源的使用和LocalCache本地缓存的使用
qq_34652478的博客
11-27 1434
在srping cloud中，有个domain项目为数据字典，我现在的需求是，数据字典放在redis的15中，所以需要配置redis的多数据源。然后，在其他项目中，开启缓存，从redis15库中获取到所有数据。放到本地的缓存。所以缓存这一块考虑使用LocalCache。 首先：在domain项目中，实现redis的多数据源配置。然后在刷新缓存按钮触发时，把数据从DB存储到redis15库，在这个时...
LRU缓存（LRUCache）
爱写bug的王六六
02-27 5392
146. LRU 缓存 题目描述： 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存（cache） int get(int key)如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ； 如果不存在，则向缓存
CacheManager配置
chenkaibsw的专栏
07-08 1113
CacheManager配置
详细解释一下本地缓存项目中的LRU
03-21
LRU（Least Recently Used）是一种缓存淘汰算法，它的基本思想是将最近最少使用的缓存项淘汰掉，从而保留最常用的缓存项。在实现中，可以使用一个双向链表和一个哈希表来实现LRU缓存。具体来说，哈希表用于快速查找...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值