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", "加锁线程的名称") ? "能" : "否"));
}
}
