初始Redis
认识NoSQL
非关系型数据库
与SQL的对比
- 结构
- 关系
在SQL中表与表之间可能会通过一定的关系关联起来,在NoSQL中每一条数据没有关联
- 查询
在NoSQL中查询语句没有固定的语法,每一个不同的库都有不同语法
- 事务
SQL都有事务的ACID性;但是NoSQL可能没有事务或者就算有事务可能也只能满足事务的基本一致性
认识Redis
Redis诞生于2009年,是一个基于内存的键值对型NoSQL数据库
特征:
- 键值型,value支持多种不同数据结构,功能丰富
- 单线程,每个命令具备原子性
- 低延迟,速度快(基于内存、IO多路复用、良好的编码)
- 支持数据的持久化
- 支持主从集群、分片集群
Redis常见命令
5种常见数据结构
通用命令
// 添加键值对
MSET [k1 v1 k2 v2]
// 查看符合模板的所有KEY,不建议在生产环境设备上使用
KEYS [pattern]
// 删除所选的key,可以删除多个
DEL [key...]
// 查看对应键是否存在
EXISTS [key]
// 给一个key设置有效期,有效期到时key会被自动删除
EXPIRE [key seconds]
// 查看key还有多少有效期
TTL [key]
不同数据结构的操作命令
- String
- string:普通字符串
- int:整数类型,可以做自增、自减操作
- float:浮点类型,可以做自增、自减操作
SET:添加或者修改已存在的一个String类型的键值对
GET:根据key获得String类型的value
MSET:批量添加多个String类型的键值对
MGET:批量获得多个String类型的value
INCR:让一个整型的key自增1
INCRBY:让一个整型的key自增指定步长,列如:incrby num 2 让num值自增2
INCRBYFLOAT:让一个浮点类型的数字自增并指定步长
SETNX:添加一个String类型的键值对,前提是该key不存在,存在则不执行
SETEX:添加一个String类型的键值对,并且指定有效期
key的结构
- Hash类型
HSET key field value:添加或者修改hash类型的field的值
HGET key field:获取一个hash类型key的field的值
HDEL key field:删除指定hash类型的field字段
HMSET:批量添加多个hash类型key的field的值
HMGET:批量获取多个hash类型key的field的值
HGETALL:获取一个hash类型的key中的所有的field和value
HKEYS:获取一个hash类型的key中的所有的field
HVALS:获取一个hash类型的key中的所有的value
HINCRBY:让一个hash类型key的字段值自增并指定步长
HSETNX:添加一个hash类型的key的field值,前提是这个field不存在,否则不执行
- List类型
LPUSH key element...:向列表左侧插入一个或多个元素
LPOP key:移除并返回列表左侧的第一个元素,没有返回nil
RPUSH key element...:向链表右侧插入一个或多个元素
RPOP key:移除并返回列表右侧的第一个元素,没有返回nil
LRANGE key star ned:返回一段角标范围内的所有元素(包含左和右)
BLPOP和BRPOP:与LPOP和RPOP类似,只不过在没有元素等待指定时间,而不是直接返回nil
- Set
// 单个set操作
SADD key member...:向set中添加一个或多个元素
SREM key member...:移除set中指定元素
SCARD key:返回set中元素的个数
SISMEMBER key member:判断一个元素是否存在于set中
SMEMERS key:获取set中的所有元素
// 多个set操作
SINTER key1 key2...:求key1与key2的交集
SDIFF key1 key2...:求key1与key2的差集
SUNION key1 key2...:求key1和key2的并集
- SortedSet
ZADD key score member:添加一个或多个到sorted set,如果已经存在则更新score值
ZREM key member:删除sorted set中的一个指定元素
ZSCORE key member:获取sorted set中的指定元素的score值
ZRANK key member:获取sorted set中指定元素的排名
ZCARD key:获取sorted set中的元素个数
ZCOUNT key min max:统计score值在给定范围内的所有元素的个数
ZINCRBY key increment member:让sorted set中的指定元素自增,步长为指定的increment值
ZRANGE key min max:按照score排序后,获取指定排名范围内的元素
ZRANGERBYSCORE key min max:按照score排序后,获取指定score范围内的元素
ZDIFF、ZINTER、ZUNION:求差集、交集、并集
注意:所有的排名默认都是升序,如果要降序则在命令的Z后面添加REV即可
Redis的Java客户端
Jedis客户端
Jedis基本用法
- 创建一个maven项目,pom.xml导入依赖
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.3.1</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.9.2</version>
<scope>test</scope>
</dependency>
</dependencies>
- 创建测试类
- 建立连接
@Resource
private Jedis jedis;
@BeforeEach
public void init(){
jedis = new Jedis("127.0.0.1",6379);
// jedis.auth(password); 有密码要认证密码
// 选择库
jedis.select(0);
}
- 测试String类型
@Test
public void testString(){
jedis.set("name","希诚");
System.out.println(jedis.get("name"));
}
- 测试Hash类
@Test
public void testHash(){
jedis.hset("nameSet","name","希诚");
jedis.hset("nameSet","age","20");
Map<String, String> nameSet = jedis.hgetAll("nameSet");
System.out.println(nameSet);
}
- 最后不要忘记关闭连接
@AfterEach
public void close(){
if (jedis != null) {
jedis.close();
}
}
Jedis连接池
创建一个JedisConnectionFactory
package com.xc.jedis.util;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalUnit;
/**
* @author xc
* @date 2023/4/9 10:53
*/
public class JedisConnectionFactory {
private final static JedisPool jedisPool;
static {
// 配置连接池
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
// 设置最大连接数
jedisPoolConfig.setMaxTotal(8);
// 设置最大空闲连接
jedisPoolConfig.setMaxIdle(8);
// 设置最小空闲连接
jedisPoolConfig.setMinIdle(0);
// 设置等待时长,没有连接时,等待多少时间直到等到空闲连接,否则报错
jedisPoolConfig.setMaxWait(Duration.of(1000, ChronoUnit.MILLENNIA));
// 创建连接对象
jedisPool = new JedisPool(jedisPoolConfig,"127.0.0.1",6379,1000);
}
public static Jedis getJedis() {
return jedisPool.getResource();
}
}
到测试类中测试
@Test
public void testJedisPool(){
Jedis jedisByPool = JedisConnectionFactory.getJedis();
jedisByPool.set("xcxc","666");
System.out.println(jedisByPool.get("xcxc"));
}
SpringDataRedis客户端
基本操作
- 创建一个springboot项目并导入依赖
<!-- redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 连接池依赖-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
- 在application.yml文件中配置我们需要的redis和连接池的信息
spring:
redis:
host: localhost
port: 6379
password:
lettuce:
pool:
max-active: 8 #最大连接
max-idle: 8 #最大空闲连接
min-idle: 0 #最小空间连接
max-wait: 100 #最长等待时间
- 编写测试类
@Resource
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
redisTemplate.opsForValue().set("name","希诚");
System.out.println(redisTemplate.opsForValue().get("name"));
}
以序列化的形式存储
SpringDateRedis的序列化方式
缺点:
- 可读性差
- 内存占用较大
怎么解决:
- redis配置类
package com.xc.springdateredisdemo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;
/**
* @author xc
* @date 2023/4/9 11:45
*/
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
// 创建redis对象
RedisTemplate<String,Object> template = new RedisTemplate<>();
// 设置连接工厂
template.setConnectionFactory(redisConnectionFactory);
// 创建JSON序列化工具
GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
// 设置Key的序列化
template.setKeySerializer(RedisSerializer.string());
template.setHashKeySerializer(RedisSerializer.string());
// 设置Value序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashValueSerializer(jackson2JsonRedisSerializer);
return template;
}
}
- 测试
@Resource
private RedisTemplate<String,Object> redisTemplate;
@Test
void contextLoads() {
redisTemplate.opsForValue().set("name","希诚");
System.out.println(redisTemplate.opsForValue().get("name"));
}
发现没有序列化
随便创建一个对象类再测试
user对象
@Data
public class User{
private String name;
private int age;
public User(){}
public User(String name, int age) {
this.name = name;
this.age = age;
}
}
测试
@Test
void testUser() {
redisTemplate.opsForValue().set("user:100",new User("希诚",20));
System.out.println(redisTemplate.opsForValue().get("user:100"));
}
会发现每次都存了一个@class,占用内存
使用stringRedisTemplate
@Resource
private StringRedisTemplate stringRedisTemplate;
@Test
void testString() {
stringRedisTemplate.opsForValue().set("gender","男");
System.out.println(stringRedisTemplate.opsForValue().get("gender"));
}
@Test
void testUser() {
User user = new User("希诚66",20);
// 每次需要自己手动序列化和反序列化(用自己熟悉的序列化工具)
Gson gson = new Gson();
String json = gson.toJson(user);
stringRedisTemplate.opsForValue().set("user:200",json);
String s = stringRedisTemplate.opsForValue().get("user:200");
User user1 = gson.fromJson(s, User.class);
System.out.println(user1);
}
结果