Redis系列（二）--缓存设计（整表缓存以及排行榜缓存方案实现）

抱歉，其实这篇应该几天前就出的，不过在这个项目中的lucene加载出bug了（虽然还没解决，但缓存的先记录下来，发出给大家）。

本系列：

（1）SSM框架构建积分系统和基本商品检索系统（Spring+SpringMVC+MyBatis+Lucene+Redis+MAVEN）（1）框架整合构建

（2）SSM框架构建积分系统和基本商品检索系统（Spring+SpringMVC+MyBatis+Lucene+Redis+MAVEN）（2）建立商品数据库和Lucene的搭建

（3）Redis系列（一）–安装、helloworld以及读懂配置文件

文章结构：（1）整表缓存；（2）排行榜缓存方案。

Redis文档

一、整表缓存：(演示禁言表的整表缓存)

整表缓存核心思想：我们使用的是普通的key-value数据结构。key对应我们普通的禁言id。value则对应这个id禁言过他人的列表的list。利用jsonarray和list之间的互换。形成这一整表缓存策略！！！

list里面则装载着禁言表的记录，每一行记录对应一个Gag。

（1）先编写好我们的接口

public interface JedisClient {

public String get(String key);
public String set(String key, String value);
public String hget(String hkey, String key);
public long hset(String hkey, String key, String value);
public long incr(String key);
public long expire(String key, int second);
public long ttl(String key);
public long del(String key);
public long hdel(String hkey, String key);
public long zadd(String key,double score,User user);
public Set<String> zgetAll(String key, long start, long end);
//拿整个榜单
public long zaddList(String key,List<User> userList);
//拿去榜单最后一名，比如前50名，这里就拿到第50名的User。积分变化时就拿这个值去判断，大于就丢user进redis，小于则不管
public Set<String> getTopLast(String key,long start,long end);
}

（2）编写业务接口实现类：

@Service
public class JedisClientSingle implements JedisClient {

@Autowired
private JedisPool jedisPool;

@Override
public String get(String key) {
Jedis jedis = jedisPool.getResource();
String string = jedis.get(key);
jedis.close();
return string;
}

@Override
public String set(String key, String value) {
Jedis jedis = jedisPool.getResource();
String string = jedis.set(key, value);
jedis.close();
return string;
}
//最基本的数据类型操作，key-value
@Override
public String hget(String hkey, String key) {
System.out.println("jedisPool   " + jedisPool);
Jedis jedis = jedisPool.getResource();
System.out.println("jedis   " + jedis);
String string = jedis.hget(hkey, key);
jedis.close();
return string;
}

@Override
public long hset(String hkey, String key, String value) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.hset(hkey, key, value);
jedis.close();
return result;
}

@Override
public long incr(String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.incr(key);
jedis.close();
return result;
}

@Override
public long expire(String key, int second) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.expire(key, second);
jedis.close();
return result;
}

@Override
public long ttl(String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.ttl(key);
jedis.close();
return result;
}

@Override
public long del(String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.del(key);
jedis.close();
return result;
}

@Override
public long hdel(String hkey, String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.hdel(hkey, key);
jedis.close();
return result;
}
@Override
public long zaddList(String key,List<User> userList){
Jedis jedis = jedisPool.getResource();
Long result = null;
for (int i=0;i<userList.size();i++){
result = jedis.zadd(key, userList.get(i).getScore(), JsonUtils.objectToJson(userList.get(i)));
}
jedis.close();
return result;
}

@Override
public long zadd(String key,double score,User user){
Jedis jedis = jedisPool.getResource();
Long result = jedis.zadd(key, score, JsonUtils.objectToJson(user));
jedis.close();
return result;
}
@Override
public Set<String> zgetAll(String key,long start,long end){
Jedis jedis = jedisPool.getResource();
Set<String> userSet =jedis.zrange(key, start, end);
System.out.println("userSet    :"+userSet);
jedis.close();
return userSet;
}
//拿最后一名的，所以start跟end必须标记最后一名的位置索引
@Override
public Set<String> getTopLast(String key,long start,long end) {
Jedis jedis = jedisPool.getResource();
Set<String> userSet = jedis.zrange(key,start,end);
System.out.println("userSet    :"+userSet);
jedis.close();
return userSet;
}

}

（3）我们写进缓存的string和读出来的string必须使用统一的转换方式：我这里使用的是fastjson这个库

public class JsonUtils {
//转成jsonarray
public static String objectToJson(Object data) {
String json = JSONArray.toJSONString(data);
return json;
}
//string转java对象
public static User jsonObjectToUser(String userString) {
User user = JSONObject.parseObject(userString.toString(),User.class);
return user;
}
public static List<User> objectToUser(JSONArray array){
List<User> userList =new ArrayList<>();
for (int i=0;i<array.size();i++) {
System.out.print("array.get(i)    "+array.get(i).toString());
//parseObject解析的是一个字符串，强转成为String是不行的，必须打印成String语句
User user = JSONObject.parseObject(array.get(i).toString(),User.class);
userList.add(user);
}
return userList;
}
}

（4）整表缓存的controller调用：

@RestController
@RequestMapping("/gag")
public class GagController {
@Autowired
private GagService gagService;
@Autowired
private JedisClient jedisClient;

@RequestMapping(value = "/gagList",produces="text/html;charset=UTF-8", method = {RequestMethod.GET,RequestMethod.GET})
public String testRedis(Long id){
List<Gag> gagList= null;
try {
String resulthget = jedisClient.hget("禁言表", id + "");
if (resulthget != null) {
//字符串转为list
System.out.println("有缓存啦啦啦！！！");
JSONArray array = JSONArray.parseArray(resulthget);
gagList = (List) array;
} else {
System.out.println("禁言表没查过");//没有查过就读取整个表的list出来
gagList= gagService.findByUserId(id);
}
} catch (Exception e) {
e.printStackTrace();
}
try {
String cacheString = JsonUtils.objectToJson(gagList);//读取出来后就加载缓存进去，但是要转化给json
jedisClient.hset("禁言表", id + "", cacheString);
} catch (Exception e) {
e.printStackTrace();
}
return JSON.toJSONString(gagList);
}
}

二、排行榜缓存方案（重头戏！！！）

方案一：（优雅方案）：

1.第一次访问的时候，查数据库，查整个user表查出topN（使用sql排序），丢给redis(使用sorted set数据类型)。

2.排序在redis，redis自动排序。以后的用户访问：均访问redis。

3.只要每次积分变化判断的时候拿topN的最后一个判别，大于某个阈值则整个user丢进redis排序。

4.积分变换的时候都往redis拿个第50名的积分进行判断。再往下去设定一个小距离为阈值。比如现在第50名的积分是100，那80分一下的应该就没必要扔给redis了吧？

注意：这个排行榜的用户是会不断增加的，比如1亿用户，如果刚开始只有前50，后5千万人的积分大于第50名，那么就会往redis加入这个用户的信息。（虽然看起来要存很多，其实一亿用户怎么存也就1G左右的内存，简单暴力优雅方案了）

实现：

（1）继续沿用JedisClient接口

//拿整个榜单
public Set<String> zgetAll(String key, long start, long end);
//批量加入用户
public long zaddList(String key,List<User> userList);
//拿去榜单最后一名，比如前50名，这里就拿到第50名的User。积分变化时就拿这个值去判断，大于就丢user进redis，小于则不管
public Set<String> getTopLast(String key,long start,long end);

（2）继续沿用JedisClientSingle实现类

//批量加入用户到redis
@Override
public long zaddList(String key,List<User> userList){
Jedis jedis = jedisPool.getResource();
Long result = null;
for (int i=0;i<userList.size();i++){
result = jedis.zadd(key, userList.get(i).getScore(), JsonUtils.objectToJson(userList.get(i)));
}
jedis.close();
return result;
}
//单个用户加入。而且可用于更新操作！！！！
@Override
public long zadd(String key,double score,User user){
Jedis jedis = jedisPool.getResource();
Long result = jedis.zadd(key, score, JsonUtils.objectToJson(user));
jedis.close();
return result;
}
//全拿榜单信息（拿多少就多少。）
@Override
public Set<String> zgetAll(String key,long start,long end){
Jedis jedis = jedisPool.getResource();
Set<String> userSet =jedis.zrange(key, start, end);
System.out.println("userSet    :"+userSet);
jedis.close();
return userSet;
}
//拿最后一名的，所以start跟end必须标记最后一名的位置索引
@Override
public Set<String> getTopLast(String key,long start,long end) {
Jedis jedis = jedisPool.getResource();
Set<String> userSet = jedis.zrange(key,start,end);
System.out.println("userSet    :"+userSet);
jedis.close();
return userSet;
}

（3）缓存加入，查询调用：（继续沿用上面的JsonUtils）

@RequestMapping(value = "/queryTopN", produces = "text/html;charset=UTF-8", method = {RequestMethod.GET, RequestMethod.GET})
public String queryTopN() {
List<User> userList = null;
try {
//拿出redis的排行榜结果
Set<String> resultSet = jedisClient.zgetAll("Toptest", (long) 0, (long) 20);
System.out.println("resultSet    " + resultSet.toString());
Iterator<String> iter = resultSet.iterator();//遍历它
if (resultSet.size() > 0) {
//字符串转为list
System.out.println("有缓存啦啦啦！！！");
userList = new ArrayList<>();
while (iter.hasNext()) {
//把一个个对象用fastjson格式转换成jsonobject
User user = JsonUtils.jsonObjectToUser(iter.next());
System.out.println("user   " + user.toString());
userList.add(user);
}
return JSON.toJSONString(userList);
} else {
System.out.println("Toptest没查过");
userList = userService.queryTopN();//没查过就查一次再丢给redis
}
} catch (Exception e) {
e.printStackTrace();
}
try {
//如果没有缓存就批量加入到redis缓存中
jedisClient.zaddList("Toptest", userList);
} catch (Exception e) {
e.printStackTrace();
}

return JSON.toJSONString(userList);
}

（4）我们缓存策略核心：修改了用户积分的时候就与缓存排行榜的我们限定的最后一名进行比较，大于就丢进redis排序，小于就不丢进去。所以只有第一次访问的时候是使用了数据库的sql排序查询。

@RequestMapping(value = "/updateScore", produces = "text/html;charset=UTF-8", method = {RequestMethod.GET, RequestMethod.GET})
public String updateScore(Long id,Integer scoreCount) {
User user = userService.queryById(id);
scoreService.updateScore(user,scoreCount);
return JSON.toJSONString(user);
}

注意的是：因为每个user序列化原因，每个user都有独特的标记，所以我们要从redis中拿user去判断，而不是新建一个user。这样的hash是不一样的！！！

@Transactional
@Override
public void updateScore(User user, int scoreCount) {
User userFind = new User();
Score score = new Score();
score.setChangeType("做任务");
score.setScore(scoreCount);
score.setUser(user);
scoreDao.insertScore(score);
userDao.updateScore(user.getId(), scoreCount);
//从redis拿出排行榜的list先
Set<String> userSet = jedisClient.getTopLast("Toptest", (long) 0, (long) 5);
Iterator<String> iter = userSet.iterator();//遍历 它，判断这个用户存不存在了
List<User> userList = new ArrayList<>();
while (iter.hasNext()) {
User userTemp = JsonUtils.jsonObjectToUser(iter.next());
System.out.println("user   " + user.toString());
userList.add(userTemp);
if (userTemp.getAccount().equals(user.getAccount())) {//如果存在就用存在的
userFind = userTemp;
}
}
//如果原本有的就修改原有的。
if (userFind != null) {
jedisClient.zadd("Toptest", (double) user.getScore(), userFind);
return;
}
//如果没有就加进去嘛，根据排行榜来区分
if (userList.size() >= 20) {
if (user.getScore() + scoreCount > userList.get(19).getScore()) {
System.out.println("大于排名20名中的最后一名就丢进缓存    :");
System.out.println("userList    :" + userList.toString());
}
} else {
System.out.println("排行榜小于20人就直接丢进缓存    :");
if (userFind != null) {
jedisClient.zadd("Toptest", (double) user.getScore(), user);
}
System.out.println("user   " + userFind);
}
}

就这样就完成我们的排行榜缓存策略了！！！

方案二：

只描述：（因为这个方案不是特别优雅，而且第一个方案已经基于第二方案进行改进了！！）

（1）用户访问排行榜接口，后台第一次是先查数据库，然后set进redis（sorted set或者普通key-value）。

（2）以后：只会访问redis。

（3）设置个定时器定时让redis去读取数据库topN。（排序在数据库）

ORDERBY 积分 DESC LIMIT 50

排行榜前50名，这样的条件

源码下载：Redis系列（二）–缓存设计（整表缓存以及排行榜缓存方案实现）Demo

好了，J2EE项目系列（四）–Redis系列（二）–缓存设计（整表缓存以及排行榜缓存方案实现）讲完了。本博客系列是我做其中一个项目时候需要整合的部分东西（分布式的往后补上），我把里面的整合，以及部分非算法性的业务逻辑写出来（大家别看这边博客这么少东西，其实就那个数据库搞了我几个钟，缓存方案更是我搞了几天的东东），分享经验给大家。欢迎在下面指出错误，共同学习！！你的点赞是对我最好的支持！！

更多内容，可以访问JackFrost的博客