Redis 入门

最新推荐文章于 2024-07-02 18:54:07 发布

freellf

最新推荐文章于 2024-07-02 18:54:07 发布

阅读量229

点赞数

分类专栏： Redis DB 文章标签： Redis

本文链接：https://blog.csdn.net/freellf/article/details/113666380

版权

DB 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

Redis

1 篇文章 0 订阅

订阅专栏

一.Redis介绍

1.1 引言

1.由于用户量增大，请求数量也随之增大，数据压力过大

2.多台服务器之间，数据不同步

3.多台服务器之间的锁，已经不存在互斥性了。

1.2 NoSQL

Redis就是一款NoSQL

NoSQL -> 非关系型数据库 -> Not only SQL

1. key-Value：Redis ...

2. 文档型: ElasticSearch, Solr, Mongodb

3. 面向列: Hbase, Cassandra

4. 图形化: Neo4j

除了关系型数据库都是非关系型数据库

NoSQL只是一种概念，泛指非关系型数据库，和关系型数据库做一个区分。

1.3Redis介绍

redis 的作者，叫Salvatore Sanfilippo，来自意大利，

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，它支持存储的value类型包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

redis的官网地址是redis.io。

Redis提供了多种持久化机制，性能可以达到110000/s读取数据以及81000/s写入数据，Redis还提供了主从，哨兵以及集群的搭建方式，可以更方便的横向扩展以及垂直扩展。

二Redis安装

2.1安装

 version: '3.1'
 services: 
    redis: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 6379:6379

其二：

version: '2'
services:
   redis:
      image: daocloud.io/library/redis:5.0.7
      container_name: redis
      restart: always
      ports:
        - 6379:6379
      environment: 
        - TIME_ZONE=Asia/Shanghai

创建 docker-redis目录，切换到此目录下，创建docker-compose.yml文档,将上面的配置信息填入，

运行 docker-compose up -d.

docker images 查看镜像

docker ps 查看运行

2.2 使用redis-cli连接Redis

进去Redis容器的内部

docker exec -it 容器id bash

在容器内部，使用 redis-cli连接

2.3 使用图形化界面连接Redis

下载地址：https://github.com/lework/RedisDesktopManager-Windows/releases/download/2020.4/redis-desktop-manager-2020.4.zip

三.Redis常用命令

3.1 Redis 存储数据的结构

常用的5种数据结构

key-string: 一个Key对应一个值
key-hash: 一个Key对应一个Map
key-list：一个Key对应一个列表
key-set: 一个Key对应一个集合
key-zset: 一个key对应一个有序的集合

另外三种数据结构：
HyperLogLog：计算近似值
GEO: 地理位置
BIT：一般存储的也是一个字符串，存储的是一个Byte[]

五种常用的存储数据结构

key-string: 最常用的，一般用于存储一个值

key-hash: 存储一个对象数据的

key-set: 交集，差集和并集的操作

key-zset: 排行榜，积分存储等操作

3.2 String常用命令

#1. 添加值
set key value

#2.取值
get key

#3.批量操作
mset key value []key value...]
mget key [key...]

#4 自增命令(自增1)
incr key

#5 自减命令(自减1)
decr key
#6 自增或自减指定数量
incrby key increment
decrby key increment

#7 设置值的同，指定生存时间(每次向Redis中添加数据时，尽量都设置生存时间)
setex key second value

#8 设置值，如果当前Key不存在的话(如果这个key存在， 什么事都不做，如果这个key不存在，和set命令一样)
setnx key value

#9.对key对应的value后，追加内容
append key value

#10.查看value字符串的长度
strlen key

命令参考文档

Redis 命令参考 — Redis 命令参考

3.3 hash常用命令

#1 存储数据
hset key field value

#2 获取数据
hget key field

#3 批量操作
hmset key field value [field value...]
hmset key field [field...]

#4. 自增(指定自增的值)
hincrby key field increment

#5. 设置值(如果key-field不存在，那么就正常添加， 如果存在，什么事都不做)
hsetnx key field value

#6. 检查field是否存在
hexists key field

#7. 删除key对应的field, 可以删除多个
hdel key field [field...]

#8. 获取当前hash结构中和field和value
hgetall key

#9. 获取当前hash结构中的全部field
hkeys key

#10. 获取当前hash结构中的全部value
hvals key

#11. 获取当前hash结构中field的数量
hlen key

3.4 list常用命令

#1. 存储数据(从左侧插入数据, 从右侧插入数据)
lpush key value [value...]
rpush key value [value...]

#2. 存储数据(如果key不存在，什么事都不做，如果key存在，但是不是list结构，什么都不做)
lpushx key value
rpushx key value

#3. 存储数据(在存储数据时，指定好你的索引位置, 覆盖之前索引位置的数据，index超出整 个列表的长度，也会失败)
lset key index value

#4. 弹栈方式获取数据(左侧弹出数据，从右侧弹出数据)
lpop key
rpop key

#5. 获取指定索引范围的数据(start从0开始， stop输入-1, 代表最后一个， -2代表倒数第二个)
lrang key start stop

#6. 获取指定索引位置的数据
lindex key index

#7.获取整个列表的长度
llen key

#8. 删除列表中的数据(他是删除当前列表中的count个value值，count>0从左侧向右侧删除，count<0从右侧向左侧删除，count==0删除列表中的全部的value)
lrem key count value

#9. 保留列表中的数据(保留你指定索引范围内的数据，超过整个索引范围被移除掉)
ltrim key start stop

#10. 将一个列表中最后的一个数据，插入到另外一个列表的头部位置
rpoplpush list1  list2

3.5 set常用命令

#1.存储数据
sadd key member [member...]

#2.获取数据(获取全部数据)
smembers key

#3.随机获取一个数据(获取的同时，移除数据，count默认为1， 代表弹出数据的数量)
spop key [count]

#4.交集(取多个set集合的交集)
sinter set1 set2 ...

#5.并集(获取全部集合中的数据)
sunion set1 set...

#6.差集(获取多个集合中不一样的数据)
sdiff set1 set2 ...

#7.删除数据
srem key member [member...]

#8.查看当前的set集合中是否包含这个值
sismember key member

3.6 zset常用命令

#1. 添加数据(score必须是数值， member不允许重复的)
zadd key score member [score member...]

#2. 修改member的分数(如果member是存在key中的，正常增加分数，如果member不存在，这个命今就相当于zadd)
zincrby key increment member

#3.查看指定member的分数
zscore key member

#4. 获取zset中的数据的数量
zcard key

#5.根据score的范围查询member数量
zcount key min max

#6. 删除zset中的成员
zrem key member [member...]

#7.根据分数从小到大排序， 获取指定范围的数据(withscores如果添加这个参数，那么会返回member对应的分数)
zrange key start stop [withscores]

#8.根据分数从大到小排序，获取指定范围内的数据(withscores如果添加这个参数，那么会返回member对应的分数)
zrevrange key start stop [withscores]

#9. 根据分数的返回去获取member(withscore代表同时返回score, 添加limit,就和MySql中一样, 如果不希望等于min或max的值被查询出来可以采用'(分数'相当于<但是不等于的方式，最大值和最小值使用+inf和-inf来标识)
zrangebyscore key min max [withscores] [limit offset count]

#10. 根据分数的返回去获取member(withscore代表同时返回score, 添加limit,就和MySql中一样)
zrangebyscore key max min [withscores] [limit offset count]

3.7 key常用命令

#1.查看Redis中全部的key(pattern: *, xxx*, *xxx)
keys pattern

#2.查看某一个key是否存在(1 - key存在， 0 - key不存在)
exists key

#3 删除key
del key [key...]

#4 设置key的生存时间，单位为秒， 单位为毫秒，设置还能活多久
expire key second
pexpire  key milliseconds

#5.设置key的生存时间，单位为秒，单位为毫秒，设置能活到什么时间点
expireat key timstamp
pexpireat key milliseconds

#6.查看key的剩余生存时间，单位为秒，单位为毫秒(-2-当前key没有设置生存时间，具体剩余的生存时间)
ttl key
pttl key

#7.移除key的生存时间（1-移除成功，0-key不存在生存时间, key不存在)
persist key

#8. 选择操作的库
select 0~15

#9.移动key到另外一个库中
move key db

3.8 库的常用命令

#1.清空当前所在的数据库
flushdb

#2.清空所有的数据库
flushall

#3.查看当前数据库中有多少个key
dbsize

#4.查看最后一次操作的时间
lastsave

#5.实时监控Redis服务接收到的目录
monitor

四.Java连接Redis

jedis连接Redis, lettuce连接Redis。

4.1 jedis连接Redis

1.创建maven项目

2.导入需要的依赖

<dependencies>
    <!--     1.Jedis-->
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>

    <!--     2.Junit测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--     3.Lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.20</version>
    </dependency>
</dependencies>

3.测试

@Test()
public void test(){
    //1.连接Redis
    Jedis jedis = new Jedis("118.178.254.138", 6379);

    //2.操作Redis - 因为Redis的命令是什么, Jedis的方法就是什么
    jedis.select(2);
    jedis.set("name", "李四");
    //3.释放资源
    jedis.close();
}

@Test
public void get(){
    //1.连接Redis
    Jedis jedis = new Jedis("118.178.254.138", 6379);

    //2.操作Redis - 因为Redis的命令是什么, Jedis的方法就是什么
    jedis.select(2);
    String value = jedis.get("name");
    System.out.println(value);

    //3.释放资源
    jedis.close();
}

4.2 Jedis存储一个对象到Redis以byte[]的形式

准备一个User实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {

    private Integer id;

    private String name;

    private Date birthDay;
}

导入spring-context依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.18.RELEASE</version>
</dependency>

创建Demo测试类，编写内容

@Test
public void setByteArray(){
    //1、连接Redis服务
    Jedis jedis = new Jedis("118.178.254.138", 6379);
    jedis.select(3);
    //2.1 准备key(String) - value(User)
    String key = "user";
    User user = new User(1, "张三", new Date());
    //2.2 将key和value转换为byte[]
    byte[] keys = SerializationUtils.serialize(key);
    byte[] values = SerializationUtils.serialize(user);
    //2.3 将key和value存储到 Redis
    jedis.set(keys, values);

    //3. 释放资源
    jedis.close();
}

@Test
public void getByteArray(){
    //1、连接Redis服务
    Jedis jedis = new Jedis("118.178.254.138", 6379);
    jedis.select(3);

    //2.1 准备key(String) - value(User)
    String key = "user";

    //2.2 将key和byte[]
    byte[] keys = SerializationUtils.serialize(key);
    //2.3 用key从Redis取出value
    byte[] values = jedis.get(keys);
    //2.3 将value反序列化为User对象
    User user = (User)SerializationUtils.deserialize(values);

    System.out.println("user: " + user);
    //3. 释放资源
    jedis.close();
}

4.3 jedis存储一个对象到Redis以String的形式

导入依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

测试

 //存储对象 - 以String形式存储
    @Test
    public void setString(){
        //1. 连接Redis
        Jedis jedis = new Jedis("118.178.254.138", 6379);
        //2.1 准备Key(String) - value(User)
        String stringKey = "stringUser";
        //2.2 使用fastJSON将value转化为json字符串
        User value = new User(2, "李四", new Date());
        String stringValue = JSON.toJSONString(value);
        //2.3 存储到Redis中
        jedis.set(stringKey, stringValue);
        //3.释放资源
        jedis.close();
    }

    @Test
    public void getString(){
        //1. 连接Redis
        Jedis jedis = new Jedis("118.178.254.138", 6379);
        //2.1 准备Key(String) - value(User)
        String stringKey = "stringUser";
        //2.2 从Redis获取查询value
        String stringValue = jedis.get(stringKey);

        //2.3 将value反序化为User
        User user = JSON.parseObject(stringValue, User.class);
        System.out.println("user: " + user);
        //3.释放资源
        jedis.close();
    }

4.4 Jedis连接池的操作

public void pool2(){
    //1.创建连接池的配置信息
    GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
    poolConfig.setMaxTotal(100);      //连接池中最大的活跃数
    poolConfig.setMaxIdle(10);       //最大的空闲数
    poolConfig.setMinIdle(5);       //最小的空闲数
    poolConfig.setMaxWaitMillis(3000);  //当连接池空了之后，多久没获取到Jedis对象，就超时
    //2.创建连接池
    JedisPool pool = new JedisPool(poolConfig, "118.178.254.138", 6379);
    //3.通过连接池获取jedis对象
    Jedis jedis = pool.getResource();
    //4.操作
    String value = jedis.get("stringUser");
    System.out.println(value);
    //5.释放资源
    jedis.close();
}

4.5Redis的管道操作

因为在操作Redis的时候，执行一个命令需要先发送请求到Redis服务器，这个过程需要经历网络的延迟，Redis还需要给客户端一个响应。

如果我需要一次性执行很多个命令，上述的方式效率很低，可以通过Redis的管道，先将命令放到客户端的一个Pipeline中，之后一次性的将全部命令都发生到Redist服务，Redis服务一次性的将全部的返回结果响应给客户端。

public void pipeline(){
    //1.创建连接池
    JedisPool pool = new JedisPool("118.178.254.138", 6379);
//        long startTime = System.currentTimeMillis();
//        //2.获取一个连接对象
//        Jedis jedis = pool.getResource();
//        //3.执行incr - 100000次
//        for (int i = 0; i < 100000; i++){
//            jedis.incr("age");
//        }
//        //4.释放资源
//        jedis.close();
//
//        System.out.println(System.currentTimeMillis() - startTime);
    //======================================================
    //2.获取一个连接对象
    long pipelineTime = System.currentTimeMillis();
    Jedis pipelineJedis = pool.getResource();
    //3.创建管道
    Pipeline pipeline = pipelineJedis.pipelined();
    //4.执行incr - 100000次放到管道中
    for (int i = 0; i < 100000; i++){
        pipeline.incr("age");
    }
    //5.执行命令
    pipeline.syncAndReturnAll();
    //6.释放资源
    pipelineJedis.close();
    System.out.println(System.currentTimeMillis() - pipelineTime);
}

五.Redis其他配置及集群

修改yml文件，以方便后期修改Redis配置信息

version: '3.1'
services:
    redis:
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 6379:6379
      volumes: 
         - ./conf/redis.conf:/usr/local/redis/redis.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]

5.1 Redis的AUTH

方式一：通过修改Redis的配置文档，实现Redis的密码校验

# redis.conf
requirepass 密码

三种客户端的连接方式：

redis-cli: 在输入正常命令之前，先输入auth密码即可。
图形化界面：在连接Redis的信息中添加上验证的密码

Jedis客户端

第一种：jedis.auth(password)

第二种：

public JedisPool(GenericObjectPoolConfig poolConfig, String host, int port, int timeout, String password)

方式二：在不修改redis.conf文件的前提下，在第一次链Redis时，输入命令: config set requirepass 密码后续再次操作redis时，需要先auto做一下校验。

5.2Redis的事务

Redis的事务：一次事务操作，该成功的成功，该失败的失败

先开启事务，执行一些列的命令，但是命令不会立即执行，会被放在一个队列中，如果你执行事务，那么这个队列中的命令全部执行，如果取消了事务，一个队列中的命令全部作废。

开启事务： multi
输入要执行的命令：被放入到一个队列中
执行事务：exec
取消事务：discard

Redis的事务向发挥功能，需要配置watch监听机制

在开启事务之前，先通过watch命令去监听一个或多个key, 在开启事务之后，如果有其他客户端修改了监听的key,事务会自动取消.

如果执行了事务，或者取消了事务，watch监听自动消除，一般不需要手动执行unwatch.

5.3 Redis执久化机制

RDB是Redis默认的持久化机制

1.RDB持久化文件，速度比较快，而且存储的是一个二进制的文件，传输起来很方便

2.RDB持久化的时机：

save 900 1： 在900秒内，有1个key改变了，就执行RDB持久化。
save 300 10： 在300秒内，有10个key改变了，就执行RDB持久化。
save 60 10000:  在60秒内，有10000个key改变了，就执行RDB持久化

3.RDB无法保证数据的绝对安全.

AOF持久化机制默认是关闭，Redis官方推荐同时开启RDB和AOF持久化，更安全，避免数据丢失。

1.AOF持久化的速度，相对RDB较慢，存储的是一个文本文件，到了后期文件会比较大，传输困难。

2.AOF持久化时机。

appendfsync always：每执行一个写操作，立即持久化到AOF文件中，性能比较低。

appendfsync everysec：每秒执行一次持久化。

appendfsync no：会根据操作系统不同，环境不同，在一定时间内执行一次持久化。

3.AOF相对RDB更安全，推荐同时开启AOF和RDB。

同时开启RDB和AOF注意事项:

如果同时开启AOF和RDB持久化，那么在Redis宕机重启之后，需要加载一个持久化文件，优先选择AOF文件。

如果先开启了RDB，再次开启AOF，如果RDB执行了持久化，那么RDB文件中的内容会被AOF覆盖掉。

5.4 Redis的主从架构

单机版Redis存在读写瓶颈的问题

 version: "3.1"
 services: 
    redis1: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis1
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7001:6379
      volumes: 
         - ./conf/redis1.conf:/usr/local/redis/redis.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis2: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis2
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7002:6379
      volumes: 
         - ./conf/redis2.conf:/usr/local/redis/redis.conf
      links: 
         - redis1:master
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis3: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis3
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7003:6379
      volumes: 
         - ./conf/redis3.conf:/usr/local/redis/redis.conf
      links: 
         - redis1:master
      command: ["redis-server", "/usr/local/redis/redis.conf"]

# 从节点配置
replicaof master 6379   #容器的节点配置

5.5哨兵

哨兵可以帮助我们解决主从架构中的单点故障问题

修改以下docker-compose.yml, 为了可以在容器内部使用哨兵的配置

version: "3.1"
services:
    redis1:
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis1
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7001:6379
      volumes:
         - ./conf/redis1.conf:/usr/local/redis/redis.conf
         - ./conf/sentinel1.conf:/data/sentinel.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis2:
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis2
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7002:6379
      volumes:
         - ./conf/redis2.conf:/usr/local/redis/redis.conf
         - ./conf/sentinel2.conf:/data/sentinel.conf
      links:
         - redis1:master
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis3:
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis3
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7003:6379
      volumes:
         - ./conf/redis3.conf:/usr/local/redis/redis.conf
         - ./conf/sentinel3.conf:/data/sentinel.conf
      links:
         - redis1:master
      command: ["redis-server", "/usr/local/redis/redis.conf"]

准备哨兵的配置文件，并且在容器内部手动启动哨兵即可。

# 哨兵需要后台启动
daemonize  yes
# 指定Master节点的ip和端口(主)
sentinel monitor master localhost 6379 2
# 指定Master节点的ip和端口(从)
sentinel monitor master master 6379 2
# 哨兵每隔多久监听一次redis架构
sentinel down-after-milliseconds master 10000

在Redis容器内部启动sentinel即可

redis-sentinel sentinel.conf

5.6Redis集群的架构图

# docker-compose.yml
version: "3.1"
services: 
    redis1: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis1
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7001:7001
         - 17001:17001
      volumes:
         - ./conf/redis1.conf:/usr/local/redis/redis.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis2: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis2
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7002:7002
         - 17002:17002
      volumes:
         - ./conf/redis2.conf:/usr/local/redis/redis.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis3: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis3
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7003:7003
         - 17003:17003
      volumes:
         - ./conf/redis3.conf:/usr/local/redis/redis.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis4: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis4
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7004:7004
         - 17004:17004
      volumes:
         - ./conf/redis1.conf:/usr/local/redis/redis.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis5: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis1
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7005:7005
         - 17005:17005
      volumes:
         - ./conf/redis5.conf:/usr/local/redis/redis.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]
    redis6: 
      image: daocloud.io/library/redis:5.0.7
      restart: always
      container_name: redis1
      environment:
         - TZ=Asia/Shanghai
      ports:
         - 7006:7006
         - 17006:17006
      volumes:
         - ./conf/redis6.conf:/usr/local/redis/redis.conf
      command: ["redis-server", "/usr/local/redis/redis.conf"]

# redis.conf
# 指定redis的端口号
port 7001
# 开启Redis集群
cluster-enabled yes
# 集群信息的文件
cluster-config-file node-7001.conf
# 集群的对外ip地址
cluster-announce-ip 118.178.254.138
# 集群的对外port
cluster-announce-port 7001
# 集群的总线端口
cluster-announce-bus-port 17001

启动了6个Redis节点

随便跳转到一个容器内部，使用redis-cli管理集群

docker stop $(docker ps -qa)
docker rm $(docker ps -qa)

redis-cli --cluster create 118.178.254.138:7001 118.178.254.138:7002 118.178.254.138:7003 118.178.254.138:7004 118.178.254.138:7005 118.178.254.138:7006 --cluster-replicas 1

redis-cli -h 118.178.254.138 -p 7001 -c

5.7 Java连接Redis集群

使用jedisCluster对象连接Redis集群

 @Test
    public void test(){
        //创建Set<HostAndPort> nodes
        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(new HostAndPort("118.178.254.138", 7001));
        nodes.add(new HostAndPort("118.178.254.138", 7002));
        nodes.add(new HostAndPort("118.178.254.138", 7003));
        nodes.add(new HostAndPort("118.178.254.138", 7004));
        nodes.add(new HostAndPort("118.178.254.138", 7005));
        nodes.add(new HostAndPort("118.178.254.138", 7006));

       //创建JedisCluster对象
        JedisCluster jedisCluster = new JedisCluster(nodes);
        //操作
        String value = jedisCluster.get("a");
        System.out.println(value);
    }

六.Redis常见问题

6.1 key的生存时间到了，Redis会立即删除吗？

不会立即删除。

1.定期删除

Redis每隔一段时间就去会查看redis设置了过期时间的key,会再100ms的间隔中默认查看3个key。

2.惰性删除

如果当你去查询一个已经过了生存时间的key时，Redis会先查看当前key的生存时间，是否已经到了，直接删除当前key, 并且给用户返回一个空值。

6.2Redis的淘汰机制

在Redis内存已经满的时候，添加一个新的数据，执行淘汰机制

volatile-lru: 在内存不足时，Redis会在设置过了生存时间的key中干掉一个最近最少使用的key
allkeys-lru:在内存不足时，在全部的key中干掉一个最近最少使用的key
volatile=lfu: 在内存不足时，Redis会在设置了生存时间的key中干掉一个最近最少频次使用的key
allkeys-lfu:在内存不足时，redis会在全部的key中干掉一个最近最少频次使用的key.
volatile-random: 在内存不足时，Redis会在设置了生存时间的key中随机干掉一个key.
allkeys-random:在内存不足时，redis会在全部的key中随机干掉一个key.
volatile-ttl:在内存不足时，Redis会在设置了生存时间的key中干掉剩余生存时间最少的key
noeviction:(默认) 当内存不足时，直接报错

指定淘汰机制的方式： maxmemory-policy 具体策略

设置Redis的最大内存： maxmemory 字节大少

6.3 缓存穿透

6.4 缓存击穿

6.5 缓存雪崩

6.6缓存倾斜

freellf

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
Redis 入门

目录一.Redis介绍二Redis安装三.Redis常用命令四.Java连接Redis五.Redis其他配置及集群六.Redis常见问题一.Redis介绍1.1 引言1.由于用户量增大，请求数量也随之增大，数据压力过大2.多台服务器之间，数据不同步3.多台服务器之间的锁，已经不存在互斥性了。 1.2 NoSQLRedis就是一款NoSQLNoSQL -> 非关系型数据库 -> Not only SQL1. key-Va...
复制链接

扫一扫