文章目录
一、什么是Redis
二、初始NoSQL
三、Redis命令
四、Redis数据结构介绍
五、Redis的Java客户端
Redis诞生于2009年,全称是Remote Dictionary Server,远程词典服务器,是一个开源、基于内存的键值型NoSQL数据库。
特征:
主要应用场景:
综上,Redis是一个性能极高的内存数据库,支持丰富的数据结构,提供持久化、事务等功能,非常适合缓存、消息队列等场景,被广泛应用于各种大型系统中。它的高性能、丰富功能使其成为非关系型数据库的重要选择之一。redis官网
关于Redis定义 有两个关键字:
其中键值型,是指Redis中存储的数据都是以key、value对的形式存储,而value的形式多种多样,可以是字符串、数值、甚至json:
而NoSql则是相对于传统关系型数据库而言,有很大差异的一种数据库。
传统关系型数据库是结构化数据,每一张表都有严格的约束信息:字段名、字段数据类型、字段约束等等信息,插入的数据必须遵守这些约束:
而NoSql则对数据库格式没有严格约束,往往形式松散,自由。
可以是键值型:
也可以是文档型:
甚至可以是图格式:
传统数据库的表与表之间往往存在关联,例如外键:
而非关系型数据库不存在关联关系,要维护关系要么靠代码中的业务逻辑,要么靠数据之间的耦合:
{
id: 1,
name: "张三",
orders: [
{
id: 1,
item: {
id: 10, title: "荣耀6", price: 4999
}
},
{
id: 2,
item: {
id: 20, title: "小米11", price: 3999
}
}
]
}
此处要维护“张三”的订单与商品“荣耀”和“小米11”的关系,不得不冗余的将这两个商品保存在张三的订单文档中,不够优雅。还是建议用业务来维护关联关系。
传统关系型数据库会基于Sql语句做查询,语法有统一标准;
而不同的非关系数据库查询语法差异极大,五花八门各种各样。
传统关系型数据库能满足事务ACID的原则。
而非关系型数据库往往不支持事务,或者不能严格保证ACID的特性,只能实现基本的一致性。
除了上述四点以外,在存储方式、扩展性、查询性能上关系型与非关系型也都有着显著差异,总结如下:
<!---->
#redis服务启动
#进入安装安装目录 使用配置文件的方式启动
cd /usr/local/src/redis/redis-7.0.4/ #先切换到安装目录下
redis-server redis.conf #使用配置文件的方式启动Redis
#或者直接在根目录下
/usr/local/src/redis/redis-7.0.4/redis-server /usr/local/src/redis/redis-7.0.4/redis.conf
#客户端连接redis服务
redis-cli -h host -p port
#若为本地redis,端口号为6379未修改 可直接使用redis-cli进行连接
redis-cli
#停止redis服务
# 法一 系统命令行,正常关闭、数据保存
redis-cli -a password shutdown
#法二 redis命令行 redis-cli连接redis服务后,在redis命令行输入shutdown
127.0.0.1:6379> shutdown
#法二 强制结束进程,断电、非正常关闭,容易数据丢失
ps -ef | grep redis-server
kill -9 redis_pid
Redis是典型的key-value数据库,key一般是字符串,而value包含很多不同的数据类型:
Redis为了方便我们学习,将操作不同数据类型的命令也做了分组,在官网( https://redis.io/commands )可以查看到不同的命令:
不同类型的命令称为一个group,我们也可以通过help命令来查看各种不同group的命令:
接下来,我们就学习常见的五种基本数据类型的相关命令。
#基础命令
ping #心跳命令,若看到PONG响应,说明客户端与Redis的连接正常
select 1 //切换数据库。切换到1号库:select 目标库下标。redis默认有16个库,下标从0开始,默认在0号库
dbsize #查看当前数据库大小,也就是key的数量(dbsize)
shutdown #关闭redis服务
quit 或exit #关闭当前连接
flushdb #清空当前库中所有数据
flushall #清空所有库中数据
#key相关操作命令
keys * #获取所有的键
keys pattern #查找所有符合给定模式(pattern)的key
set key value
get key
exists key #检查给定key是否存在
type key #返回key所存储的值的类型
del key1 key2 ... #该命令用于在key存在时删除key
unlink key #选择非阻塞删除,刚开始没有删除,后续才会删除;
move key db #将当前数据库的 key 移动到给定的数据库db当中
rename key newkey #修改 key 的名称;
expire key1 seconds #为key设置过期时间
ttl key #查看给定key的剩余生存时间(还有多久删除),以秒为单位。-2表示已经过期,-1表示永不过期
persist key #移除key的过期时间,key将持久保存
randomkey #从当前数据库中随机返回(不删除)一个key
通过help [command] 可以查看一个命令的具体用法,例如:
# 查看keys命令的帮助信息:
127.0.0.1:6379> help keys
KEYS pattern
summary: Find all keys matching the given pattern
since: 1.0.0
group: generic
见下第三小节。
Redis是一个key-value的数据库,key一般是String类型,不过value的类型多种多样:
String类型,也就是字符串类型,是Redis中最简单的存储类型。其value是字符串,不过根据字符串的格式不同,又可以分为3类:
不管是哪种格式,底层都是字节数组形式存储,只不过是编码方式不同。字符串类型的最大空间不能超过512MB,即value最大为512MB。
String的常见命令有:
127.0.0.1:6379> set wjName Jenny
OK
127.0.0.1:6379> get wjName
"Jenny"
127.0.0.1:6379> mset wjSchool WHCS wjLocation WuHan #一次性设置多个值
OK
127.0.0.1:6379> mget wjSchool wjName
1) "WHCS"
2) "Jenny"
127.0.0.1:6379> mset user:1:name Tom user:1:age 8
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "Tom"
2) "8"
127.0.0.1:6379> append wjName Happy #拼接key为name的值
(integer) 10
127.0.0.1:6379> get wjName
"JennyHappy"
127.0.0.1:6379> getrange wjName 0 4 #截取下标为0-4之间的字符串
"Jenny"
127.0.0.1:6379> setrange wjName 5 Day #从下标为5进行替换字符串
(integer) 10
127.0.0.1:6379> get wjName
"JennyDaypy"
127.0.0.1:6379>
127.0.0.1:6379> set wjAge 17
OK
127.0.0.1:6379> incr wjAge #设置key为wjAge的值加1
(integer) 18
127.0.0.1:6379> incr wjAge
(integer) 19
127.0.0.1:6379> decr wjAge #设置key为wjAge的值减1
(integer) 18
127.0.0.1:6379> incrby wjAge 5 #设置key为wjAge的值加5
(integer) 23
127.0.0.1:6379> decrby wjAge 2 #设置key为wjAge的值减2
(integer) 21
127.0.0.1:6379>
127.0.0.1:6379> setnx wjName Jen #如果不存在key为wjName的,值设置为redis;如果存在,则set失败
(integer) 0
127.0.0.1:6379> get wjName
"JennyDaypy"
127.0.0.1:6379> setex user:2:name 15 Jack #设置key为user:2:name的值为Jack,15s后过期
OK
127.0.0.1:6379> ttl user:2:name ##查看给定key的剩余生存时间
(integer) 11
127.0.0.1:6379>
Redis没有类似MySQL中的Table的概念,我们该如何区分不同类型的key呢?例如,需要存储用户、商品信息到redis,有一个用户id是1,有一个商品id恰好也是1,此时如果使用id作为key,那就会冲突了,该怎么办?
我们可以通过给key添加前缀加以区分,不过这个前缀不是随便加的,有一定的规范:
Redis的key允许有多个单词形成层级结构,多个单词之间用':'隔开,格式如下:
项目名:业务名:类型:id
这个格式并非固定,也可以根据自己的需求来删除或添加词条。这样一来,我们就可以把不同类型的数据区分开了,从而避免了key的冲突问题。例如我们的项目名称叫 jw,有user和product两种不同类型的数据,我们可以这样定义key:
如果Value是一个Java对象,例如一个User对象,则可以将对象序列化为JSON字符串后存储:
KEY | VALUE |
---|---|
jw:user:1 | {"id":1, "name": "Jack", "age": 21} |
jw:product:1 | {"id":1, "name": "小米11", "price": 4999} |
并且,在Redis的桌面客户端中,还会以相同前缀作为层级结构,让数据看起来层次分明,关系清晰:
Redis中的List类型与Java中的LinkedList类似,可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。特征也与LinkedList类似:
常用来存储一个有序数据,例如:朋友圈点赞列表,评论列表等。
List的常见命令有:
127.0.0.1:6379> lpush list1 18 20 Jenny #向列表左侧插入一个或多个元素
(integer) 3
127.0.0.1:6379> lpush list1 Happy
(integer) 4
127.0.0.1:6379> lrange list1 0 2 #返回一段角标范围内的所有元素
1) "Happy"
2) "Jenny"
3) "20"
127.0.0.1:6379> rpush list1 Jack Health 16 #向列表右侧插入一个或多个元素
(integer) 7
127.0.0.1:6379> lrange list1 0 -1 #通过区间获取具体的值
1) "Happy"
2) "Jenny"
3) "20"
4) "18"
5) "Jack"
6) "Health"
7) "16"
127.0.0.1:6379> lpop list1 #移除list的第一个元素:Happy
"Happy"
127.0.0.1:6379> rpop list1 #移除list的最后一个元素:16
"16"
127.0.0.1:6379> lindex list1 2 #通过下标获得list当中的某一个值
"18"
127.0.0.1:6379> llen list1 #获取list的长度
(integer) 5
127.0.0.1:6379> rpush list1 18 Jack
(integer) 7
127.0.0.1:6379> lrange list1 0 -1
1) "Jenny"
2) "20"
3) "18"
4) "Jack"
5) "Health"
6) "18"
7) "Jack"
127.0.0.1:6379> lrem list1 2 Jack #移除list集合指定个数的value,移除2个值为Jack的,精确匹配
(integer) 2
127.0.0.1:6379> lrange list1 0 -1
1) "Jenny"
2) "20"
3) "18"
4) "Health"
5) "18"
127.0.0.1:6379> ltrim list1 3 4 #截取list集合中下标为3到下标为4之间的元素集合,并覆盖原来的list集合
OK
127.0.0.1:6379> lrange list1 0 -1
1) "Health"
2) "18"
127.0.0.1:6379> lset list 1 17
(error) ERR no such key
127.0.0.1:6379> lset list1 1 17 #更新list集合当中下标为1的值为17,如果下标1的值不存在,则报错
OK
127.0.0.1:6379> linsert list1 AFTER Health 20 #将某个具体的值插入到某一个具体元素(默认第一个)的前面或者后面
(integer) 3
127.0.0.1:6379> linsert list1 BEFORE Health Jenny
(integer) 4
127.0.0.1:6379> lrange list1 0 -1
1) "Jenny"
2) "Health"
3) "20"
4) "17"
Redis的Set结构与Java中的HashSet类似,可以看做是一个value为null的HashMap。因为也是一个hash表,因此具备与HashSet类似的特征:
功能与list类似,但是可以自动排除重复数据。它是string类型的无序集合,底层是一个value为null的hash表。因此添加、删除、查找复杂度为O(1)。可以看作Java里面的hashset和C++里面的unordered_set。
Set的常见命令有:
例如两个集合:s1和s2:
求交集:SINTER s1 s2;求s1与s2的不同:SDIFF s1 s2
127.0.0.1:6379> sadd set1 Jenny 18 WuHan 20 #往set1集合中添加多个元素
(integer) 4
127.0.0.1:6379> smembers set1 #查看set1集合中所有元素
1) "20"
2) "WuHan"
3) "18"
4) "Jenny"
127.0.0.1:6379> sismember set1 WuHan #查看set1集合中是否存在某元素
(integer) 1
127.0.0.1:6379> srandmember set1 #随机抽取出1个元素
"20"
127.0.0.1:6379> srandmember set1 2 #随机抽取出2个元素
1) "18"
2) "WuHan"
127.0.0.1:6379> spop set1 #随机删除set1集合中某个元素
"Jenny"
127.0.0.1:6379> smove set1 set2 20 #移动set1集合中的world元素到set2集合中
(integer) 1
127.0.0.1:6379> sadd set2 20 Jenny WuHan
(integer) 2
127.0.0.1:6379> smembers set2
1) "20"
2) "WuHan"
3) "Jenny"
127.0.0.1:6379> smembers set1
1) "WuHan"
2) "18"
127.0.0.1:6379> sdiff set1 set2 #作set1集合减去set2集合的差集
1) "18"
127.0.0.1:6379> sinter set1 set2 #set1和set2的交集
1) "WuHan"
127.0.0.1:6379> sunion set1 set2 #set1和set2作并集并去重
1) "20"
2) "Jenny"
3) "18"
4) "WuHan"
127.0.0.1:6379>
Redis的Hash类型也叫散列,是一种键值对集合,其value是一个无序字典,类似于Python 的字典、Java中的HashMap结构。
String结构是将对象序列化为JSON字符串后存储,当需要修改对象某个字段时很不方便:
KEY | VALUE |
---|---|
jw:user:1 | {name:"Jack", age:21} |
jw:product:1 | {name:"Rose", age:18} |
Hash结构可以将对象中的每个字段独立存储,可以针对单个字段做CRUD:
Redis-Hash 类型的一些主要特性:
Redis-Hash应用场景:
Redis 的 Hash 类型是一种键值对集合,适合用于存储对象,因此在很多场景下都有着广泛的应用。以下是一些常见的应用场景:
Hash类型的常见命令有
127.0.0.1:6379> hset hash1 username Jack #往hash1集合中存放键值对数据
(integer) 1
127.0.0.1:6379> hmset hash1 age 18 place WuHan #同时往hash1集合中添加多个值
OK
127.0.0.1:6379> hget hash1 place #从hash1集合中获取数据
"WuHan"
127.0.0.1:6379> hmget hash1 username age #同时往hash1集合中获取多个值
1) "Jack"
2) "18"
127.0.0.1:6379> hgetall hash1 #获取hash1集合中所有的键值对
1) "username"
2) "Jack"
3) "age"
4) "18"
5) "place"
6) "WuHan"
127.0.0.1:6379> hdel hash1 username #删除hash1集合中指定的key字段
(integer) 1
127.0.0.1:6379> hlen hash1 #获取hash1集合的长度
(integer) 2
127.0.0.1:6379> hexists hash1 username #判断hash集合中指定字段是否存在
(integer) 0
127.0.0.1:6379> hgetall hash1
1) "age"
2) "18"
3) "place"
4) "WuHan"
127.0.0.1:6379> hkeys hash1 #获取hash集合中所有的key
1) "age"
2) "place"
127.0.0.1:6379> hvals hash1 #获取hash集合中所有的值
1) "18"
2) "WuHan"
127.0.0.1:6379> hincrby hash1 age 3 #指定hash集合中指定增量
(integer) 21
127.0.0.1:6379> hsetnx hash1 age 9 #如果不存在则直接设置值,存在则设置失败
(integer) 0
Redis的ZSet是一个可排序的set集合,与Java中的TreeSet有些类似,但底层数据结构却差别很大。ZSet中的每一个元素都带有一个score属性,可以基于score属性对元素排序,底层的实现是一个跳表(SkipList)加 hash表。注意,集合成员是唯一的,但是评分可以重复。
ZSet具备下列特性:
因为ZSet的可排序特性,经常被用来实现排行榜这样的功能。
ZSet常见命令:
ZSet的常见命令有:
注意:所有的排名默认都是升序,如果要降序则在命令的Z后面添加REV即可,例如:
127.0.0.1:6379> zadd zset1 1 first 2 second 3 third 4 four #往zset添中加一个或多个元素
(integer) 4
127.0.0.1:6379> zrange zset1 0 -1 #返回有序集合中、下标在<start> <end>之间的元素(有 WITHSCORES 会显示评分)。0 -1 表示所有元素
1) "first"
2) "second"
3) "third"
4) "four"
127.0.0.1:6379> zrevrange zset1 0 -1
1) "four"
2) "third"
3) "second"
4) "first"
127.0.0.1:6379> zscore zset1 third #获取zset中的third元素的score值
"3"
127.0.0.1:6379> zrank zset1 third #返回third在集合中的排名,从0开始
(integer) 2
127.0.0.1:6379> zrevrank zset1 third
(integer) 1
127.0.0.1:6379> zrangebyscore zset1 -inf +inf #给zset集合中的元素从小到大排序,-inf:负无穷,+inf:正无穷。返回score值介于-inf到+inf之间(含两端)的成员(score从小到大)
1) "first"
2) "second"
3) "third"
4) "four"
127.0.0.1:6379> zrangebyscore zset1 -inf +inf withscores #从小到大排序并输出键值
1) "first"
2) "1"
3) "second"
4) "2"
5) "third"
6) "3"
7) "four"
8) "4"
127.0.0.1:6379> zrangebyscore zset1 -inf 1 withscores #指定负无穷到1的范围
1) "first"
2) "1"
127.0.0.1:6379> zrem zset1 four #移除zset集合中指定的元素
(integer) 1
127.0.0.1:6379> zcard zset1 #查看zset集合中元素个数
(integer) 3
127.0.0.1:6379> zrangebyscore zset1 1 2 withscores #根据score值从小到大排列
1) "first"
2) "1"
3) "second"
4) "2"
127.0.0.1:6379> zrevrangebyscore zset1 2 1 withscores #根据score值从大到小排列
1) "second"
2) "2"
3) "first"
4) "1"
127.0.0.1:6379> zcount zset1 1 2 #统计score值在1到2之间的元素个数
(integer) 2
在Redis官网中提供了各种语言的客户端,地址:https://redis.io/docs/clients/
其中Java客户端也包含很多:
标记为*的就是推荐使用的java客户端,包括:
Jedis使用的基本步骤:1)引入依赖;2)创建Jedis对象,建立连接;3)使用Jedis,方法名与Redis命令一致;4)释放资源。具体步骤可查阅官网。
Jedis连接池
Jedis本身是线程不安全的,并且频繁的创建和销毁连接会有性能损耗,因此我们推荐大家使用Jedis连接池代替Jedis的直连方式。
public class JedisConnectionFactory {
private static final JedisPool jedisPool;
static {
// 配置连接池
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
// 最大连接
jedisPoolConfig.setMaxTotal(8);
// 最大空闲连接
jedisPoolConfig.setMaxIdle(8);
// 最小空闲连接
jedisPoolConfig.setMinIdle(0);
// 设置最长等待时间, ms
jedisPoolConfig.setMaxWaitMillis(200);
// 创建连接池对象,参数:连接池配置、服务端ip、服务端端口、超时时间、密码
jedisPool = new JedisPool(jedisPoolConfig, "192.168.150.101", 6379, 1000, "123321");
}
// 获取Jedis对象
public static Jedis getJedis(){
return jedisPool.getResource();
}
}
SpringData是Spring中数据操作的模块,包含对各种数据库的集成,其中对Redis的集成模块就叫做SpringDataRedis,官网地址:https://spring.io/projects/spring-data-redis
SpringDataRedis中提供了RedisTemplate工具类,其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中:
API | 返回值类型 | 说明 |
---|---|---|
redisTemplate.opsForValue() | ValueOperations | 操作String类型数据 |
redisTemplate.opsForHash() | HashOperations | 操作Hash类型数据 |
redisTemplate.opsForList() | ListOperations | 操作List类型数据 |
redisTemplate.opsForSet() | SetOperations | 操作Set类型数据 |
redisTemplate.opsForZSet() | ZSetOperations | 操作SortedSet类型数据 |
redisTemplate | 通用的命令 |
SpringDataRedis的使用步骤:1)引入spring-boot-starter-data-redis依赖;2)在application.yml配置Redis信息;3)注入RedisTemplate
RedisTemplate可以接收任意Object作为值写入Redis:
只不过写入前会把Object序列化为字节形式,默认是采用JDK序列化,得到的结果是这样的:
缺点:
我们可以自定义RedisTemplate的序列化方式,代码如下:
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
// 创建RedisTemplate对象
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 设置连接工厂
template.setConnectionFactory(connectionFactory);
// 创建JSON序列化工具
GenericJackson2JsonRedisSerializer jsonRedisSerializer =
new GenericJackson2JsonRedisSerializer();
// 设置Key的序列化
template.setKeySerializer(RedisSerializer.string());
template.setHashKeySerializer(RedisSerializer.string());
// 设置Value的序列化
template.setValueSerializer(jsonRedisSerializer);
template.setHashValueSerializer(jsonRedisSerializer);
// 返回
return template;
}
}
这里采用了JSON序列化来代替默认的JDK序列化方式。最终结果如图:
整体可读性有了很大提升,并且能将Java对象自动的序列化为JSON字符串,并且查询时能自动把JSON反序列化为Java对象。不过,其中记录了序列化时对应的class名称,目的是为了查询时实现自动反序列化。这会带来额外的内存开销。
为了节省内存空间,我们可以不使用JSON序列化器来处理value,而是统一使用String序列化器,要求只能存储String类型的key和value。当需要存储Java对象时,手动完成对象的序列化和反序列化。
因为存入和读取时的序列化及反序列化都是我们自己实现的,SpringDataRedis就不会将class信息写入Redis了。
这种用法比较普遍,因此SpringDataRedis就提供了RedisTemplate的子类:StringRedisTemplate,它的key和value的序列化方式默认就是String方式。
省去了我们自定义RedisTemplate的序列化方式的步骤,而是直接使用:
@Autowired
private StringRedisTemplate stringRedisTemplate;
// JSON序列化工具
private static final ObjectMapper mapper = new ObjectMapper();
@Test
void testSaveUser() throws JsonProcessingException {
// 创建对象
User user = new User("虎哥", 21);
// 手动序列化
String json = mapper.writeValueAsString(user);
// 写入数据
stringRedisTemplate.opsForValue().set("user:200", json);
// 获取数据
String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
// 手动反序列化
User user1 = mapper.readValue(jsonUser, User.class);
System.out.println("user1 = " + user1);
}
RedisTemplate的两种序列化实践方案:
参考黑马程序员相关视频与笔记
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。