redis
1.redis介绍
Redis定义
Redis是C语言开发的一个开源的高性能键值对(key-value)数据库,可以用作数据库,缓存,消息中间件,他是一个种非关系型数据库。
特点
- 性能优秀,数据在内存中,读写速度非常快,支持10W的并发请求。
- 单进程单线程是线程安全的
- 丰富的数据类型,String,list,hash,set,zset
- 支持数据的持久化,可以将内存中的数据保存到磁盘中,重启时加载
- 主从复制,哨兵,高可用可以用作分布式锁,可以作为消息中间件使用,支持发布订阅。
2.redis安装
1.直接到https://github.com/MicrosoftArchive/redis/releases下载,我这里说一下解压版本的安装。
2.直接解压redis-xx.zip
3.进入目录,在redis.windows.conf中搜索requirepassword设置redis的认证密码。
4.在命令行进入redis的安装目录执行:redis-server.exe --service-install redis.windows.conf
5.在windows 服务中找到redis启动。
3.redis的数据类型
string(字符串)
string是redis最基本的类型,一个key对应一个value
string类型是二进制安全的,redis的string可以包含任何数据。
string类型最大能存储512MB
使用命令 set,get 就可以实现存储string
127.0.0.1:6379> set xpf "heixiaofei"
OK
127.0.0.1:6379> get xpf
"heixiaofei"
127.0.0.1:6379>
Hash(哈希)
Redis Hash 是一个键值(key=>value)对集合
Redis Hash 是一个string类型的field和value的映射表,hash适合用于存储对象
Redis存储hash使用,HMSET,HGET 命令,每个hash可以存储40多亿键值对
127.0.0.1:6379> del xpf
(integer) 1
127.0.0.1:6379> hmset xpf filed1 "xxxx" field2 "yyyy"
OK
127.0.0.1:6379> hget xpf field2
"yyyy"
127.0.0.1:6379> hget xpf filed1
"xxxx"
127.0.0.1:6379>
List<列表>
Redis列表是简单的字符串列表,按照插入顺序排序。
Redis 的列表最多可存储40多亿元素
127.0.0.1:6379> del xpf
(integer) 1
127.0.0.1:6379> lpush xpf redis
(integer) 1
127.0.0.1:6379> lpush xpf mongodb
(integer) 2
127.0.0.1:6379> lpush xpf rabbitMQ
(integer) 3
127.0.0.1:6379> lrange xpf 0 10
1) "rabbitMQ"
2) "mongodb"
3) "redis"
127.0.0.1:6379> lrange xpf 0 2
1) "rabbitMQ"
2) "mongodb"
3) "redis"
127.0.0.1:6379>
Set<集合>
Redis的Set是string类型的无序集合
集合是通过哈希表实现的,所以添加,删除,查找的复杂度都是o(1)
sadd命令,添加一个string元素到key对应的set集合中,成功返回1,存在返回0(集合内元素的唯一性)
127.0.0.1:6379> del xpf
(integer) 1
127.0.0.1:6379> sadd xpf redis
(integer) 1
127.0.0.1:6379> sadd xpf mongodb
(integer) 1
127.0.0.1:6379> sadd xpf rabbitMQ
(integer) 1
127.0.0.1:6379> sadd xpf redis
(integer) 0
127.0.0.1:6379> smembers xpf
1) "redis"
2) "rabbitMQ"
3) "mongodb"
127.0.0.1:6379>
zset(sorted set:有序集合)
Redis zset和set一样也是string类型元素的集合,且不允许重复的成员
每个元素都会关联一个double类型的分数,redis通过分数为集合中元素升序排列
zset中成员是唯一的,但分数(score)可以重复
zadd 命令
127.0.0.1:6379> del xpf
(integer) 1
127.0.0.1:6379> zadd xpf 4 redis
(integer) 1
127.0.0.1:6379> zadd xpf 3 mongodb
(integer) 1
127.0.0.1:6379> zadd xpf 2 rabbitMQ
(integer) 1
127.0.0.1:6379> zadd xpf 2 redis
(integer) 0
127.0.0.1:6379> zrangebyscore xpf 0 1000
1) "rabbitMQ"
2) "redis"
3) "mongodb"
127.0.0.1:6379> zadd xpf 6 redis
(integer) 0
127.0.0.1:6379> zrangebyscore xpf 0 1000
1) "rabbitMQ"
2) "mongodb"
3) "redis"
127.0.0.1:6379>
<!--从这里可以看出,当第二次加同一个元素时,返回的结果为0,但是score发生了改变。排序发生了变化 -->
4.Redis的发布订阅
Redis支持发布订阅的消息通信模式,发送者(pub)发送消息,订阅者(sub)接收消息
当有新消息通过PUBLISH命令发送给频道channel1时,这个消息就会被发送给它的三个客户端:
订阅 redisChat 频道
D:\developmentTools\redis\redis-3.2>redis-cli
127.0.0.1:6379> auth xykj.8387
OK
127.0.0.1:6379> subscribe redisChat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1
1) "message"
2) "redisChat"
给 RedisChat 频道推送消息
127.0.0.1:6379> publish redisChat "redis is a great caching technique"
(integer) 1
127.0.0.1:6379>
这个时候订阅消息的客户端就会接收到发送的消息。
3) "redis is a great caching technique"
5.redis的事务
一个事务从开始到执行会经历以下三个阶段:
- 开始事务。
- 命令入队。
- 执行事务。
127.0.0.1:6379> multi //开始事务
OK
127.0.0.1:6379> set a aaa //命令入队
QUEUED
127.0.0.1:6379> set b bbb //命令入队
QUEUED
127.0.0.1:6379> set c ccc //命令入队
QUEUED
127.0.0.1:6379> exec //执行事务
1) OK
2) OK
3) OK
127.0.0.1:6379>
单个redis命令执行时原子性的,但redis没有在事务上增加任何维持原子性的机制,所以redis事务的执行并不是原子性的。
批量指令并非原子化的操作,中间某条指令的失败不会导致前面的指令回滚,也不会导致后面的指令不执行。
6.redis数据备份与恢复
数据备份
redis SAVE 命令用于创建当前数据库的备份
127.0.0.1:6379> save
OK
该命令在redis的安装目录中创建dump.rdb文件
使用BGSAVE 命令也可以创建redis备份文件,在后台运行
127.0.0.1:6379> bgsave
Background saving started
127.0.0.1:6379>
数据恢复
将备份文件dump.rdb移动到redis安装目录并启动服务,获取redis目录使用 config get dir 命令
127.0.0.1:6379> config get dir
1) "dir"
2) "D:\\developmentTools\\redis\\redis-3.2"
7.SpringBoot 集成 redis
源码下载地址:
https://github.com/prettycharacter/boot_redis.git
1.创建项目
使用idea创建一个SpringBoot项目
File→new→project→Spring Initializr→next…
2.引入依赖
<!--加入redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
3.编写application.yml配置文件
# 增加redis的配置
spring:
redis:
#redis的数据库索引,默认为0
database: 0
#redis服务器地址
host: 127.0.0.1
#redis 服务器端口
port: 6379
password: xykj.8387
redis:
pool:
# 连接池最大连接数
max-active: 200
# 阻塞等待时间
max-wait: -1
#最大空闲连接
max-idle: 10
#最小空闲连接
min-idle: 10
# 连接超时时间
timeout: 1000
4.自定义一个redisTemplate
SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。但是,这个RedisTemplate的泛型是<Object,Object>,写代码不方便,需要写好多类型转换的代码;我们需要一个泛型为<String,Object>形式的RedisTemplate。
package xpf.learn.redis.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @author xpf
* @date 2020/5/26 11:45
*/
@Configuration
public class RedsiConfig {
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(factory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
jackson2JsonRedisSerializer.setObjectMapper(om);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用String的序列化方式
redisTemplate.setKeySerializer(stringRedisSerializer);
//hash的key也采用String的序列化方式
redisTemplate.setHashKeySerializer(stringRedisSerializer);
//value序列化采用jackson
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
//hash 的value序列化方式采用jackson
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}
5.编写redis工具类
package xpf.learn.redis.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* @author xpf
* @date // :
*/
@Component
public class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
//=============================common============================
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
//============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
//================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
//============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
//===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
6.写一个测试
package xpf.learn.redis;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import xpf.learn.redis.entity.User;
import xpf.learn.redis.util.RedisUtil;
import javax.annotation.Resource;
@SpringBootTest
class RedisApplicationTests {
@Resource
private RedisUtil redisUtil;
@Test
void testRedis() {
User user = new User();
user.setUserName("xpf");
user.setPassword("xpf6960585");
user.setType("管理员");
redisUtil.set("user", user);
}
}
测试结果:redis库中多个一个key为user的数据。
8.启动项目就加载缓存
1.编写初始化类
package xpf.learn.redis.init;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import xpf.learn.redis.service.InitService;
/**
*ApplicationRunner
* 在开发中可能会有这样的情景。需要在容器启动的时候执行一些内容。比如读取配置文件,数据库连接之类的。
* SpringBoot给我们提供了两个接口来帮助我们实现这种需求。这两个接口分别为CommandLineRunner和ApplicationRunner。
* 他们的执行时机为容器启动完成的时候。
*
*ApplicationListener 监听器
*当我们使用spring boot项目开发时候,碰到应用启动后做一些初始化操作,可以使用ApplicationListener。
* 比如:netty 随着应用启动完成后进行初始化、初始化定时任务
* @author xpf
* @date 2020/5/26 14:31
*/
@Component
public class init implements ApplicationRunner {
@Autowired
private InitService initService;
@Async
@Override
public void run(ApplicationArguments args) throws Exception {
initService.init();
}
}
2.初始化数据服务
package xpf.learn.redis.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.task.TaskExecutor;
import org.springframework.stereotype.Service;
import xpf.learn.redis.entity.User;
import xpf.learn.redis.util.RedisUtil;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
/**
* @author xpf
* @date 2020/5/26 15:05
*/
@Service
public class InitService {
Logger logger = LoggerFactory.getLogger(InitService.class);
@Resource
private RedisUtil redisUtil;
@Resource
private TaskExecutor taskExecutor;
public void init() {
logger.info("进入初始化缓存的方法+++++++++++++++++++++++++");
User xpf = new User();
xpf.setUserName("xpf");
xpf.setPassword("xpf696058");
xpf.setType("小神童");
redisUtil.set("xpf", xpf);
}