Redis应用—9.简单应用汇总

大纲

1.基于Redis实现的简单缓存机制(String数据结构)

2.实现一个最简单的分布式锁(String数据结构)

3.博客网站的文章发布与查看(String数据结构)

4.博客字数统计与文章预览(String数据结构)

5.用户操作日志审计功能(String数据结构)

6.实现一个简单的唯一ID生成器(incr命令)

7.实现博客点赞次数计数器(incr命令 + decr命令)

8.社交网站的网址点击追踪机制(长网址转短网址)(Hash数据结构)

9.基于Hash实现博客基本功能(Hash数据结构)

10.基于令牌的用户登录会话机制(Hash数据结构)

11.秒杀活动下的公平队列抢购机制(List数据结构)

12.基于List实现博客的分页浏览(List数据结构)

13.实现OA系统中的待办事项管理(List数据结构)

14.网站用户注册时的邮件验证机制(List数据结构)

15.网站每日UV数据指标去重统计(Set数据结构)

16.博客网站的文章标签管理(Set数据结构)

17.朋友圈点赞功能的实现(Set数据结构)

18.实现一个网站投票统计程序(Set数据结构)

19.实现微博的社交关系(Set数据结构)

20.实现网站上的抽奖程序(Set数据结构)

21.为商品搜索构建反向索引(Set数据结构)

22.实现音乐网站的排行榜(Sorted Set数据结构)

23.实现获取指定时间的新闻(Sorted Set数据结构)

24.实现购买某商品时也会购买其他商品的推荐功能(Sorted Set数据结构)

25.实现搜索框的自动补全(Sorted Set数据结构)

26.基于HyperLogLog的网站UV统计程序(HyperLogLog数据结构)

27.网站重复垃圾数据的快速去重和过滤(HyperLogLog数据结构)

28.周活月活年活的统计(HyperLogLog数据结构)

29.基于位图的用户行为记录(BitMap数据结构)

30.基于Geo的距离计算程序(Geo数据结构)

31.陌生人社交里的查找附近的人(Geo数据结构)

32.带有自动过期时间的分布式缓存(expire命令)

33.支持超时自动释放的简单分布式锁(expire命令)

34.支持自动过期的用户登录会话实现(expire命令)

35.支持冷数据自动淘汰的自动补全(expire命令)

36.支持身份验证的分布式锁释放(pipeline命令)

 

1.基于Redis实现的简单缓存机制(String数据结构)

Redis里存放了大量的key-value对，可以先通过"set key value"命令往Redis里存放一些数据，然后再通过"get key"命令从Redis里获取这些数据。

 

基于Redis的缓存机制可以实现高并发和高性能。比如可以把复杂查询后的结果放入Redis里作为缓存，下次查询时就直接从Redis缓存里取出，无需再到数据库中查询复杂SQL。比如可以将HTML页面存放在Redis缓存里，下次查询时就直接从Redis缓存里获取，无需先基于JSP动态渲染页面，再从磁盘上读取出来返回给浏览器。

public class JedisTest {     public static void main(String[] args) throws Exception {         Jedis jedis = new Jedis("127.0.0.1");              //最简单的缓存读写示例         jedis.set("key1", "value1");         System.out.println(jedis.get("key1"));     } }

 

2.实现一个最简单的分布式锁(String数据结构)

通过Redis的"set key value nx"命令可实现一个最简单的分布式锁。

 

当key不存在时，才能设置成功，返回true。当key存在时，会设置失败，返回false。

public class JedisTest {     public static void main(String[] args) throws Exception {         Jedis jedis = new Jedis("127.0.0.1");              //最简单的基于nx选项实现的分布式锁         jedis.del("lock_test");              String result = jedis.set("lock_test", "value_test", SetParams.setParams().nx());         System.out.println("第一次加锁的结果：" + result);              result = jedis.set("lock_test", "value_test", SetParams.setParams().nx());         System.out.println("第二次加锁的结果：" + result);              jedis.del("lock_test");              result = jedis.set("lock_test", "value_test", SetParams.setParams().nx());         System.out.println("第二次加锁的结果：" + result);     } }

 

3.博客网站的文章发布与查看(String数据结构)

Redis有mset、mget、msetnx等命令。其中mset可一次性设置多个key-value对，mget可获取多个key的value，msetnx就是在多个key都不存在的情况下一次性设置多个key的value。mset和mget，相当于batch批量设置和查询，可节省网络通讯时间。

public class JedisTest {     public static void main(String[] args) throws Exception {         Jedis jedis = new Jedis("127.0.0.1");                   //博客的发布、修改与查看         Long publishBlogResult = jedis.msetnx(             "article:1:title", "学习Redis",             "article:1:content", "如何学好Redis的使用",             "article:1:author", "Test",             "article:1:time", "2020-01-01 00:00:00"         );         System.out.println("发布博客的结果：" + publishBlogResult);              List<String> blog = jedis.mget(             "article:1:title",              "article:1:content",             "article:1:author",              "article:1:time"         );         System.out.println("查看博客：" + blog);              String updateBlogResult = jedis.mset(             "article:1:title", "修改后的学习redis",             "article:1:content", "修改后的如何学好redis的使用"         );         System.out.println("修改博客的结果：" + updateBlogResult);              blog = jedis.mget(             "article:1:title",              "article:1:content",             "article:1:author",              "article:1:time"         );         System.out.println("再次查看博客：" + blog);     } }

 

4.博客字数统计与文章预览(String数据结构)

使用Redis的strlen命令可以统计value值的字数，getrange命令可以截取value值的内容。

public class JedisTest {     public static void main(String[] args) throws Exception {         Jedis jedis = new Jedis("127.0.0.1");         Long blogLength = jedis.strlen("article:1:content");         System.out.println("博客的长度统计：" + blogLength);              String blogContentPreview = jedis.getrange("article:1:content", 0, 5);         System.out.println("博客内容预览：" + blogContentPreview);     } }

 

5.用户操作日志审计功能(String数据结构)

使用Redis的append命令可以向value值追加内容，比如需要记录用户每天的核心操作日志，就可以使用Redis的append命令。

public class JedisTest {     public static void main(String[] args) throws Exception {         Jedis jedis = new Jedis("127.0.0.1");                   //操作日志的审计功能         jedis.del("operation_log_2020_01_01");         jedis.setnx("operation_log_2020_01_01", "");         for (int i = 0; i < 10; i++) {             jedis.append("operation_log_2020_01_01", "今天的第" + (i + 1) + "条操作日志n");         }              String operationLog = jedis.get("operation_log_2020_01_01");         System.out.println("今天所有的操作日志：n" + operationLog);     } }

 

6.实现一个简单的唯一ID生成器(incr命令)

在单库单表中，唯一ID可以通过自增主键来生成。在分库分表中，唯一ID可以通过SnowFlake来生成。当然，Redis的incr命令也可以生成唯一ID。

public class JedisTest {     public static void main(String[] args) throws Exception {         Jedis jedis = new Jedis("127.0.0.1");                   //唯一ID生成器         jedis.del("order_id_counter");         for (int i = 0; i < 10; i++) {             Long orderId = jedis.incr("order_id_counter");             System.out.println("生成的第" + (i + 1) + "个唯一ID：" + orderId);         }     } }

 

7.实现博客点赞次数计数器(incr命令 + decr命令)

使用Redis的incr命令和decr命令可维护点赞次数。

public class JedisTest {     public static void main(String[] args) throws Exception {         Jedis jedis = new Jedis("127.0.0.1");                   //博客的点赞计数器         jedis.del("article:1:dianzan");         for (int i = 0; i < 10; i++) {             jedis.incr("article:1:dianzan");         }         Long dianzanCounter = Long.valueOf(jedis.get("article:1:dianzan"));         System.out.println("博客的点赞次数为：" + dianzanCounter);            jedis.decr("article:1:dianzan");         dianzanCounter = Long.valueOf(jedis.get("article:1:dianzan"));         System.out.println("再次查看博客的点赞次数为：" + dianzanCounter);     } }

 

8.社交网站的网址点击追踪机制(长网址转短网址)(Hash数据结构)

Redis的Hash数据结构可以实现网址点击追踪机制。需要对某个原地址进行追踪时：首先通过Redis的incr命令获取一个自增的10进制数。然后将10进制数转换为36进制数，并将转换后的36进制数作为短网址。接着通过hset命令设置短网址的点击次数为0，以及通过hset命令设置短网址和原地址的映射关系。当有用户访问该短网址时，就可以通过hincrBy命令对点击次数进行自增。

//短网址追踪案例 public class ShortUrlDemo {     private static final String[] X36_ARRAY = "0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z".split(",");     private Jedis jedis = new Jedis("127.0.0.1");          public ShortUrlDemo() {         jedis.set("short_url_seed", "51167890045");     }      //获取短网址     public String getShortUrl(String url) {         //通过Redis的incr命令获取一个自增的10进制数         long shortUrlSeed = jedis.incr("short_url_seed");            //将10进制数转换为36进制数，并将转换后的36进制数作为短网址         StringBuffer buffer = new StringBuffer();         while (shortUrlSeed > 0) {             buffer.append(X36_ARRAY[(int)(shortUrlSeed % 36)]);             shortUrlSeed = shortUrlSeed / 36;         }         String shortUrl = buffer.reverse().toString();            jedis.hset("short_url_access_count", shortUrl, "0");         jedis.hset("url_mapping", shortUrl, url);         return shortUrl;     }      //增加短网址的访问次数     public void incrementShortUrlAccessCount(String shortUrl) {         jedis.hincrBy("short_url_access_count", shortUrl, 1);     }      //获取短网址的访问次数     public long getShortUrlAccessCount(String shortUrl) {         return Long.valueOf(jedis.hget("short_url_access_count", shortUrl));     }      public static void main(String[] args) throws Exception {         ShortUrlDemo shortUrlDemo = new ShortUrlDemo();         String shortUrl = shortUrlDemo.getShortUrl("http://redis.com/index.html");         System.out.println("页面上展示的短网址为：" + shortUrl);         //假设访问152次         for (int i = 0; i < 152; i++) {             shortUrlDemo.incrementShortUrlAccessCount(shortUrl);         }         long accessCount = shortUrlDemo.getShortUrlAccessCount(shortUrl);         System.out.println("短网址被访问的次数为：" + accessCount);     } }

 

9.基于Hash实现博客基本功能(Hash数据结构)

Java对象特别适合使用Hash数据结构来存放到Redis中。如果先将Java对象序列化成字符串，再以字符串形式存放到Redis里，那么在Redis中操作Java对象就不太方便了。其中使用Redis的命令有：hexists、hset、hgetAll、hincrBy。

//博客网站案例 public class BlogDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //获取博客id     public long getBlogId() {         return jedis.incr("blog_id_counter");     }      //发表一篇博客     public boolean publishBlog(long id, Map<String, String> blog) {         if (jedis.hexists("article::" + id, "title")) {             return false;         }         blog.put("content_length", String.valueOf(blog.get("content").length()));         jedis.hset("article::" + id, blog);         return true;     }      //查看一篇博客     public Map<String, String> findBlogById(long id) {         Map<String, String> blog = jedis.hgetAll("article::" + id);         incrementBlogViewCount(id);         return blog;     }      //更新一篇博客     public void updateBlog(long id, Map<String, String> updatedBlog) {         String updatedContent = updatedBlog.get("content");         if (updatedContent != null && !"".equals(updatedContent)) {             updatedBlog.put("content_length", String.valueOf(updatedContent.length()));         }         jedis.hset("article::" + id, updatedBlog);     }      //对博客进行点赞     public void incrementBlogLikeCount(long id) {         jedis.hincrBy("article::" + id, "like_count", 1);     }      //增加博客浏览次数     public void incrementBlogViewCount(long id) {         jedis.hincrBy("article::" + id, "view_count", 1);     }      public static void main(String[] args) {         BlogDemo demo = new BlogDemo();         //发表一篇博客         long id = demo.getBlogId();            Map<String, String> blog = new HashMap<String, String>();         blog.put("id", String.valueOf(id));         blog.put("title", "我喜欢学习Redis");         blog.put("content", "学习Redis是一件特别快乐的事情");         blog.put("author", "test");         blog.put("time", "2020-01-01 10:00:00");         demo.publishBlog(id, blog);            //更新一篇博客         Map<String, String> updatedBlog = new HashMap<String, String>();         updatedBlog.put("title", "我特别喜欢学习Redis");         updatedBlog.put("content", "我平时喜欢到官方网站上去学习Redis");         demo.updateBlog(id, updatedBlog);            //其他用户点击查看博客的详细内容，并进行点赞         Map<String, String> blogResult = demo.findBlogById(id);         System.out.println("查看博客的详细内容：" + blogResult);         demo.incrementBlogLikeCount(id);            //查看博客的浏览次数和点赞次数         blogResult = demo.findBlogById(id);         System.out.println("查看博客的详细内容：" + blogResult);     } }

 

10.基于令牌的用户登录会话机制(Hash数据结构)

用户中心在处理用户请求时，会先检查请求是否有令牌及令牌是否合法，此时可以使用Redis的hset和hget命令来实现令牌对应的session检查。

//用户会话管理案例 public class SessionDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //检查session是否有效     public boolean isSessionValid(String token) throws Exception {         //校验token是否为空         if (token == null || "".equals(token)) {             return false;         }            //假设session是一个value为user_id的json字符串         String session = jedis.hget("sessions", "session::" + token);         if (session == null || "".equals(session)) {             return false;         }            //检查这个session是否在有效期内         String expireTime = jedis.hget("sessions::expire_time", "session::" + token);         if (expireTime == null || "".equals(expireTime)) {             return false;         }            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");         Date expireTimeDate = dateFormat.parse(expireTime);         Date now = new Date();         if (now.after(expireTimeDate)) {             return false;         }            //如果token不为空，且获取到的session不为空，而且session没过期，则认为session在有效期内         return true;     }      //模拟的登录方法     public String login(String username, String password) {         //基于用户名和密码去登录         System.out.println("基于用户名和密码登录：" + username + ", " + password);         Random random = new Random();         long userId = random.nextInt() * 100;         //登录成功后，生成一块令牌         String token = UUID.randomUUID().toString().replace("-", "");         //基于令牌和用户id去初始化用户的session         initSession(userId, token);         //返回这个令牌给用户         return token;     }      //用户登录成功之后，初始化一个session     public void initSession(long userId, String token) {         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");            Calendar calendar = Calendar.getInstance();         calendar.setTime(new Date());         calendar.add(Calendar.HOUR, 24);         Date expireTime = calendar.getTime();            //通过hset来设置session         jedis.hset("sessions", "session::" + token, String.valueOf(userId));         jedis.hset("sessions::expire_time", "session::" + token, dateFormat.format(expireTime));     }      public static void main(String[] args) throws Exception {         SessionDemo demo = new SessionDemo();            //第一次访问系统，token都是空的         boolean isSessionValid = demo.isSessionValid(null);         System.out.println("第一次访问系统的session校验结果：" + (isSessionValid == true ? "通过" : "不通过"));            //强制性进行登录，获取到token         String token = demo.login("test","123456");         System.out.println("登录过后拿到令牌：" + token);            //第二次再次访问系统，此时是可以访问的         isSessionValid = demo.isSessionValid(token);         System.out.println("第二次访问系统的session校验结果：" + (isSessionValid == true ? "通过" : "不通过"));     } }

 

11.秒杀活动下的公平队列抢购机制(List数据结构)

秒杀系统有很多实现方案，其中一种方案就是公平队列方案。对所有涌入系统的秒杀抢购请求，都放入Redis的一个List数据结构里排队，然后请求入队后就让请求等待秒杀结果。接着通过一个消费者从List中按顺序获取抢购请求，按顺序进行库存扣减。扣减成功才响应请求抢购成功，可以通过Redis的rpush和lpop命令实现一个公平队列。

//秒杀活动案例 public class SecKillDemo {     private Jedis jedis = new Jedis("127.0.0.1");          //秒杀抢购请求入队     public void enqueueSecKillRequest(String secKillRequest) {         jedis.rpush("sec_kill_request_queue", secKillRequest);     }          //秒杀抢购请求出队     public String dequeueSecKillRequest() {         return jedis.lpop("sec_kill_request_queue");     }          public static void main(String[] args) throws Exception {         SecKillDemo demo = new SecKillDemo();         for (int i = 0; i < 10; i++) {             demo.enqueueSecKillRequest("第" + (i + 1) + "个秒杀请求");         }         while (true) {             String secKillRequest = demo.dequeueSecKillRequest();             if (secKillRequest == null || "null".equals(secKillRequest) || "".equals(secKillRequest)) {                 break;             }             System.out.println(secKillRequest);         }     } }

 

12.基于List实现博客的分页浏览(List数据结构)

发表博客时就把博客数据lpush到一个List里，分页查询时就通过"lrange list start_index end_index"命令查询某一页的数据，获取所有数据量时就通过"llen list"命令来获取。

//博客网站案例 public class BlogDemo {     private Jedis jedis = new Jedis("127.0.0.1");          //获取博客id     public long getBlogId() {         return jedis.incr("blog_id_counter");     }      //发表一篇博客     public boolean publishBlog(long id, Map<String, String> blog) {         if (jedis.hexists("article::" + id, "title")) {             return false;         }         blog.put("content_length", String.valueOf(blog.get("content").length()));         jedis.hset("article::" + id, blog);         jedis.lpush("blog_list", String.valueOf(id));         return true;     }      //查看一篇博客     public Map<String, String> findBlogById(long id) {         Map<String, String> blog = jedis.hgetAll("article::" + id);         incrementBlogViewCount(id);         return blog;     }      //更新一篇博客     public void updateBlog(long id, Map<String, String> updatedBlog) {         String updatedContent = updatedBlog.get("content");         if (updatedContent != null && !"".equals(updatedContent)) {             updatedBlog.put("content_length", String.valueOf(updatedContent.length()));         }         jedis.hset("article::" + id, updatedBlog);     }      //对博客进行点赞     public void incrementBlogLikeCount(long id) {         jedis.hincrBy("article::" + id, "like_count", 1);     }      //增加博客浏览次数     public void incrementBlogViewCount(long id) {         jedis.hincrBy("article::" + id, "view_count", 1);     }      //分页查询博客     public List<String> findBlogByPage(int pageNo, int pageSize) {         int startIndex = (pageNo - 1) * pageSize;         int endIndex = pageNo * pageSize - 1;         return jedis.lrange("blog_list", startIndex, endIndex);     }      public static void main(String[] args) {         BlogDemo demo = new BlogDemo();         //发表一篇博客         long id = demo.getBlogId();         Map<String, String> blog = new HashMap<String, String>();         blog.put("id", String.valueOf(id));         blog.put("title", "我喜欢学习Redis");         blog.put("content", "学习Redis是一件特别快乐的事情");         blog.put("author", "test");         blog.put("time", "2020-01-01 10:00:00");         demo.publishBlog(id, blog);         //更新一篇博客         Map<String, String> updatedBlog = new HashMap<String, String>();         updatedBlog.put("title", "我特别的喜欢学习Redis");         updatedBlog.put("content", "我平时喜欢到官方网站上去学习Redis");         demo.updateBlog(id, updatedBlog);         //构造20篇博客数据         for (int i = 0; i < 20; i++) {             id = demo.getBlogId();             blog = new HashMap<String, String>();             blog.put("id", String.valueOf(id));             blog.put("title", "第" + (i + 1) + "篇博客");             blog.put("content", "学习第" + (i + 1) + "篇博客，是一件很有意思的事情");             blog.put("author", "test");             blog.put("time", "2020-01-01 10:00:00");             demo.publishBlog(id, blog);         }         //分页浏览所有的博客，先浏览第一页         int pageNo = 1;         int pageSize = 10;         List<String> blogPage = demo.findBlogByPage(pageNo, pageSize);         System.out.println("展示第一页的博客......");         for (String blogId : blogPage) {             blog = demo.findBlogById(Long.valueOf(blogId));             System.out.println(blog);         }         pageNo = 2;         blogPage = demo.findBlogByPage(pageNo, pageSize);         System.out.println("展示第二页的博客......");         for (String blogId : blogPage) {             blog = demo.findBlogById(Long.valueOf(blogId));             System.out.println(blog);         }         //点击查看博客的详细内容，并进行点赞         Random random = new Random();         int blogIndex = random.nextInt(blogPage.size());         String blogId = blogPage.get(blogIndex);         Map<String, String> blogResult = demo.findBlogById(Long.valueOf(blogId));         System.out.println("查看博客的详细内容：" + blogResult);         demo.incrementBlogLikeCount(Long.valueOf(blogId));         //查看博客的浏览次数和点赞次数         blogResult = demo.findBlogById(Long.valueOf(blogId));         System.out.println("查看博客的详细内容：" + blogResult);     } }

 

13.实现OA系统中的待办事项管理(List数据结构)

使用Redis的lindex、lset、linsert、lrange、lrem可实现待办事项管理。

 

新增待办事项：lpush list event

插入待办事项：linsert list index event

查询待办事项列表：lrange list 0 -1

完成待办事项：lrem list 0 event

添加已办事项：lpush done_list event

修改待办事项：lindex和lset

查询已办事项列表：lrange done_list 0 -01

//OA系统的待办事项的管理案例 public class TodoEventDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //添加待办事项     public void addTodoEvent(long userId, String todoEvent) {         jedis.lpush("todo_event::" + userId, todoEvent);     }      //分页查询待办事项列表     public List<String> findTodoEventByPage(long userId, int pageNo, int pageSize) {         int startIndex = (pageNo - 1) * pageSize;         int endIndex = pageNo * pageSize - 1;         return jedis.lrange("todo_event::" + userId, startIndex, endIndex);     }      //插入待办事项     public void insertTodoEvent(long userId, ListPosition position, String targetTodoEvent, String todoEvent) {         jedis.linsert("todo_event::" + userId, position, targetTodoEvent, todoEvent);     }      //修改一个待办事项     public void updateTodoEvent(long userId, int index, String updatedTodoEvent) {         jedis.lset("todo_event::" + userId, index, updatedTodoEvent);     }      //完成(移除)一个待办事项     public void finishTodoEvent(long userId, String todoEvent) {         jedis.lrem("todo_event::" + userId, 0, todoEvent);     }      public static void main(String[] args) throws Exception {         TodoEventDemo demo = new TodoEventDemo();            //添加20个待办事项         long userId = 2;         for (int i = 0; i < 20; i++) {             demo.addTodoEvent(userId, "第" + (i + 1) + "个待办事项");         }            //查询第一页待办事项         int pageNo = 1;         int pageSize = 10;         List<String> todoEventPage = demo.findTodoEventByPage(userId, pageNo, pageSize);         System.out.println("第一次查询第一页待办事项......");         for (String todoEvent :todoEventPage) {             System.out.println(todoEvent);         }            //插入一个待办事项         Random random = new Random();         int index = random.nextInt(todoEventPage.size());         String targetTodoEvent = todoEventPage.get(index);         demo.insertTodoEvent(userId, ListPosition.BEFORE, targetTodoEvent, "插入的待办事项");         System.out.println("在" + targetTodoEvent + "前面插入了一个待办事项");            //重新分页查询第一页待办事项         todoEventPage = demo.findTodoEventByPage(userId, pageNo, pageSize);         System.out.println("第二次查询第一页待办事项......");         for (String todoEvent :todoEventPage) {             System.out.println(todoEvent);         }            //修改一个待办事项         index = random.nextInt(todoEventPage.size());         demo.updateTodoEvent(userId, index, "修改后的待办事项");            //完成一个待办事项         demo.finishTodoEvent(userId, todoEventPage.get(0));            //最后查询一次待办事项         todoEventPage = demo.findTodoEventByPage(userId, pageNo, pageSize);            System.out.println("第三次查询第一页待办事项......");         for (String todoEvent :todoEventPage) {             System.out.println(todoEvent);         }     } }

 

14.网站用户注册时的邮件验证机制(List数据结构)

用户注册时使用Redis的lpush命令将发送邮件任务放入List，发送邮件时就用Redis的brpop命令阻塞式地从List队列里获取任务。

//注册之后发送邮件的案例 public class SendMailDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //将发送邮件的任务进入队列     public void enqueueSendMailTask(String sendMailTask) {         jedis.lpush("send_mail_task_queue", sendMailTask);     }      //阻塞式获取发送邮件任务     //即从List中获取不到元素会阻塞5秒     public List<String> takeSendMailTask() {         return jedis.brpop(5, "send_mail_task_queue");     }      public static void main(String[] args) {         SendMailDemo demo = new SendMailDemo();            System.out.println("尝试阻塞式地获取发送邮件任务......");         //此时队列中没有任务，会进行阻塞         List<String> sendMailTasks = demo.takeSendMailTask();            demo.enqueueSendMailTask("第一个邮件发送任务");         sendMailTasks = demo.takeSendMailTask();         System.out.println(sendMailTasks);     } }

 

15.网站每日UV数据指标去重统计(Set数据结构)

每日UV就是每日的独立访客，可以使用Redis的Set数据结构来实现，具体可以使用Redis的sadd命令添加访客和scard命令统计访客。

//网站UV统计案例 public class UVDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //添加一次用户访问记录     public void addUserAccess(long userId) {         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");         String today = dateFormat.format(new Date());         jedis.sadd("user_access::" + today, String.valueOf(userId));     }      //获取当天的网站uv的值     public long getUV() {         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");         String today = dateFormat.format(new Date());         return jedis.scard("user_access::" + today);     }      public static void main(String[] args) throws Exception {         UVDemo demo = new UVDemo();         for (int i = 0; i < 100; i++) {             long userId = i + 1;             for (int j = 0; j < 10; j++) {                 demo.addUserAccess(userId);             }         }         long uv = demo.getUV();         System.out.println("当日uv为：" + uv);     } }

 

16.博客网站的文章标签管理(Set数据结构)

使用Redis的sadd和smembers命令可管理标签。

//博客网站案例 public class BlogDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //获取博客id     public long getBlogId() {         return jedis.incr("blog_id_counter");     }      //发表一篇博客     public boolean publishBlog(long id, Map<String, String> blog, String[] tags) {         if (jedis.hexists("article::" + id, "title")) {             return false;         }         blog.put("content_length", String.valueOf(blog.get("content").length()));         jedis.hmset("article::" + id, blog);         jedis.lpush("blog_list", String.valueOf(id));         jedis.sadd("article::" + id + "::tags", tags);         return true;     }      //查看一篇博客     public Map<String, String> findBlogById(long id) {         Map<String, String> blog = jedis.hgetAll("article::" + id);         Set<String> tags = jedis.smembers("article::" + id + "::tags");         blog.put("tags", tags.toString());         incrementBlogViewCount(id);         return blog;     }     ... }

 

17.朋友圈点赞功能的实现(Set数据结构)

用户对某条朋友圈进行点赞，可以使用sadd命令。用户对某条朋友圈取消点赞，可以使用srem命令。查看某个用户是否对某条朋友圈进行过点赞，可以使用sismember命令。查看某条朋友圈具体被哪些人点赞，可以使用smembers命令。查看某条朋友圈的点赞次数，可以使用scard命令。

//朋友圈点赞案例 public class MomentsDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //对某条朋友圈进行点赞     public void likeMoment(long userId, long momentId) {         jedis.sadd("moment_like_users::" + momentId, String.valueOf(userId));     }      //对某条朋友圈取消点赞     public void dislikeMoment(long userId, long momentId) {         jedis.srem("moment_like_users::" + momentId, String.valueOf(userId));     }      //查看自己是否对某条朋友圈点赞过     public boolean hasLikedMoment(long userId, long momentId) {         return jedis.sismember("moment_like_users::" + momentId, String.valueOf(userId));     }      //获取某条朋友圈有哪些人点赞了     public Set<String> getMomentLikeUsers(long momentId) {         return jedis.smembers("moment_like_users::" + momentId);     }      //获取某条朋友圈被几个人点赞了     public long getMomentLikeUsersCount(long momentId) {         return jedis.scard("moment_like_users::" + momentId);     }      public static void main(String[] args) throws Exception {         MomentsDemo demo = new MomentsDemo();         //用户id         long userId = 11;         //朋友圈id         long momentId = 151;         //朋友1的用户id         long friendId = 12;         //朋友2的用户id         long otherFriendId = 13;            //朋友1对你的朋友圈进行点赞，再取消点赞         demo.likeMoment(friendId, momentId);         demo.dislikeMoment(friendId, momentId);         boolean hasLikedMoment = demo.hasLikedMoment(friendId, momentId);         System.out.println("朋友1刷朋友圈，看到是否对自己的朋友圈点赞过：" + (hasLikedMoment ? "是" : "否"));            //朋友2对你的朋友圈进行点赞         demo.likeMoment(otherFriendId, momentId);         hasLikedMoment = demo.hasLikedMoment(otherFriendId, momentId);         System.out.println("朋友2刷朋友圈，看到是否对自己的朋友圈点赞过：" + (hasLikedMoment ? "是" : "否"));            //查看自己的朋友圈的点赞情况         Set<String> momentLikeUsers = demo.getMomentLikeUsers(momentId);         long momentLikeUsersCount = demo.getMomentLikeUsersCount(momentId);         System.out.println("自己刷朋友圈，看到自己发的朋友圈被" + momentLikeUsersCount + "个人点赞了，点赞的用户为：" + momentLikeUsers);     } }

 

18.实现一个网站投票统计程序(Set数据结构)

使用Redis的sadd和scard命令可实现投票功能。

//投票统计案例 public class VoteDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //投票     public void vote(long userId, long voteItemId) {         jedis.sadd("vote_item_users::" + voteItemId, String.valueOf(userId));     }      //检查用户对投票项是否投过票     public boolean hasVoted(long userId, long voteItemId) {         return jedis.sismember("vote_item_users::" + voteItemId, String.valueOf(userId));     }      //获取一个投票项被哪些人投票     public Set<String> getVoteItemUsers(long voteItemId) {         return jedis.smembers("vote_item_users::" + voteItemId);     }      //获取一个投票项被多少人投票     public long getVoteItemUsersCount(long voteItemId) {         return jedis.scard("vote_item_users::" + voteItemId);     }      public static void main(String[] args) throws Exception {         VoteDemo demo = new VoteDemo();            //定义用户id         long userId = 1;         //定义投票项id         long voteItemId = 110;         //进行投票         demo.vote(userId, voteItemId);         //检查我是否投票过         boolean hasVoted = demo.hasVoted(userId, voteItemId);         System.out.println("用户查看自己是否投票过：" +(hasVoted ? "是" : "否"));         //归票统计         Set<String> voteItemUsers = demo.getVoteItemUsers(voteItemId);         long voteItemUsersCount = demo.getVoteItemUsersCount(voteItemId);         System.out.println("投票项有哪些人投票：" + voteItemUsers + "，有几个人投票：" + voteItemUsersCount);     } }

 

19.实现微博的社交关系(Set数据结构)

使用Redis的sadd命令和srem命令可以实现类似微博的关注和取关功能，使用Redis的sinter命令可以获取共同关注的人(两个Set取交集)，使用Redis的sdiff命令可以获取没有关注的人(两个Set取差集)。

//微博案例 public class MicroBlogDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //关注别人，userId关注followUserId     public void follow(long userId, long followUserId) {         jedis.sadd("user::" + followUserId + "::followers", String.valueOf(userId));//关注者都有谁         jedis.sadd("user::" + userId + "::follow_users", String.valueOf(followUserId));//都关注了谁     }      //取消关注别人     public void unfollow(long userId, long followUserId) {         jedis.srem("user::" + followUserId + "::followers", String.valueOf(userId));//关注者都有谁         jedis.srem("user::" + userId + "::follow_users", String.valueOf(followUserId));//都关注了谁     }      //查看有哪些人关注了自己     public Set<String> getFollowers(long userId) {         return jedis.smembers("user::" + userId + "::followers");//关注者都有谁     }      //查看关注了自己的人数     public long getFollowersCount(long userId) {         return jedis.scard("user::" + userId + "::followers");//关注者都有谁     }      //查看自己关注了哪些人     public Set<String> getFollowUsers(long userId) {         return jedis.smembers("user::" + userId + "::follow_users");//都关注了谁     }      //查看自己关注的人数     public long getFollowUsersCount(long userId) {         return jedis.scard("user::" + userId + "::follow_users");//都关注了谁     }      //获取用户跟其他用户之间共同关注的人有哪些     public Set<String> getSameFollowUsers(long userId, long otherUserId) {         return jedis.sinter("user::" + userId + "::follow_users", "user::" + otherUserId + "::follow_users");     }      //获取otherUserId关注的，但userId没有关注的人，这些人可以推荐给userId     public Set<String> getRecommendFollowUsers(long userId, long otherUserId) {         return jedis.sdiff("user::" + otherUserId + "::follow_users", "user::" + userId + "::follow_users");     }      public static void main(String[] args) throws Exception {         MicroBlogDemo demo = new MicroBlogDemo();         //定义用户id         long userId = 31;         long friendId = 32;         long superstarId = 33;         long classmateId = 34;         long motherId = 35;         //定义关注的关系链         demo.follow(userId, friendId);         demo.follow(userId, motherId);         demo.follow(userId, superstarId);         demo.follow(friendId, superstarId);         demo.follow(friendId, classmateId);         //明星看看自己被哪些人关注了         Set<String> superstarFollowers = demo.getFollowers(superstarId);         long superstarFollowersCount = demo.getFollowersCount(superstarId);         System.out.println("明星被哪些人关注了：" + superstarFollowers + "，被关注的人数为：" + superstarFollowersCount);         //朋友看看自己被哪些人关注了，自己又关注了哪些人         Set<String> friendFollowers = demo.getFollowers(friendId);         long friendFollowersCount = demo.getFollowersCount(friendId);         System.out.println("朋友被哪些人关注了：" + friendFollowers + "，被多少人关注了：" + friendFollowersCount);         Set<String> friendFollowUsers = demo.getFollowUsers(friendId);         long friendFollowUsersCount = demo.getFollowUsersCount(friendId);         System.out.println("朋友关注了哪些人：" + friendFollowUsers + "，关注了多少人：" + friendFollowUsersCount);         //查看我关注了哪些人         Set<String> myFollowUsers = demo.getFollowUsers(userId);         long myFollowUsersCount = demo.getFollowUsersCount(userId);         System.out.println("我关注了哪些人：" + myFollowUsers + ", 我关注的人数：" + myFollowUsersCount);         //获取我和朋友共同关注的用户         Set<String> sameFollowUsers = demo.getSameFollowUsers(userId, friendId);         System.out.println("我和朋友共同关注的人有哪些：" + sameFollowUsers);         //获取可以推荐给我关注的人         Set<String> recommendFollowUsers = demo.getRecommendFollowUsers(userId, friendId);         System.out.println("推荐给我关注的人有哪些：" + recommendFollowUsers);     } }

 

20.实现网站上的抽奖程序(Set数据结构)

使用Redis的sadd命令和srandmember命令可以实现抽奖功能。

//抽奖案例 public class LotteryDrawDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //添加抽奖候选人     public void addLotteryDrawCandidate(long userId, long lotteryDrawEventId) {         jedis.sadd("lottery_draw_event::" + lotteryDrawEventId +"::candidates", String.valueOf(userId));     }      //实际进行抽奖     public List<String> doLotteryDraw(long lotteryDrawEventId, int count) {         return jedis.srandmember("lottery_draw_event::" + lotteryDrawEventId +"::candidates", count);     }      public static void main(String[] args) throws Exception {         LotteryDrawDemo demo = new LotteryDrawDemo();         int lotteryDrawEventId = 120;         for (int i = 0; i < 20; i++) {             demo.addLotteryDrawCandidate(i + 1, lotteryDrawEventId);         }         List<String> lotteryDrawUsers = demo.doLotteryDraw(lotteryDrawEventId, 3);         System.out.println("获奖人选为：" + lotteryDrawUsers);     } }

 

21.为商品搜索构建反向索引(Set数据结构)

使用Redis的sadd命令和sinter命令可以为商品搜索构建反向索引。

//商品搜索案例 public class ProductSearchDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //添加商品的时候附带一些关键词     public void addProduct(long productId, String[] keywords) {         for (String keyword : keywords) {             jedis.sadd("keyword::" + keyword + "::products", String.valueOf(productId));         }     }      //根据多个关键词搜索商品     public Set<String> searchProduct(String[] keywords) {         List<String> keywordSetKeys = new ArrayList<String>();         for (String keyword : keywords) {             keywordSetKeys.add("keyword::" + keyword + "::products");         }            String[] keywordArray = keywordSetKeys.toArray(new String[keywordSetKeys.size()]);         return jedis.sinter(keywordArray);     }      public static void main(String[] args) throws Exception {         ProductSearchDemo demo = new ProductSearchDemo();            //添加一批商品         demo.addProduct(11, new String[]{"手机", "iphone", "潮流"});         demo.addProduct(12, new String[]{"iphone", "潮流", "炫酷"});         demo.addProduct(13, new String[]{"iphone", "天蓝色"});            //根据关键词搜索商品         Set<String> searchResult = demo.searchProduct(new String[]{"iphone", "潮流"});         System.out.println("商品搜索结果为：" + searchResult);     } }

 

22.实现音乐网站的排行榜(Sorted Set数据结构)

Redis的Sorted Set里的元素会按照分数进行排序。使用zadd命令可以把音乐加入排行榜中(刚开始分数可能就是0)，使用zscore命令可以获取音乐的分数，使用zrem命令可以删除某首音乐，使用zincrby命令可以给某首音乐增加分数(比如播放、分享、点赞时)，使用zrevrank命令可以获取音乐在排行榜里的排名，使用zrevrange set 0 100 withscores(可以获取排名前100首热门歌曲)。

//音乐排行榜案例 public class MusicRankingListDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //把新的音乐加入到排行榜里去     public void addSong(long songId) {         jedis.zadd("music_ranking_list", 0, String.valueOf(songId));     }      //增加歌曲的分数     public void incrementSongScore(long songId, double score) {         jedis.zincrby("music_ranking_list", score, String.valueOf(songId));     }      //获取歌曲在排行榜里的排名     public long getSongRank(long songId) {         return jedis.zrevrank("music_ranking_list", String.valueOf(songId));     }      //获取音乐排行榜     public Set<Tuple> getMusicRankingList() {         return jedis.zrevrangeWithScores("music_ranking_list", 0, 2);     }      public static void main(String[] args) throws Exception {         MusicRankingListDemo demo = new MusicRankingListDemo();         for (int i = 0; i < 20; i++) {             demo.addSong(i + 1);         }            demo.incrementSongScore(5, 3.2);         demo.incrementSongScore(15, 5.6);         demo.incrementSongScore(7, 9.6);            long songRank = demo.getSongRank(5);         System.out.println("查看id为5的歌曲的排名：" + (songRank + 1));            Set<Tuple> musicRankingList = demo.getMusicRankingList();         System.out.println("查看音乐排行榜排名前3的歌曲：" + musicRankingList);     } }

 

23.实现获取指定时间的新闻(Sorted Set数据结构)

可以对Redis里的Sorted Set的数据进行倒序排序，然后可以选择其中指定的分数区间范围内的数据，并进行分页查询。

 

可以维护一个新闻数据集合，里面的分数都是新闻的时间戳。使用zadd命令可以把当日最新的新闻加入到一个集合里，使用zrem命令可以删除某个新闻，使用zcard命令可以统计当日最新新闻，使用zrevrangeByScoreWithScores命令可以按时间分数进行倒序排序，使用zcount命令可以获取指定分数范围的数量。

//新闻浏览案例 public class NewsDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //加入一篇新闻     public void addNews(long newsId, long timestamp) {         jedis.zadd("news", timestamp, String.valueOf(newsId));     }      //搜索新闻     public Set<Tuple> searchNews(long maxTimestamp, long minTimestamp, int index , int count) {         return jedis.zrevrangeByScoreWithScores("news", maxTimestamp, minTimestamp, index, count);     }      public static void main(String[] args) throws Exception {         NewsDemo demo = new NewsDemo();         for (int i = 0; i < 20; i++) {             demo.addNews(i + 1, i + 1);         }            long maxTimestamp = 18;         long minTimestamp = 2;         int pageNo = 1;         int pageSize = 10;         int startIndex = (pageNo - 1) * 10;         Set<Tuple> searchResult = demo.searchNews(maxTimestamp, minTimestamp, startIndex, pageSize);         System.out.println("搜索指定时间范围内的新闻的第一页：" + searchResult);     } }

 

24.实现购买某商品时也会购买其他商品的推荐功能(Sorted Set数据结构)

用户购买两个商品时，其中一个商品可以作为key，另一个商品作为value，商品的购买数量作为score，设置到Redis的Sorted Set数据结构中，这样后续就可以根据score分数来获取购买某商品时应该推荐那些商品，对应的Redis命令是zincrby命令和zrevrangeWithScores命令。

//推荐其他商品案例 public class RecommendProductDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //购买商品productId的同时，也购买了商品otherProductId     public void continuePurchase(long productId, long otherProductId) {         jedis.zincrby("continue_purchase_products::" + productId, 1, String.valueOf(otherProductId));     }      //推荐其他人购买productId时也会购买的其他商品     public Set<Tuple> getRecommendProducts(long productId) {         return jedis.zrevrangeWithScores("continue_purchase_products::" + productId, 0, 2);     }      public static void main(String[] args) throws Exception {         RecommendProductDemo demo = new RecommendProductDemo();         int productId = 1;         for (int i = 0; i < 20; i++) {             demo.continuePurchase(productId, i + 2);         }         for (int i = 0; i < 3; i++) {             demo.continuePurchase(productId, i + 2);         }         Set<Tuple> recommendProducts = demo.getRecommendProducts(productId);         System.out.println("推荐其他人购买过的商品：" + recommendProducts);     } }

 

25.实现搜索框的自动补全(Sorted Set数据结构)

使用zincrby命令和zrevrange命令可以实现搜索框的自动补全功能。每次搜索时，key为潜在搜索词，value为完整搜索词，score为当前时间。

//自动补全案例 public class AutoCompleteDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //搜索某个关键词     public void search(String keyword) {         char[] keywordCharArray = keyword.toCharArray();         StringBuffer potentialKeyword = new StringBuffer("");         for (char keywordChar : keywordCharArray) {             potentialKeyword.append(keywordChar);             //key为潜在搜索词，value为完整搜索词，score为当前时间             jedis.zincrby("potential_Keyword::" + potentialKeyword.toString() + "::keywords", new Date().getTime(), keyword);         }     }      //获取自动补全列表     //按照score排序，就可以获取最新搜索的搜索词     public Set<String> getAutoCompleteList(String potentialKeyword) {         return jedis.zrevrange("potential_Keyword::" + potentialKeyword + "::keywords", 0, 2);     }      public static void main(String[] args) throws Exception {         AutoCompleteDemo demo = new AutoCompleteDemo();         demo.search("我爱大家");         demo.search("我喜欢学习Redis");         demo.search("我很喜欢一个城市");         demo.search("我不太喜欢玩儿");         demo.search("我喜欢学习Spark");            Set<String> autoCompleteList = demo.getAutoCompleteList("我");         System.out.println("第一次自动补全推荐：" + autoCompleteList);            autoCompleteList = demo.getAutoCompleteList("我喜");         System.out.println("第二次自动补全推荐：" + autoCompleteList);     } }

 

26.基于HyperLogLog的网站UV统计程序(HyperLogLog数据结构)

Redis的HyperLogLog可以得到去重统计的近似数。如果基于Redis的set来统计UV，则太耗费内存了，而且也没必要太精准。如果基于HyperLogLog来统计UV，则只占12KB内存，且误差只有0.8%。

 

使用Redis的HyperLogLog的具体方式是：先通过pfadd命令对数据进行计数，再通过pfcount命令获取计数结果。

//基于HyperLogLog统计UV的案例 public class HyperLogLogUVDemo {     private Jedis jedis = new Jedis("127.0.0.1");          //初始化uv数据     public void initUVData() {         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");         String today = dateFormat.format(new Date());         for (int i = 0; i < 1358; i++) {             for (int j = 0; j < 10; j++) {                 jedis.pfadd("hyperloglog_uv_" + today, String.valueOf((i + 1)));             }         }     }      //获取uv值     public long getUV() {         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");         String today = dateFormat.format(new Date());         return jedis.pfcount("hyperloglog_uv_" + today);     }      public static void main(String[] args) throws Exception {         HyperLogLogUVDemo demo = new HyperLogLogUVDemo();         demo.initUVData();         long uv = demo.getUV();         System.out.println("今天uv的值是：" + uv);     } }

 

27.网站重复垃圾数据的快速去重和过滤(HyperLogLog数据结构)

可以使用Redis的HyperLogLog对垃圾数据进行快速过滤，比如通过执行"pfadd key content"命令。如果返回的是1，那么说明之前没见过这条数据。如果返回的是0，说明之前见过这条数据了。

//垃圾内容过滤案例 public class GarbageContentFilterDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //判断当前内容是否是垃圾内容     public Boolean isGarbageContent(String content) {         return jedis.pfadd("hyperloglog_contennt", content) == 0;     }      public static void main(String[] args) {         GarbageContentFilterDemo demo = new GarbageContentFilterDemo();         String content = "正常的内容";         System.out.println("是否为垃圾内容：" + (demo.isGarbageContent(content) ? "是" : "否"));            content = "垃圾内容";         System.out.println("是否为垃圾内容：" + (demo.isGarbageContent(content) ? "是" : "否"));                    content = "垃圾内容";         System.out.println("是否为垃圾内容：" + (demo.isGarbageContent(content) ? "是" : "否"));     } }

 

28.周活月活年活的统计(HyperLogLog数据结构)

首先使用pfadd命令对每天日活进行计数，然后再通过pfcount命令获取每天日活结果，周活跃用户数和年活跃用户数都可以基于日活跃用户数来进行统计。

//网站日常指标统计案例 public class WebsiteStatisticsDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //初始化某一天的uv数据     public void initUVData(String date) {         Random random = new Random();         int startIndex = random.nextInt(1000);         System.out.println("今日访问uv起始id为：" + startIndex);            for (int i = startIndex; i < startIndex + 1358; i++) {             for (int j = 0; j < 10; j++) {                 jedis.pfadd("hyperloglog_uv_" + date, String.valueOf((i + 1)));             }         }     }      //获取某日的uv值     public long getUV(String date) {         return jedis.pfcount("hyperloglog_uv_" + date);     }      //获取周活跃用户数     public long getWeeklyUV() {         List<String> keys = new ArrayList<String>();         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");         Calendar calendar = Calendar.getInstance();         calendar.setTime(new Date());         for (int i = 0; i < 7; i++) {             calendar.add(Calendar.DAY_OF_YEAR, 1);             String date = dateFormat.format(calendar.getTime());             keys.add("hyperloglog_uv_" + date);         }         String[] keyArray = keys.toArray(new String[keys.size()]);         jedis.pfmerge("weekly_uv", keyArray);         return jedis.pfcount("weekly_uv");     }      public static void main(String[] args) throws Exception {         WebsiteStatisticsDemo demo = new WebsiteStatisticsDemo();         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");            Calendar calendar = Calendar.getInstance();         calendar.setTime(new Date());         long duplicateUv = 0;         for (int i = 0; i < 7; i++) {             calendar.add(Calendar.DAY_OF_YEAR, 1);             String date = dateFormat.format(calendar.getTime());             demo.initUVData(date);                long uv = demo.getUV(date);             System.out.println("日期为" + date + "的uv值为：" + uv);             duplicateUv += uv;         }            long weeklyUV = demo.getWeeklyUV();         System.out.println("实际的周活跃用户数为：" + weeklyUV);     } }

 

29.基于位图的用户行为记录(BitMap数据结构)

Redis的位图命令setbit：一个字节(byte)8个位(bit)，每个位是0或者1。"setbit key offset value"，指将左起向右偏移offset的位置设置value。

 

如果用户系统需要统计某用户登录天数，且统计窗口随机。那么这时可这样设计：以用户ID为位图的key，登录日期天数作为偏移量。

 

所以这个key是有365个位的。用户在某一天登录了，就在这个key上对应的偏移量设1。用户user1在第2天登录了，可以设置："setbit user1 1 1"。用户user1在第8天登录了，可以设置："setbit user1 7 1"。用户user1在第365天登录了，可以设置："setbit user1 364 1"。这样一个用户总共就只需要46个字节而已，1亿用户 * 46byte = 4G。查看用户最后两周是否登录，可以执行："bitcount user1 -2 -1"。

 

如果要把活跃用户统计出来，比如1号~3号连续登录要去重。那么可以这样设计：以日期为位图的key，用户ID作为偏移量。固定好对应于二进制位的那一个位，id和二进制位做好映射。

 

比如1号用户在2020年1月1号登录了，那么"setbit 20200101 1 1"。比如1号用户在2020年1月2号登录了，那么"setbit 20200102 1 1"。比如7号用户在2020年1月2号登录了，那么"setbit 20200102 7 1"。因此可以通过位或算出2020年1月2号到2020年1月2号的活跃用户数是："bitop or destkey 20200101 20200102"。然后获取destkey有多少个1即可："bitcount destkey 0 -1"。

 

如果要记录用户是否执行过某些操作，也可以使用位图来实现高效记录。此时可这样设计：以操作类型为位图的key，用户ID作为位图的偏移量。

//网站用户操作日志案例 public class UserOperationLogDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //记录用户的操作日志     public void recordUserOperationLog(String operation, long userId) {         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");         String today = dateFormat.format(new Date());         jedis.setbit("operation::" + operation + "::" + today + "::log", userId, String.valueOf(1));     }      //判断用户今天是否执行过某个操作     public Boolean hasOperated(String operation, long userId) {         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");         String today = dateFormat.format(new Date());         return jedis.getbit("operation::" + operation + "::" + today + "::log", userId);     }      public static void main(String[] args) {         UserOperationLogDemo demo = new UserOperationLogDemo();         demo.recordUserOperationLog("操作1", 110);         System.out.println("用户110是否执行过操作：" + (demo.hasOperated("操作1", 110) ? "是" : "否"));         System.out.println("用户111是否执行过操作：" + (demo.hasOperated("操作1", 111) ? "是" : "否"));     } }

 

30.基于Geo的距离计算程序(Geo数据结构)

使用Redis的geoadd命令和geodist命令可以计算两个经纬度的距离。

//用户与商家的距离计算案例 public class UserShopDistanceDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //添加一个地理位置     public void addLocation(String name, double longitude, double latitude) {         jedis.geoadd("location_data", longitude, latitude, name);     }      //获取用户到商家的位置     public double getDistance(String user, String shop) {         return jedis.geodist("location_data", user, shop, GeoUnit.KM);     }      public static void main(String[] args) {         UserShopDistanceDemo demo = new UserShopDistanceDemo();         demo.addLocation("张三", 116.49428833935545, 39.86700462665782);         demo.addLocation("丫丫小吃店", 116.45961274121092, 39.87517301328063);         System.out.println("用户到商家的距离为：" + demo.getDistance("张三", "丫丫小吃店"));     } }

 

31.陌生人社交里的查找附近的人(Geo数据结构)

使用Redis的georadiusByMember命令可以查找某位置附近的位置。

//查找附近的人案例 public class NearbyShopsDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //添加一个地理位置     public void addLocation(String name, double longitude, double latitude) {         jedis.geoadd("location_data", longitude, latitude, name);     }      //查找附近5公里内的店铺     public List<GeoRadiusResponse> getNearbyShops() {         return jedis.georadiusByMember("location_data", "张三", 5.0, GeoUnit.KM);     }      public static void main(String[] args) {         NearbyShopsDemo demo = new NearbyShopsDemo();         List<String> nearbyShops = new ArrayList<String>();         List<GeoRadiusResponse> results = demo.getNearbyShops();         for (GeoRadiusResponse result : results) {             String name = result.getMemberByString();             if (!name.equals("张三")) {                 nearbyShops.add(name);             }         }         System.out.println("附近5公里内的商家：" + nearbyShops);     } }

 

32.带有自动过期时间的分布式缓存(expire命令)

其实就是使用Redis的expire命令设置过期时间。

//数据自动过期的案例 public class ExpireDemo {     private static Jedis jedis = new Jedis("127.0.0.1");          public static void main(String[] args) throws Exception {         jedis.set("test_key", "test_value");         jedis.expire("test_key", 10);         Thread.sleep(12 * 1000);         String testValue = jedis.get("test_key");         System.out.println("数据是否过期：" + (testValue == null || "null".equals(testValue) ? "是" : "否"));     } }

 

33.支持超时自动释放的简单分布式锁(expire命令)

其实就是使用Redis的setnx命令和expire命令设置锁及其过期时间。

//支持超时自动释放的简单分布式锁案例 public class TimeoutDistributedLockDemo {     private static Jedis jedis = new Jedis("127.0.0.1");          //加锁     public Boolean lock(String key, String value, int timeout) {         long result = jedis.setnx(key, value);         jedis.expire(key, timeout);         return result > 0;     }          public static void main(String[] args) throws Exception {         TimeoutDistributedLockDemo demo = new TimeoutDistributedLockDemo();         demo.lock("test_lock", "test_value", 10);         Thread.sleep(12 * 1000);         Boolean result = demo.lock("test_lock", "test_value", 10);         System.out.println("第二次加锁结果：" + (result ? "成功" : "失败"));     } }

 

34.支持自动过期的用户登录会话实现(expire命令)

通过expire命令设置过期时间让用户登录自动过期。

//用户会话管理案例 public class SessionDemo {     private Jedis jedis = new Jedis("127.0.0.1");      //检查session是否有效     public boolean isSessionValid(String token) throws Exception {         //校验token是否为空         if (token == null || "".equals(token)) {             return false;         }         String session = jedis.get( "session::" + token);         if (session == null || "".equals(session) || "null".equals(session)) {             return false;         }         //如果token不为空，且获取到的Session不为空，且Session没过期，此时可以认为Session在有效期内         return true;     }      //模拟的登录方法     public String login(String username, String password) {         //基于用户名和密码去登录         System.out.println("基于用户名和密码登录：" + username + ", " + password);         Random random = new Random();         long userId = random.nextInt() * 100;         //登录成功后，生成一块令牌         String token = UUID.randomUUID().toString().replace("-", "");         //基于令牌和用户id去初始化用户的Session         jedis.set("session::" + token, String.valueOf(userId));         jedis.expire("session::" + token, 10);         //返回这个令牌给用户         return token;     }      public static void main(String[] args) throws Exception {         SessionDemo demo = new SessionDemo();         //第一次访问系统，token都是空的         boolean isSessionValid = demo.isSessionValid(null);         System.out.println("第一次访问系统的Session校验结果：" + (isSessionValid == true ? "通过" : "不通过"));            //强制性进行登录，获取到token         String token = demo.login("test","123456");         System.out.println("登陆过后拿到令牌：" + token);            //第二次再次访问系统，此时是可以访问的         isSessionValid = demo.isSessionValid(token);         System.out.println("第二次访问系统的Session校验结果：" + (isSessionValid == true ? "通过" : "不通过"));         Thread.sleep(12 * 1000);            //第三次再次访问系统，Session已过期，此时是不可以访问的         isSessionValid = demo.isSessionValid(token);         System.out.println("第三次访问系统的Session校验结果：" + (isSessionValid == true ? "通过" : "不通过"));     } }

 

35.支持冷数据自动淘汰的自动补全(expire命令)

通过expire命令设置过期时间让冷数据自动淘汰实现冷热分离。

//自动补全案例 public class AutoCompleteDemo {     private Jedis jedis = new Jedis("127.0.0.1");          //搜索某个关键词     public void search(String keyword) {         char[] keywordCharArray = keyword.toCharArray();         StringBuffer potentialKeyword = new StringBuffer("");         for (char keywordChar : keywordCharArray) {             potentialKeyword.append(keywordChar);             jedis.zincrby("potential_Keyword::" + potentialKeyword.toString() + "::keywords", new Date().getTime(), keyword);             //通过设置过期时间，冷数据就会自动淘汰             jedis.expire("potential_Keyword::" + potentialKeyword.toString() + "::keywords", 10);         }     }          //获取自动补全列表     public Set<String> getAutoCompleteList(String potentialKeyword) {         return jedis.zrevrange("potential_Keyword::" + potentialKeyword + "::keywords", 0, 2);     }          public static void main(String[] args) throws Exception {         AutoCompleteDemo demo = new AutoCompleteDemo();         demo.search("我爱大家");         demo.search("我喜欢学习Redis");         demo.search("我很喜欢一个城市");         demo.search("我不太喜欢玩儿");         demo.search("我喜欢学习Spark");         Set<String> autoCompleteList = demo.getAutoCompleteList("我");         System.out.println("第一次自动补全推荐：" + autoCompleteList);            autoCompleteList = demo.getAutoCompleteList("我喜");         System.out.println("第二次自动补全推荐：" + autoCompleteList);            Thread.sleep(12 * 1000);         autoCompleteList = demo.getAutoCompleteList("我");         System.out.println("第三次自动补全推荐：" + autoCompleteList);     } }

 

36.支持身份验证的分布式锁释放(pipeline命令)

通过Redis的pipeline命令和事务操作可以保证多个命令在一个事务内全部完成，从而减少多次网络请求带来的开销。

 

pipeline的watch命令可以在事务开始执行前对所要操作的key执行监测，从而保证了事务的完整性和一致性。因此，为了防止锁篡改，可以在加锁完成之后对锁进行watch操作，一旦锁发生变化，则终止事务，回滚操作。

//支持超时自动释放的分布式锁案例 public class TimeoutDistributedLockDemo {     private static Jedis jedis = new Jedis("127.0.0.1");      //加锁     public Boolean lock(String key, String value, int timeout) {         long result = jedis.setnx(key, value);         jedis.expire(key, timeout);         return result > 0;     }      //释放锁，需要判断是否是当前线程加的锁，才可以释放     //key是锁的名称，value是线程名称     public Boolean unlock(String key, String value) {         String currentValue = jedis.get(key);         Pipeline pipeline = jedis.pipelined();         try {             pipeline.watch(key);             if (currentValue == null || currentValue.equals("") || currentValue.equals("null")) {                 return true;             }             if (currentValue.equals(value)) {                 //通过pipeline.multi()命令开启事务                 pipeline.multi();                 pipeline.del(key);                 //通过pipeline.exec()提交事务                 pipeline.exec();                 return true;             } else {                 return false;             }         } catch (Exception e) {             e.printStackTrace();             return false;         } finally {             pipeline.unwatch();             pipeline.close();         }     }      public static void main(String[] args) throws Exception {         TimeoutDistributedLockDemo demo = new TimeoutDistributedLockDemo();         demo.lock("test_lock", "test_value", 10);         Thread.sleep(12 * 1000);            Boolean result = demo.lock("test_lock", "test_value", 10);         System.out.println("第二次加锁结果：" + (result ? "成功" : "失败"));            System.out.println("不是加锁线程能否释放锁：" + (demo.unlock("test_lock", "非加锁线程的名称") ? "能" : "否"));         System.out.println("加锁线程能否释放锁：" + (demo.unlock("test_lock", "加锁线程的名称") ? "能" : "否"));     } }