本地缓存google.guava及分布式缓存redis 随笔

近期项目用到了缓存,我选用的是主流的google.guava作本地缓存,redis作分布式

缓存,先说说我对本地缓存和分布式缓存的理解吧,可能不太成熟的地方,大家指出,一起

学习.本地缓存的特点是速度快,不会受到网络阻塞的干扰,但由于是放在本地内存中,所

以容量较小,不能项目间共享比IO效率高比redis,且不会持久化.所以拿来存储一些数据

很少,但又经常执行的,甚至只要启动程序就会访问的数据.

我们可以自定义初始化本地缓存的方法,指定存储量和缓存淘汰机制.

/**
 * 初始化本地缓存
 */
@PostConstruct
public void init() {
    commonCache = CacheBuilder.newBuilder()
            //设置缓存的
            .initialCapacity(10)
            //设置缓存中最大可以存储的key数量,超过就会按照LRU的策略进行清除
            .maximumSize(100).expireAfterWrite(60, TimeUnit.SECONDS).build();
}
几种常见的内存淘汰机制:LRU,LFU
LFU:根据数据的历史访问频率来淘汰数据
LRU:根据访问时间的前后来淘汰数据,优先保留近期访问的数据
guava是极度轻量级的cache,只具备基本的增删改查和刷新数据,淘汰数据等功能,但能满足大部分需求.

redis作为常用的分布式缓存,他是nosql数据库,默认3主3从的无中心的分布式存储架构,可以用来提高
并发量,分布式主键等功能.redis有rdb(快照)和aof两种持久化到硬盘的方式,默认是rdb,快照能够高
效且高性能的持久化数据,但存在数据丢失的风险,所以aof-日志保存应运而出.aof能够在用户操作
redis时把每一个命令存储下来,在出现宕机时,通过日志还原数据.但这样日志文件就会非常大,redis
提供了一种重写压缩aof文件的机制BGREWRITEAOF命令.

redis集群的复制原理: 
1、Slave启动成功连接到master后会发送一个sync命令；
2、Master接到命令启动后的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行
完毕之后，master
将传送整个数据文件到slave，以完成一次完全同步；
3、全量复制：而slave服务在数据库文件数据后，将其存盘并加载到内存中；
4、增量复制：Master继续将新的所有收集到的修改命令依次传给slave，完成同步；
5、但是只要是重新连接master，一次完全同步（全量复制）将被自动执行
redis采用的是纯内存操作,非阻塞单线程多路复用,单线程可以避免上下文频繁切换,多路复用提高效率.

Redis 采用的是定期删除+惰性删除策略。
定时删除，用一个定时器来负责监视 Key，过期则自动删除。虽然内存及时释放，但是十分消耗 CPU 资源。
在大并发请求下，CPU 要将时间应用在处理请求，而不是删除 Key，因此没有采用这一策略。
定期删除+惰性删除是如何工作:
定期删除，Redis 默认每个 100ms 检查，是否有过期的 Key，有过期 Key 则删除。
需要说明的是，Redis 不是每个 100ms 将所有的 Key 检查一次，而是随机抽取进行检查(如果每隔 100ms，
全部 Key 进行检查，Redis 岂不是卡死)。因此，如果只采用定期删除策略，会导致很多 Key 到时间没有
删除。于是，惰性删除派上用场。也就是说在你获取某个 Key 的时候，Redis 会检查一下，这个 Key 
如果设置了过期时间，那么是否过期了？如果过期了此时就会删除。
采用定期删除+惰性删除就没其他问题了么?
不是的，如果定期删除没删除 Key。然后你也没即时去请求 Key，也就是说惰性删除也没生效。
这样，Redis的内存会越来越高。那么就应该采用内存淘汰机制。

过期策略存在的问题：
由于redis定期删除是随机抽取检查，不可能扫描清除掉所有过期的key并删除，然后一些key由于未被请求，
惰性删除也未触发。这样redis的内存占用会越来越高。此时就需要内存淘汰机制 。

redis内存淘汰机制:
volatile-lru
从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。redis并不是保证取得所有数据集中最近最少
使用的键值对，而只是随机挑选的几个键值对中的， 当内存达到限制的时候无法写入非过期时间的数据集。
volatile-ttl
从已设置过期时间的数据集中挑选将要过期的数据淘汰。redis 并不是保证取得所有数据集中最近将要
过期的键值对，而只是随机挑选的几个键值对中的， 当内存达到限制的时候无法写入非过期时间的数据集。
volatile-random
从已设置过期时间的数据集中任意选择数据淘汰。当内存达到限制的时候无法写入非过期时间的数据集。
allkeys-lru
从数据集中挑选最近最少使用的数据淘汰。当内存达到限制的时候，对所有数据集挑选最近最少使用的数据
淘汰，可写入新的数据集。
allkeys-random
从数据集中任意选择数据淘汰，当内存达到限制的时候，对所有数据集挑选随机淘汰，可写入新的数据集。
no-enviction
当内存达到限制的时候，不淘汰任何数据，不可写入任何数据集，所有引起申请内存的命令会报错。
下面看看几种策略的适用场景
allkeys-lru：如果我们的应用对缓存的访问符合幂律分布，也就是存在相对热点数据，
或者我们不太清楚我们应用的缓存访问分布状况，我们可以选择allkeys-lru策略。
allkeys-random：如果我们的应用对于缓存key的访问概率相等，则可以使用这个策略。
volatile-ttl：这种策略使得我们可以向Redis提示哪些key更适合被eviction。
另外，volatile-lru策略和volatile-random策略适合我们将一个Redis实例既应用于
缓存和又应用于持久化存储的时候，然而我们也可以通过使用两个Redis实例来达到相同的效果，
将key设置过期时间实际上会消耗更多的内存，因此我们建议使用allkeys-lru策略从而更有效率的使用内存。

redis的String字符串的应用场景:
String类型二进制安全
1、缓存功能：String字符串是最常用的数据类型，不仅仅是redis，各个语言都是最基本类型，
因此，利用redis作为缓存，配合其它数据库作为存储层，利用redis支持高并发的特点，可以大大加快系统的
读写速度、以及降低后端数据库的压力。
2、计数器：许多系统都会使用redis作为系统的实时计数器，可以快速实现计数和查询的功能。
而且最终的数据结果可以按照特定的时间落地到数据库或者其它存储介质当中进行永久保存。
3、共享用户session：用户重新刷新一次界面，可能需要访问一下数据进行重新登录，或者访问页面缓存cookie，
但是可以利用redis将用户的session集中管理，在这种模式只需要保证redis的高可用，
每次用户session的更新和获取都可以快速完成。大大提高效率。
4,限制某段时间内的访问次数，就比如我们登录的功能可以用手机获取验证码登录，但是我们发送验证码使用的第三方，
是多少钱多少条的，肯定不能让他一直点，一直发短信，就算前端js做了校验，若有些人用fiddler拦截绕过前台就麻烦了，
这时候可以用redis的incr命令和expire结合起来做一个解决方案
5，分布式锁 setnx  expire（过期时间）
redis的hashmap类型的应用场景:
1,Hash存储购物车数据的操作
2.存储用户关系，用户id,年龄，姓名是key对应value值
3.hash 类型十分适合存储对象类数据，相对于在 string 中介绍的把对象转化为 json 字符串存储，
hash 的结构可以任意添加或删除‘字段名’，更加高效灵活。
4.类似于表记录的存储
5.页面视图所需数据的存储
redis的list类型的应用场景:
对数据量大的集合数据删减
列表数据显示、关注列表、粉丝列表、留言评价等…分页、热点新闻（Top5)等
利用LRANGE还可以很方便的实现分页的功能,在博客系统中，每片博文的评论也可以存入一个单独的list中。

任务队列
(list通常用来实现一个消息队列，而且可以确保先后顺序，不必像MySQL那样还需要通过ORDER BY来进行排序)
redis的set类型的应用场景:
对两个集合间的数据[计算]进行交集、并集、差集运算
1、以非常方便的实现如共同关注、共同喜好、二度好友等功能。对上面的所有集合操作，你还可以使用不同的命令
选择将结果返回给客户端还是存储到一个新的集合中。
2、利用唯一性，可以统计访问网站的所有独立 IP
redis的zset类型的应用场景:
常应用于：排行榜
1比如twitter 的public timeline可以以发表时间作为score来存储，这样获取时就是自动按时间排好序的。
2比如一个存储全班同学成绩的Sorted Set，其集合value可以是同学的学号，而score就可以是其考试得分，
这样在数据插入集合的时候，就已经进行了天然的排序
3还可以用Sorted Set来做带权重的队列，比如普通消息的score为1，重要消息的score为2，然后工作线程
可以选择按score的倒序来获取工作任务。让重要的任务优先执行。
RESP 是redis客户端和服务端之前使用的一种通讯协议；
RESP 的特点：实现简单、快速解析、可读性好

缓存和数据库一致性解决方案
1.第一种方案：采用延时双删策略
在写库前后都进行redis.del(key)操作，并且设定合理的超时时间。
伪代码如下
public void write(String key,Object data){
 redis.delKey(key); 
db.updateData(data); 
Thread.sleep(500);
 redis.delKey(key); }
2.具体的步骤就是：
1）先删除缓存
2）再写数据库
3）休眠500毫秒
4）再次删除缓存
2.方案二:使用消息队列异步更新,把更新的数据先同步到redis,再发送到消息队列mq中,
由mysql数据库自己到mq中读取,以合适的速度也不易导致数据库奔溃.
常见的mq有:kafka,ribbitmq,rocketmq等各有各的特点,但都能满足这个需求.
mq的常见功能:异步,解耦,削峰等可以极大的提高系统的高并发,高可用,高性能.

下面是springboot集成redis的案例:
<!--redis start--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!--redis end-->

redis:
  database: 0
host: 
  port: 6379
password: redis

我选择用RedisTemplate来操作redis

private RedisTemplate<String, Object> redisTemplate;

//=============================common============================

/**
 * 指定缓存失效时间
 *
 * @param key  键
 * @param time 时间(秒)
 * @return {@link Boolean}
 */
@Override
public boolean expire(String key, long time) {
    try {
        if (time > ) {
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 根据key 获取过期时间
 *
 * @param key 键 不能为null
 * @return 时间(秒) 返回0代表为永久有效
 */
@Override
public long getExpire(String key) {
    return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}

/**
 * 判断key是否存在
 *
 * @param key 键
 * @return true 存在 false不存在
 */
@Override
public boolean hasKey(String key) {
    try {
        return redisTemplate.hasKey(key);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 删除缓存
 *
 * @param key 可以传一个值 或多个
 */
@Override
public void del(String... key) {
    if (key != null && key.length > ) {
        if (key.length == ) {
            redisTemplate.delete(key[]);
        } else {
            redisTemplate.delete(CollectionUtil.arrayToList(key));
        }
    }
}

//============================String=============================

/**
 * 普通缓存获取
 *
 * @param key 键
 * @return 值
 */
@Override
public Object get(String key) {
    return key == null ? null : redisTemplate.opsForValue().get(key);
}

/**
 * 普通缓存放入
 *
 * @param key   键
 * @param value 值
 * @return true成功 false失败
 */
@Override
public boolean set(String key, Object value) {
    try {
        redisTemplate.opsForValue().set(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }

}

/**
 * 普通缓存放入并设置时间
 *
 * @param key   键
 * @param value 值
 * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
 * @return true成功 false 失败
 */
@Override
public boolean set(String key, Object value, long time) {
    try {
        if (time > ) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            set(key, value);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 递增
 *
 * @param key   键
 * @param delta 要增加几(大于0)
 * @return
*/
@Override
public long incr(String key, long delta) {
    if (delta < ) {
        throw new RuntimeException("递增因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, delta);
}

/**
 * 递减
 *
 * @param key   键
 * @param delta 要减少几(小于0)
 * @return
*/
@Override
public long decr(String key, long delta) {
    if (delta < ) {
        throw new RuntimeException("递减因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, -delta);
}

//================================Map=================================

/**
 * HashGet
 *
 * @param key  键 不能为null
 * @param item 项 不能为null
 * @return 值
 */
@Override
public Object hget(String key, String item) {
    return redisTemplate.opsForHash().get(key, item);
}

/**
 * 获取hashKey对应的所有键值
 *
 * @param key 键
 * @return 对应的多个键值
 */
@Override
public Map<Object, Object> hmget(String key) {
    return redisTemplate.opsForHash().entries(key);
}

/**
 * HashSet
 *
 * @param key 键
 * @param map 对应多个键值
 * @return true 成功 false 失败
 */
@Override
public boolean hmset(String key, Map<String, Object> map) {
    try {
        redisTemplate.opsForHash().putAll(key, map);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * HashSet 并设置时间
 *
 * @param key  键
 * @param map  对应多个键值
 * @param time 时间(秒)
 * @return true成功 false失败
 */
@Override
public boolean hmset(String key, Map<String, Object> map, long time) {
    try {
        redisTemplate.opsForHash().putAll(key, map);
        if (time > ) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 向一张hash表中放入数据,如果不存在将创建
 *
 * @param key   键
 * @param item  项
 * @param value 值
 * @return true 成功 false失败
 */
@Override
public boolean hset(String key, String item, Object value) {
    try {
        redisTemplate.opsForHash().put(key, item, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 向一张hash表中放入数据,如果不存在将创建
 *
 * @param key   键
 * @param item  项
 * @param value 值
 * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
 * @return true 成功 false失败
 */
@Override
public boolean hset(String key, String item, Object value, long time) {
    try {
        redisTemplate.opsForHash().put(key, item, value);
        if (time > ) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 删除hash表中的值
 *
 * @param key  键 不能为null
 * @param item 项 可以使多个 不能为null
 */
@Override
public void hdel(String key, Object... item) {
    redisTemplate.opsForHash().delete(key, item);
}

/**
 * 判断hash表中是否有该项的值
 *
 * @param key  键 不能为null
 * @param item 项 不能为null
 * @return true 存在 false不存在
 */
@Override
public boolean hHasKey(String key, String item) {
    return redisTemplate.opsForHash().hasKey(key, item);
}

/**
 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
 *
 * @param key  键
 * @param item 项
 * @param by   要增加几(大于0)
 * @return
*/
@Override
public double hincr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, by);
}

/**
 * hash递减
 *
 * @param key  键
 * @param item 项
 * @param by   要减少记(小于0)
 * @return
*/
@Override
public double hdecr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, -by);
}

//============================set=============================

/**
 * 根据key获取Set中的所有值
 *
 * @param key 键
 * @return
*/
@Override
public Set<Object> sGet(String key) {
    try {
        return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

/**
 * 根据value从一个set中查询,是否存在
 *
 * @param key   键
 * @param value 值
 * @return true 存在 false不存在
 */
@Override
public boolean sHasKey(String key, Object value) {
    try {
        return redisTemplate.opsForSet().isMember(key, value);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 将数据放入set缓存
 *
 * @param key    键
 * @param values 值 可以是多个
 * @return 成功个数
 */
@Override
public long sSet(String key, Object... values) {
    try {
        return redisTemplate.opsForSet().add(key, values);
    } catch (Exception e) {
        e.printStackTrace();
        return ;
    }
}

/**
 * 将set数据放入缓存
 *
 * @param key    键
 * @param time   时间(秒)
 * @param values 值 可以是多个
 * @return 成功个数
 */
@Override
public long sSetAndTime(String key, long time, Object... values) {
    try {
        Long count = redisTemplate.opsForSet().add(key, values);
        if (time > ) {
            expire(key, time);
        }
        return count;
    } catch (Exception e) {
        e.printStackTrace();
        return ;
    }
}

/**
 * 获取set缓存的长度
 *
 * @param key 键
 * @return
*/
@Override
public long sGetSetSize(String key) {
    try {
        return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
        e.printStackTrace();
        return ;
    }
}

/**
 * 移除值为value的
 *
 * @param key    键
 * @param values 值 可以是多个
 * @return 移除的个数
 */
@Override
public long setRemove(String key, Object... values) {
    try {
        Long count = redisTemplate.opsForSet().remove(key, values);
        return count;
    } catch (Exception e) {
        e.printStackTrace();
        return ;
    }
}
//===============================list=================================

/**
 * 获取list缓存的内容
 *
 * @param key   键
 * @param start 开始
 * @param end   结束  0 到 -1代表所有值
 * @return
*/
@Override
public List<Object> lGet(String key, long start, long end) {
    try {
        return redisTemplate.opsForList().range(key, start, end);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

/**
 * 获取list缓存的长度
 *
 * @param key 键
 * @return
*/
@Override
public long lGetListSize(String key) {
    try {
        return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
        e.printStackTrace();
        return ;
    }
}

/**
 * 通过索引 获取list中的值
 *
 * @param key   键
 * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
 * @return
*/
@Override
public Object lGetIndex(String key, long index) {
    try {
        return redisTemplate.opsForList().index(key, index);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

/**
 * 将list放入缓存
 *
 * @param key   键
 * @param value 值
 * @return
*/
@Override
public boolean lSet(String key, Object value) {
    try {
        redisTemplate.opsForList().rightPush(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 将list放入缓存
 *
 * @param key   键
 * @param value 值
 * @param time  时间(秒)
 * @return
*/
@Override
public boolean lSet(String key, Object value, long time) {
    try {
        redisTemplate.opsForList().rightPush(key, value);
        if (time > ) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 将list放入缓存
 *
 * @param key   键
 * @param value 值
 * @return
*/
@Override
public boolean lSet(String key, List<Object> value) {
    try {
        redisTemplate.opsForList().rightPushAll(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 将list放入缓存
 *
 * @param key   键
 * @param value 值
 * @param time  时间(秒)
 * @return
*/
@Override
public boolean lSet(String key, List<Object> value, long time) {
    try {
        redisTemplate.opsForList().rightPushAll(key, value);
        if (time > ) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 根据索引修改list中的某条数据
 *
 * @param key   键
 * @param index 索引
 * @param value 值
 * @return
*/
@Override
public boolean lUpdateIndex(String key, long index, Object value) {
    try {
        redisTemplate.opsForList().set(key, index, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 移除N个值为value
 *
 * @param key   键
 * @param count 移除多少个
 * @param value 值
 * @return 移除的个数
 */
@Override
public long lRemove(String key, long count, Object value) {
    try {
        Long remove = redisTemplate.opsForList().remove(key, count, value);
        return remove;
    } catch (Exception e) {
        e.printStackTrace();
        return ;
    }
}
感谢阅读