- VisualStudio2022插件的安装及使用-编程手把手系列文章
- pprof-在现网场景怎么用
- C#实现的下拉多选框,下拉多选树,多级节点
- 【学习笔记】基础数据结构:猫树
大纲 。
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", "加锁线程的名称") ? "能" : "否"));
}
}
。
最后此篇关于Redis应用—9.简单应用汇总的文章就讲到这里了,如果你想了解更多关于Redis应用—9.简单应用汇总的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
我正在努力实现以下目标, 假设我有字符串: ( z ) ( A ( z ) ( A ( z ) ( A ( z ) ( A ( z ) ( A ) ) ) ) ) 我想编写一个正则
给定: 1 2 3 4 5 6
很难说出这里要问什么。这个问题模棱两可、含糊不清、不完整、过于宽泛或夸夸其谈,无法以目前的形式得到合理的回答。如需帮助澄清此问题以便重新打开,visit the help center . 关闭 1
大家好,我卡颂。 Svelte问世很久了,一直想写一篇好懂的原理分析文章,拖了这么久终于写了。 本文会围绕一张流程图和两个Demo讲解,正确的食用方式是用电脑打开本文,跟着流程图、Demo一
身份证为15位或者18位,15位的全为数字,18位的前17位为数字,最后一位为数字或者大写字母”X“。 与之匹配的正则表达式: ?
我们先来最简单的,网页的登录窗口; 不过开始之前,大家先下载jquery的插件 本人习惯用了vs2008来做网页了,先添加一个空白页 这是最简单的的做法。。。先在body里面插入 <
1、MySQL自带的压力测试工具 Mysqlslap mysqlslap是mysql自带的基准测试工具,该工具查询数据,语法简单,灵活容易使用.该工具可以模拟多个客户端同时并发的向服务器发出
前言 今天大姚给大家分享一款.NET开源(MIT License)、免费、简单、实用的数据库文档(字典)生成工具,该工具支持CHM、Word、Excel、PDF、Html、XML、Markdown等
Go语言语法类似于C语言,因此熟悉C语言及其派生语言( C++、 C#、Objective-C 等)的人都会迅速熟悉这门语言。 C语言的有些语法会让代码可读性降低甚至发生歧义。Go语言在C语言的
我正在使用快速将 mkv 转换为 mp4 ffmpeg 命令 ffmpeg -i test.mkv -vcodec copy -acodec copy new.mp4 但不适用于任何 mkv 文件,当
我想计算我的工作簿中的工作表数量,然后从总数中减去特定的工作表。我错过了什么?这给了我一个对象错误: wsCount = ThisWorkbook.Sheets.Count - ThisWorkboo
我有一个 perl 文件,用于查看文件夹中是否存在 ini。如果是,它会从中读取,如果不是,它会根据我为它制作的模板创建一个。 我在 ini 部分使用 Config::Simple。 我的问题是,如果
尝试让一个 ViewController 通过标准 Cocoa 通知与另一个 ViewController 进行通信。 编写了一个简单的测试用例。在我最初的 VC 中,我将以下内容添加到 viewDi
我正在绘制高程剖面图,显示沿路径的高程增益/损失,类似于下面的: Sample Elevation Profile with hand-placed labels http://img38.image
嗨,所以我需要做的是最终让 regStart 和 regPage 根据点击事件交替可见性,我不太担心编写 JavaScript 函数,但我根本无法让我的 regPage 首先隐藏。这是我的代码。请简单
我有一个非常简单的程序来测量一个函数花费了多少时间。 #include #include #include struct Foo { void addSample(uint64_t s)
我需要为 JavaScript 制作简单的 C# BitConverter。我做了一个简单的BitConverter class BitConverter{ constructor(){} GetBy
已关闭。这个问题是 not reproducible or was caused by typos 。目前不接受答案。 这个问题是由拼写错误或无法再重现的问题引起的。虽然类似的问题可能是 on-top
我是 Simple.Data 的新手。但我很难找到如何进行“分组依据”。 我想要的是非常基本的。 表格看起来像: +________+ | cards | +________+ | id |
我现在正在开发一个 JS UDF,它看起来遵循编码。 通常情况下,由于循环计数为 2,Alert Msg 会出现两次。我想要的是即使循环计数为 3,Alert Msg 也只会出现一次。任何想法都
我是一名优秀的程序员,十分优秀!