4.6 Redis

一、Redis介绍

1.1 引言

 我们的项目就是这样的，客户端访问服务器，服务器访问数据库。如果访问量过大，那么服务器可能就承受不住了，此时可以增加多台服务器，即服务器集群，但是数据库的压力大（数据库基于SQL从磁盘中通过IO获取和存放数据），这时轻则导致查询效率低，重则直接服务器崩溃。怎么办呢？这时候就要用到Redis。此外，有了多台服务器后，客户端的访问通过服务器集群的时候，不知道该访问哪一台服务器。比如此时通过上面的服务器进行登录（上面服务器保存了Session），但是下次从下面服务器去请求，却没有session，此时数据不同步，登录失败。还有锁的问题，如果上面保存了锁，下面也可以再保存另外一个锁，因为两个锁是根据各自服务器中的对象创建的，此时不具有互斥性，这样也会出现问题。

总结：

1. 由于用户增大，请求数量也随之增大，数据压力过大。
2. 堕胎服务器之间，数据不同步。
3. 多台服务器之间的锁，已经不存在互斥性了。

此时我们的Redis就上场了，他可以完美解决上面的三个问题：

1. Redis是基于内存存储和读取数据的，而非硬盘IO，这样效率增加；
2. 有了Redis，可以将共享数据(如Seeesion)保存在Redis中。Redis只有一个，数据就不存在不共享了；
3. Redis是基于单线程的，因此就不存在锁的问题。

 1.2 Redis介绍

Redis就是一款NoSQL。

NoSQL->非关系型数据库->Not Only SQL.有如下类别：

• key-Value:Redis.....
• 文档型：ElasticSearch，Solr，Mongodb...
• 面向列：Hbase，Cassandra...
• 图形化：Neo4j...

除了关系型数据库都是非关系型数据库。这句话像是废话，其实不是的。我们知道关系型数据库是由表和表之间的关系构成的数据库。如MySQL，非关系型数据库是除了关系型数据库之外的所有数据库，他可能有表，甚至可能没有表，没有绝对的概念。上面的四类也是大家划分的。

NoSQL只是一种概念，泛指非关系型数据库，和关系型数据库做一个区分。关系型数据库是说表与表之间存在关系，而非关系型数据是说表与表之间没有关系，甚至说有些关系型数据库不存在表。

1.3 Redis介绍

作者介绍：

• 有一位意大利人，在开发一款LLOOGG的统计页面，因为MySQL的性能不好，自己研发了一款非关系型数据库，并命名为Redis。作者是Salvatore。
• Redis(Remote Dictionary Server)即远程字典服务，Redis是由C语言去编写，Redis是一款基于key-Value的NoSQL，而且Redis是基于内存存储数据的(缺陷，断点宕机)，Redis还提供了多种持久化机制（放置断电数据丢失），性能可以达到110000/s读取数据以及81000/s写入数据，Redis还提供了主从，哨兵以及集群的搭建方式，可以更方便的横向扩展以及垂直扩展。

二、Redis安装

2.1 安装Redis 

Docker-Compose安装

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

 

2.2 使用Redix-cli连接Redis 

连接Redis的三种方式：Redis自己提供了客户端连接的命令，或者说脚本；其次是用一些图形化界面连接；最后才会用java去连接。

进入容器的内部

docker exec -it 容器id bash

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

2.3 使用图形化界面连接Redis

但是呢？这种访问没有页面，非常的不清晰，因此我们下载一个图形化界面。

下载地址：看下图；然后傻瓜式安装。

登录github->搜索Redis-Desktop->Manage->找到Windows版本的安装包->在安装使用的地方点击releases去下载->选择一个下载->安装，傻瓜式安装

 安装后，用图形化界面连接。连接后可以看到Redis默认的16个数据库，我们刚才默认使用的是0号库，点开就可以看到name。

 

三、Redis常用命令

在讲述Redis常用命令之前，先讲述下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-list：使用list结构实现栈和队列结构。

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中添加数据时，尽量都设置上生存时间)  --  由于Redis是存放在内存中的，内存资源紧缺。因此每次设值最好设置时间，如果实在不能设置，则不设置。
setex key second value

#8. 设置值，如果当前key不存在的话(如果这个key存在，什么事都不做，如果这个key不存在，和set命令一样)  --  这个命令会在学习Redis分布式锁的时候用到
setnx key value

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

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

3.3 hash常用命令

#1. 存储数据
hset key field value

# 2. 获取数据
hget key field

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

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

#5. 设置值(如果key-value不存在，那么就正常添加，如果存在，什么事都不做)
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代表倒数第二个)
lrange 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. 并集(获取全部集合中的数据)

#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(withscores代表同时返回score，添加limit，就和MySQL中一样，如果不希望等于min或者max的值被查询出来可以采用 '(分数' 相当于 < 但是不等于的方式，最大值和最小值使用+inf和-inf来标识)
zrangebyscore key min max [withscores] [limit offset count]

#10. 根据分数的返回去获取member(withscores代表同时返回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 timestamp
pexpireat key milliseconds

#6. 查看key的剩余生存时间，单位为秒，单位为毫秒(-2 - 当前key不存在，-1 - 当前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

 对于最后一个监控命令，要想看到效果，可以再开一个窗口，然后连接redis。这样每个操作，就会实时的在这个窗口中显示。

四、Java连接Redis

用Java连接Redis有两种客户端，一种是Jedis、一种是Lettuce。我们是使用Jedis，因为其更加简单（Redis的命令是什么，Jedis的方法就是什么）。

4.1 Jedis连接Redis-以byte[]的形式

 1.创建maven项目

2.导入需要的依赖

需要三个依赖（其实只需要一个）：Jedis依赖，这个不必说；junit为了方便测试；lombok这个是方便创建对象。

3.测试

package com.qf;

import org.junit.Test;
import redis.clients.jedis.Jedis;

public class Demo1
{
    @Test
    public void set() {
        // 1. 连接Redis
        Jedis jedis = new Jedis("1.15.122.141", 6379);
        // 2. 操作Redis - 因为Redis的命令是什么，Jedis的方法就是什么
        jedis.set("name", "李四");
        // 3. 释放资源
        jedis.close();
    }

    @Test
    public void get() {
        // 1. 连接Redis
        Jedis jedis = new Jedis("1.15.122.141", 6379);
        // 2. 操作Redis - 因为Redis的命令是什么，Jedis的方法就是什么
        String name = jedis.get("name");
        System.out.println(name);
        // 3. 释放资源
        jedis.close();
    }
}

4.2 Jedis如何存储一个对象到Redis

准备一个User实体类(实现Serializable接口是为了可以序列化)

package com.qf.entity;

import java.io.Serializable;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable
{
    private Integer id;

    private String name;

    private Date birthday;
}

导入spring-context依赖(这个依赖是为了借助Sprin的功能----实体对象和byte[]数组之间的转化)

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

创建Demo测试类，编写内容

package com.qf;

import com.qf.entity.User;
import java.util.Date;
import org.junit.Test;
import org.springframework.util.SerializationUtils;
import redis.clients.jedis.Jedis;

public class Demo2
{
    // 存储对象 - 以直接数组的形式
    @Test
    public void setByteArray() {
        // 1. 连接Redis服务
        Jedis jedis = new Jedis("1.15.122.141", 6379);
        // ------------------------------------------------------------
        // 2.1 准备key(String) - value(User)
        String key = "user";
        User value = new User(1,"zhangsan",new Date());
        // 2.2 将key和value转换为byte[]
        byte[] byteKey = SerializationUtils.serialize(key);
        byte[] byteValue = SerializationUtils.serialize(value);
        // 2.3 将key和value存储到Redis
        jedis.set(byteKey, byteValue);
        // ------------------------------------------------------------
        // 3. 释放资源
        jedis.close();
    }

    // 获取对象 - 以byte[]形式在Redis中获取
    @Test
    public void getByteArray() {
        // 1. 连接Redis服务
        Jedis jedis = new Jedis("1.15.122.141", 6379);
        // ------------------------------------------------------------
        // 2.1 准备key
        String key = "user";
        // 2.2 将key转换为byte[]
        byte[] byteKey = SerializationUtils.serialize(key);
        // 2.3 jedis去Redis中获取value
        byte[] value = jedis.get(byteKey);
        //2.4 将value反序列化为User对象
        User user = (User) SerializationUtils.deserialize(value);
        // 2.5 输出
        System.out.println("user:" + user);
        // ------------------------------------------------------------
        // 3. 释放资源
        jedis.close();
    }
}

4.3 Jedis存储一个对象到Redis-以string的形式

1.导入依赖(fastJson方便对象和字符串之间的转化)

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

 2. 测试

package com.qf.entity;

import com.alibaba.fastjson.JSON;
import java.util.Date;
import org.junit.Test;
import org.springframework.util.SerializationUtils;
import redis.clients.jedis.Jedis;

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

    // 获取对象 - 以String形式在Redis中获取
    @Test
    public void getByteArray() {
        // 1. 连接Redis服务
        Jedis jedis = new Jedis("1.15.122.141", 6379);
        // ------------------------------------------------------------
        // 2.1 准备一个key
        String key = "stringUser";
        // 2.2 去Redis中查询value
        String value = jedis.get(key);
        // 2.3 将value反序列化为User
        User user = JSON.parseObject(value, User.class);
        // 2.4 输出
        System.out.println("user:" + user);
        // ------------------------------------------------------------
        // 3. 释放资源
        jedis.close();
    }
}

 对于上面存储对象的两种方式：到底选哪种？如果你本来就是json字符串，用第二种自然最好；如果本来是对象，则两种方法都可以。

4.4 Jedis连接池的操作

上面我们操作一次Jedis就要先创建一次，然后再销毁，这样频繁地创建和销毁对象非常消耗资源。使用连接池操作Redis，避免频繁创建和销毁链接对象消耗资源。

package com.qf;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class Demo4
{
    // 简单方式创建连接池   -- 这个连接池没有配置信息
    @Test
    public void pool() {
        // 1. 创建连接池
        JedisPool pool = new JedisPool("1.15.122.141", 6379);

        // 2. 通过连接池获取jedis对象
        Jedis jedis = pool.getResource();

        // 3. 操作
        String value = jedis.get("stringUser");
        System.out.println("user:" + value);

        // 4. 释放资源  --- 不过这个释放资源时将上面获得的jedis对象还给连接池
        jedis.close();
    }

    @Test
    public void pool2() {
        // 1. 创建连接池配置信息
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(100);  // 连接池中最大的活跃数
        poolConfig.setMaxIdle(10);  // 最大空闲数
        poolConfig.setMaxWaitMillis(3000);  // 当连接池空了之后，多久没获取到Jedis对象，就超时

        // 2. 创建连接池
        JedisPool pool = new JedisPool(poolConfig, "1.15.122.141", 6379);

        // 3. 通过连接池获取jedis对象
        Jedis jedis = pool.getResource();

        // 4. 操作
        String value = jedis.get("stringUser");
        System.out.println("user:" + value);

        // 5. 释放资源  --- 不过这个释放资源时将上面获得的jedis对象还给连接池
        jedis.close();
    }
}

4.5 Redis的管道操作

正常情况下，如果发送3个命令，则过程如下图所示：所消耗的资源是巨大的，要经过三次网络延迟和三次发送和相应。但是如果采用管道操作，则这个过程会变成一次，时间消耗大量减小。

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

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

// Redis管道的操作
@Test
public void pipeline() {
    // 1. 创建连接池
    JedisPool pool = new JedisPool("1.15.122.141", 6379);
    long l = System.currentTimeMillis();

    /*// 2. 获取一个连接对象
    Jedis jedis = pool.getResource();

    // 3. 执行incr - 100000次
    for (int i = 0; i < 100000; i++)
    {
        jedis.incr("pp");
    }

    // 4. 释放资源
    jedis.close();   // 耗时 39903*/

    // ============================
    // 2. 获取一个连接对象
    Jedis jedis = pool.getResource();
    // 3. 创建管道
    Pipeline pipelined = jedis.pipelined();
    // 3. 执行incr - 100000次放到管道中
    for (int i = 0; i < 100000; i++)
    {
        pipelined.incr("qq");
    }
    // 4. 执行命令
    pipelined.syncAndReturnAll();
    // 5. 释放资源
    jedis.close();
    
    System.out.println(System.currentTimeMillis() - l);  // 耗时 14156 时间消耗更少
}

五、Redis其它配置及集群

为了学习Redis的其它配置和集群安装，咱们要先将以前的docker-compose.yml文件修改一下。

原有docker-compose.yml文件

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

创建一个文件，用于映射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"]

然后，先docker-compose down，再docker-compose up -d.

5.1 Redis的AUTH

很显然，现在操作Redis不需要密码认证，这个是很不安全的。为了更安全，可以用这个AUTH配置密码，实现安全登录。

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

操作如下：(其实restart就可以，不一定非要关闭和重启)

 配置文件内容如下：

# Redis的AUTH密码
requirepass xxxx

三种客户端链接方式

1.redis-cli：再输入正常密码之前，先输入auth 密码即可。

然后再次进入容器操作：发现正常可以登录redis-cli，但是无法设置值。此时要用auth xxxx。

2. 图形化界面：在链接Redis的信息中添加验证的密码。 

此时用RDM链接也是需要密码的。(我自己设置后，密码没有生效。不知道为什么)

3.Jedis客户端

第一种：jedis.auth(password);这种方式的话，没有用连接池，每次创建和销毁消耗资源。

那Java代码怎么操作呢？

@Test
public void set() {
    // 1. 连接Redis
    Jedis jedis = new Jedis("1.15.122.141", 6379);
    jedis.auth("xxxx")
    // 2. 操作Redis - 因为Redis的命令是什么，Jedis的方法就是什么
    jedis.set("name", "李四");
    // 3. 释放资源
    jedis.close();
}

第二种：连接池

这样就链接上了，但是对于连接池怎么办呢？

@Test
public void poolForAuth() {
    // 1. 创建连接池配置信息
    GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
    poolConfig.setMaxTotal(100);  // 连接池中最大的活跃数
    poolConfig.setMaxIdle(10);  // 最大空闲数
    poolConfig.setMaxWaitMillis(3000);  // 当连接池空了之后，多久没获取到Jedis对象，就超时

    // 2. 创建连接池
    JedisPool pool = new JedisPool(poolConfig, "1.15.122.141", 6379, 3000, "xxxx");

    // 3. 通过连接池获取jedis对象
    Jedis jedis = pool.getResource();

    // 4. 操作
    String value = jedis.get("stringUser");
    System.out.println("user:" + value);

    // 5. 释放资源  --- 不过这个释放资源时将上面获得的jedis对象还给连接池
    jedis.close();
}

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

还有第二种设置密码的方式：

先把刚刚配置文件中的requirepass xxxx注释掉。然后正常链接redis，此时是可以设置内容的。但是此时我们可以用一个命令操作，就可以设置密码，下面再曹祖oredis就要密码了。不过这种方式呢？当redis重启后就失效了。因此更推荐第一种方式。

# Redis的AUTH密码
#requirepass xxxx
# RDB持久化机制的配置
# 代表RDB执行的时机
# 9000秒之内，有一个key改变了，就执行RDB持久化，后面两个都是类似意思
save 900 1
save 300 10
save 60 10000
# 开启RDB持久化的压缩
rdbcompression yes
# RDB持久化文件的名称
dbfilename redis.rdb

修改yml文件：将RDB的内容映射出来，方便后续查看和修改。

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
      - ./data:/data
    command: ["redis-server","/usr/local/redis/redis.conf"]

我的我的单位的我的