一、Redis介绍
1.1 引言
我们的项目就是这样的，客户端访问服务器，服务器访问数据库。如果访问量过大，那么服务器可能就承受不住了，此时可以增加多台服务器，即服务器集群，但是数据库的压力大（数据库基于SQL从磁盘中通过IO获取和存放数据），这时轻则导致查询效率低，重则直接服务器崩溃。怎么办呢？这时候就要用到Redis。此外，有了多台服务器后，客户端的访问通过服务器集群的时候，不知道该访问哪一台服务器。比如此时通过上面的服务器进行登录（上面服务器保存了Session），但是下次从下面服务器去请求，却没有session，此时数据不同步，登录失败。还有锁的问题，如果上面保存了锁，下面也可以再保存另外一个锁，因为两个锁是根据各自服务器中的对象创建的，此时不具有互斥性，这样也会出现问题。
总结：
- 由于用户增大，请求数量也随之增大，数据压力过大。
- 堕胎服务器之间，数据不同步。
- 多台服务器之间的锁，已经不存在互斥性了。
此时我们的Redis就上场了，他可以完美解决上面的三个问题：
- Redis是基于内存存储和读取数据的，而非硬盘IO，这样效率增加；
- 有了Redis，可以将共享数据(如Seeesion)保存在Redis中。Redis只有一个，数据就不存在不共享了；
- 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"]
我的我的单位的我的