Redis的应用实战场景

这里列举常见的redis实战场景

大概从网上找来了下面这里实战场景：
1、最新20条评论
2、排行榜
3、计数
4、统计在某段特点时间里有多少特定用户访问了某个特定资源（比如我想要知道某些特定的注册用户或IP地址，他们到底有多少访问了某篇文章。）
5、按照用户投票和时间排序
6、实时分析正在发生的情况，用于数据统计与防止垃圾邮件等
7、Reverse cache(反向cache)
8、用户最近访问记录
9、Fast transaction with Lua
Redis 的Lua的功能扩展实际给Redis带来了更多的应用场景，你可以编写若干command组合作为一个小型的非阻塞事务或者更新逻辑，如：在收到 message推送时，同时1.给自己的增加一个未读的对话 2.给自己的私信增加一个未读消息 3.最后给发送人回执一个完成推送消息，这一层逻辑完全可以在Redis Server端实现。
但是，需要注意的是Redis会将lua script的全部内容记录在aof和传送给slave，这也将是对磁盘，网卡一个不小的开销。
10、分布式锁
11、抢号（不一定每人都有），抢红包模式（每人都有）
12、Uniq操作，获取某段时间所有数据去重值
13、打卡
14、session存储
15、bitmap的使用场景
16、文章投票
17、限流工具

18、好友关系

19、热数据查询

具体api说明：https://blog.csdn.net/sinat_22797429/article/details/89196933

1、排行榜场景（利用zset）

需求：

前段时间，做了一个世界杯竞猜积分排行榜。对世界杯64场球赛胜负平进行猜测，猜对+1分，错误+0分，一人一场只能猜一次。
1.展示前一百名列表。
2.展示个人排名(如：张三，您当前的排名106579)。

       一开始打算直接使用mysql数据库来做，遇到一个问题，每个人的分数都会变化,如何能够获取到个人的排名呢？数据库可以通过分数进行row_num排序，但是这个方法需要进行全表扫描，当参与的人数达到10000的时候查询就非常慢了。
redis的排行榜功能就完美锲合了这个需求。来看看我是怎么实现的吧。

实现逻辑：

redis中的zset（sorted sets）数据类型

Sorted Sets数据类型就像是set和hash的混合。与sets一样，Sorted Sets是唯一的，不重复的字符串组成。可以说Sorted Sets也是Sets的一种。

Sorted Sets是通过Skip List(跳跃表)和hash Table(哈希表)的双端口数据结构实现的，因此每次添加元素时，Redis都会执行O(log(N))操作。所以当我们要求排序的时候，Redis根本不需要做任何工作了，早已经全部排好序了。元素的分数可以随时更新。

将数据以zset的数据方式存进redis（根据得分为score属性）。在存进去的时候redis已经帮我们排序好了。、

（存数据时以分数为score属性，在获取时根据score属性值进行逆序获取）

1.展示前一百名列表。

代码实现：

依赖

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.60</version>
        </dependency>
    </dependencies>

创建以下结构：

controller：

@RestController
public class PhbController {

    @Autowired
    PhbServiceImpl phbServiceImpl;

    @GetMapping("/phb")
    public void phb(){

        phbServiceImpl.phbImpl();
    }
}

service：

@Service
public class PhbServiceImpl {

    //注入template对象(也可以直接用RedisTemplate)
//注意StringRedisTemplate表示key、value都是String类型，如果用RedisTemplate则key为String、value为object类型
    @Autowired
    StringRedisTemplate redisTemplate;

    //redis存储的key值
    public static final String SCORE_RANK = "score_rank";

    //实现逻辑
    public void phbImpl(){

        //1、模拟10万条数据
        Set<ZSetOperations.TypedTuple<String>> tuples = new HashSet<>();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {//向set集合中插入10万条数据
            DefaultTypedTuple<String> tuple = new DefaultTypedTuple<>("张三" + i, 1D + i);
            tuples.add(tuple);
        }
        System.out.println("循环时间:" +( System.currentTimeMillis() - start));
        //2、向redis中添加该set集合
        //此时的redis中数据则是key：SCORE_RANK----value：｛（"张三" + i，1D + i），（"张三" + i，1D + i）｝
        //其中以1D + i为score属性进行排序
        Long num = redisTemplate.opsForZSet().add(SCORE_RANK, tuples);
        System.out.println("批量新增时间:" +(System.currentTimeMillis() - start));
        System.out.println("受影响行数：" + num);

        //3、获取排行版前10名列表+获取前10名分数和名称列表
        list(10);

    }

    private void list(int count){
        //获取排名列表
        Set<String> range = redisTemplate.opsForZSet().range(SCORE_RANK, 0, count);
        System.out.println("获取到的排名列表为："+range);
        //获取排行和分数列表
        Set<ZSetOperations.TypedTuple<String>> rangeWithScores = redisTemplate.opsForZSet().reverseRangeWithScores(SCORE_RANK, 0, 10);
        System.out.println("获取排行和分数列表为："+ JSON.toJSONString(rangeWithScores));

    }
}

启动类：

@SpringBootApplication
public class phbApplication {

    public static void main(String[] args) {

        SpringApplication.run(phbApplication.class,args);
    }
}

yml文件：

spring:
  #redis配置信息
  redis:
    #redis 服务器地址
    host: 192.168.211.20
    #redis端口
    port: 6379
    #客户端超时时间单位是毫秒 默认是2000
    timeout: 5000
    #最大空闲数
    maxIdle: 20
    #连接池的最大数据库连接数
    maxActive: -1
    #控制一个pool可分配多少个jedis实例,用来替换上面的maxActive
    maxTotal: 100
    #最大建立连接等待时间。如果超过此时间将接到异常
    maxWaitMillis: 100
    #连接的最小空闲时间
    minEvictableIdleTimeMillis: 864000000
    #每次释放连接的最大数目
    numTestsPerEvictionRun: 10
    #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程
    timeBetweenEvictionRunsMillis: 300000
    #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    testOnBorrow: true
    #在空闲时检查有效性
    testWhileIdle: false
    #数据库
    database: 0
server:
  port: 9090

访问：http://localhost:9090/phb接口查看控制台：

上面是进行所有人员进行排序的，如果此时只想获取某个人的分数和排名，如何实现？

2.展示个人排名(如：张三，您当前的排名106579)。

代码实现：

在phbImpl方法中先模拟一个数据的插入：

 redisTemplate.opsForZSet().add(SCORE_RANK, "李四", 8899);

在list方法中打印该人的排位等：

Long rankNum = redisTemplate.opsForZSet().reverseRank(SCORE_RANK, "李四");
        System.out.println("李四的个人排名：" + rankNum);

Double score = redisTemplate.opsForZSet().score(SCORE_RANK, "李四");
        System.out.println("李四的分数:" + score);

访问http://localhost:9090/phb查看控制台：

3、统计某分数区间有多少人？

代码实现：8001-9000区间人数

Long count = redisTemplate.opsForZSet().count(SCORE_RANK, 8001, 9000);

4、获取整个集合数量

Long aLong = redisTemplate.opsForZSet().zCard(SCORE_RANK);

5、对某个人进行分数修改，使用加法操作分数（将李四的值加1000）

Double score = redisTemplate.opsForZSet().incrementScore(SCORE_RANK, "李四", 1000);

（上面修改时如果有缓存数据则为更新，没有则为新增）

6、总结：

1）、新增or更新

有三种方式，一种是单个，一种是批量，对分数使用加法(如果不存在，则从0开始加)。

//单个新增or更新
Boolean add(K key, V value, double score);
//批量新增or更新
Long add(K key, Set<TypedTuple<V>> tuples);
//使用加法操作分数
Double incrementScore(K key, V value, double delta);

2）、删除：删除提供了三种方式：通过key/values删除，通过排名区间删除，通过分数区间删除。

//通过key/value删除
Long remove(K key, Object... values);

//通过排名区间删除
Long removeRange(K key, long start, long end);

//通过分数区间删除
Long removeRangeByScore(K key, double min, double max);

3）查询：

3.1：列表查询:分为两大类，正序和逆序。以下只列表正序的，逆序的只需在方法前加上reverse即可：

//通过排名区间获取列表值集合

Set<V> range(K key, long start, long end);

//通过排名区间获取列表值和分数集合
Set<TypedTuple<V>> rangeWithScores(K key, long start, long end);

//通过分数区间获取列表值集合
Set<V> rangeByScore(K key, double min, double max);

//通过分数区间获取列表值和分数集合
Set<TypedTuple<V>> rangeByScoreWithScores(K key, double min, double max);

//通过Range对象删选再获取集合排行
Set<V> rangeByLex(K key, Range range);

//通过Range对象删选再获取limit数量的集合排行
Set<V> rangeByLex(K key, Range range, Limit limit);

3.2：单人查询

可获取单人排行，和通过key/value获取分数。以下只列表正序的，逆序的只需在方法前加上reverse即可：

//获取个人排行
Long rank(K key, Object o);

//获取个人分数
Double score(K key, Object o);

4）、统计：

统计分数区间的人数，统计集合基数。

//统计分数区间的人数
Long count(K key, double min, double max);

//统计集合基数
Long zCard(K key);

以上就是redis中使用排行榜功能的一些例子，和对redis的操作方法了。redis不仅仅只是作为缓存，它更是数据库，提供了许多的功能，我们都可以好好的利用。

在这里我使用redis来实现了世界杯积分排行的展示，无论是在批量更新或是获取个人排行等方便，都有着很高效率，也降低了对数据库操作的压力，达到了很好的效果。

2、最新20条评论（利用list）

关注列表，粉丝列表，评论列表等都可以用Redis的list结构来实现。这里使用lpush和ltrim简单实现始终取最新评论的前20条。

//模拟从左边插入两条数据
redisTemplate.opsForList().leftPush("commons:id001","id为001的文章第1条评论");
redisTemplate.opsForList().leftPush("commons:id001","id为001的文章第2条评论");
//获取最新的一条数据（0-0区间）
List<String> range1 = redisTemplate.opsForList().range("commons:id001", 0, 0);
System.out.println(range1);

查看控制台：

list类型还可以用来其他操作：

 

3、计数器（限流）

如果要记录某个ip或用户的请求次数，限制一天请求次数不超过2次，超过则进行限制访问

实现：在redis中存相应用户的缓存，key为用户标示，value为访问次数，每次访问则利用incr自增1，每次访问都查看访问次数是否超过了2次，超过了则进行限流。

这里不做具体代码，就写几个命令代码说明下：

//缓存一个值
redisTemplate.opsForValue().set("bbb","100");
//该值加上100
redisTemplate.opsForValue().increment("bbb",100);
System.out.println(JSON.toJSONString(redisTemplate.opsForValue().get("bbb")));

最后输出为“200”。注意这里的key，value都是String类型，虽然用inc方法时String和int类型相加后为200，但200仍然是String类型。那为什么value也是String类型的呢？因为我们在之前注入的redisTemplate是注入了StringRedisTemplate，所以其key，value都是String类型，如果此时换成RedisTemplate类型，此时key为String，value则为object类型，即可进行正常的incr操作了。或者可以使用下面这种方式：将key设置为限流标识，value为用户标识，访问次数为score，对其修改则是对score值进行修改（上面有说到如何对score值进行修改）

也可以用分布式信号量实现

 

4、获取某段时间所有数据去重值

存进set即可

5、打卡签到

可以用hash、set，但为了节省空间可以用bitmap。当然也可以用mysql实现

6、session存储

    即springsession实现方案，在分布式系统中不同机器有不同session，此时要将session统一放在某个数据库中，此时就能实现分布式统一共享session，session共享可以将session放到redis、tomcat、mysql等中进行统一存储管理。这里将session内容存到redis中进行共享。

    springsession在一定程度上可以解决单点登陆问题，前提是所有系统是父子域名关系，因为利用cookie实现单点登陆的方案中，每个cookie都有一个对应的域，该域对应相应的域名。springsession中可以将cookie中token的访问域设置为父子域都可访问，则解决了单点登陆的问题。

这里就以简单的session获取存储为例进行说明springsession的实现

//官方案例：https://docs.spring.io/spring-session/docs/current/reference/html5/guides/boot-redis.html

1、依赖：

    <dependency>
		<groupId>org.springframework.session</groupId>
		<artifactId>spring-session-data-redis</artifactId>
	</dependency>

2、配置springsession相关配置：

这里也可以不写，后面用@EnableRedisHttpSession注解代替

#表示将session移交存储到redis
  session:
    store-type: redis

3、代码实现：

3.1、在启动类上添加@EnableRedisHttpSession注解，开启springsession功能。

@EnableRedisHttpSession
@SpringBootApplication
public class phbApplication {

    public static void main(String[] args) {

        SpringApplication.run(phbApplication.class,args);
    }
}

（注意这里如果要向redis存一些对象数据，该对象要实现序列化接口seri，因为向redis存数据是要进行序列化的，java对象默认是jdk序列化，所以要对象实现序列化接口）

3.2、完整代码实现：

@RestController
public class SessionDemo {


    @GetMapping("/session")
    public void sessionDemo(HttpServletRequest request, HttpServletResponse response){
        HttpSession session = request.getSession();
        session.setAttribute("sessionDemo",123123);
        System.out.println(session.getAttribute("sessionDemo"));

    }
}

8、好友关系

求交集

set类型中：

获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)

redisTemplate.opsForSet().union(key, otherKeys)

获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合求交集)

redisTemplate.opsForSet().intersect(key, otherKey)

 

10、bitmap的使用场景

1、打卡签到

2、统计活跃用户

3、用户在线状态

一般状态只存在两种情况时可用位图（bitmap），如签到只有签到和不签到两种状态。

用bitmap不用其他数据类型的比较：https://www.cnblogs.com/spareyaya/p/12806637.html

11、分布式锁

实现方式：

1、使用jedis/springdata-redis+lua实现

2、使用redisson实现（底层也是用lua脚本实现）

3、zookeeper实现

4、数据库

因为第一种方法要实现比较复杂，而redission为我们封装了一轮代码，直接为我们提供watchedog、分布式锁等实现机制，所以一般情况下redis的分布式锁的实现都是用redission实现比较简单。

redission实现redis的分布式锁：（redisson也实现了juc接口，所以使用基本和juc类似）

这里以redisson官方文档为主https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95

1、依赖：

 <!--redisson分布式锁-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.5.0</version>
        </dependency>

2、redisson配置（可以用程序配置，或者yml配置然后再加载）（如果依赖是sprinboot-data-redisson的包，则可直接在yml配置）这里使用程序配置

2.1、向容器注入redis的配置类MyRedisConfig

@Configuration
public class MyRedisConfig {
    /**
    * 所有操作都是通过redissonClient对象操作
    *
    * */
    @Bean(destroyMethod = "shutdown")//执行完后的销毁方法shutdown
    public RedissonClient redisson() throws Exception{

        //1、配置信息
        Config config = new Config();
        //集群配置
        config.useClusterServers()
                .addNodeAddress("redis://192.168.211.20:6379",
                                "redis://192.168.211.20:6380",
                                "redis://192.168.211.20:6381");
        //根据配置信息创建出redissonClient
        return Redisson.create(config);
    }

}

3、此时就可以直接来使用redisson

（官方文档：https://github.com/redisson/redisson/wiki/8.-%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81%E5%92%8C%E5%90%8C%E6%AD%A5%E5%99%A8）

基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

所有redisson的分布式锁和同步器的使用类似于juc锁的使用

这里基于Reentrant Lock和Semaphore进行举例

3.1、Reentrant Lock

@RestController
public class RedisLock {

    @Autowired
    RedissonClient redissonClient;

    @GetMapping("/lock")
    public void lock(){

        RLock lock = redissonClient.getLock("myLock");
       // 最常见的使用方法,阻塞式等待
        lock.lock();
        try {
            System.out.println("加锁成功，执行业务......."+Thread.currentThread().getId());
            Thread.sleep(30000);//模拟业务30秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
            System.out.println("释放锁...."+Thread.currentThread().getId());
        }

    }
}

此时在浏览器开启两个访问端口，都发送请求，此时只有68线程获取到锁，在30秒后释放锁，再被另一个请求获取到锁

此时除了这些方法还存在其方法，例如：

// 加锁以后10秒钟自动解锁
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);

//异步执行
lock.lockAsync();
lock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = lock.tryLockAsync(100, 10, TimeUnit.SECONDS);

3.2 Semaphore的使用举例

注意：一个信号量只能指定一次许可数量trySetPermits（再次使用无效），要表可以使用reducePermits/drainPermits/手动去redis修改相应的值

RSemaphore semaphore = redissonClient.getSemaphore("semaphore");
semaphore.trySetPermits(5);//设置有5个坑位（5个许可）
//加锁、获取一个坑位
semaphore.acquire(); 
//解锁
semaphore.release();

另外还有其他方法：

semaphore.acquireAsync();
semaphore.acquire(23);//获取23个坑位
semaphore.tryAcquire();
//或
semaphore.tryAcquireAsync();
semaphore.tryAcquire(23, TimeUnit.SECONDS);//获取一个坑位，等待时间为23秒
//或
semaphore.tryAcquireAsync(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
//或
semaphore.releaseAsync();

public interface RSemaphore extends RExpirable, RSemaphoreAsync {
 
    boolean trySetPermits(int var1);                     //设置permits数
    void reducePermits(int var1);                        //减少permit数
 
    void acquire() throws InterruptedException;          //获得一个permit
    void acquire(int var1) throws InterruptedException;  //获得var1个permits
 
    boolean tryAcquire();                                //尝试获得permit
    boolean tryAcquire(int var1);                        //尝试获得var1个permit
    boolean tryAcquire(long var1, TimeUnit var3) throws InterruptedException; //尝试获得permit，等待时间var1
    boolean tryAcquire(int var1, long var2, TimeUnit var4) throws InterruptedException;
                                                         //尝试获得var1个permit，等待时间var2
    void release();                                      //释放permit
    void release(int var1);                              //释放var1个permits
 
    int availablePermits();                              //信号量的permits数
    int drainPermits();                                  //清空permits
 
}

信号量可以用来实现限流操作(同时允许n个线程访问)

12、发布订阅功能

https://blog.csdn.net/wlddhj/article/details/107006035

https://zhuanlan.zhihu.com/p/59065399

由于没有消息持久化与 ACK 的保证，所以，Redis 的发布订阅功能并不可靠。这也就导致了它的应用场景很有限，建议用于实时与可靠性要求不高的场景。

13、抢号（不一定每人都有），抢红包模式

使用redisson实现分布式场景（因为获取到锁+减库存的全过程要求是原子操作的）

抢号：可以使用redisson的ReentrantLock锁，一个人获取到锁就减一个号

抢红包：也可以用分布式锁，指定抢红包人数，随机分成n份数额，一个人获取到锁就红包数减1并且拿走随机的一个金额。

14、延时队列

利用zset中有score的属性，以时间为score属性，这样zset会以时间前后进行排序，然后消费者再利用线程或者定时任务去查看当前时间大于哪个zset中的元素则拿出来消费。（不用遍历，大于就拿来消费即可）

15、布隆过滤器

主要用来解决redis的缓存穿透问题。

其中谷歌的guava则封装了布隆过滤器的实现，但那是把数据放在本地内存中，如果要将数据放在redis中，redis也有实现的一个布隆过滤器插件，需要去安装使用。

16、redis在高并发中的缓存穿透，缓存击穿，缓存雪崩实例解决

穿透：设null值/布隆过滤器

击穿、雪崩：均匀分布过期时间，限流，热数据，预加载等操作

具体实现后面再说