Hefery 的个人网站

Hefery's Personal Website

Contact：hefery@126.com
  menu
73 文章
0 浏览
0 当前访客
ღゝ◡╹)ノ❤️
/    

SpringBoot使用Redis

RedisConnection

RedisConnection 主要处理与 Redis 的通信。
使用 RedisConnection，则需要在调用方法时，处理序列化和反序列化问题

RedisTemplate

RedisTemplate简介

使用RedisTemplate

引入 spring-boot-starter-data-redis 依赖：引入 jedis 和 spring-data-redis 两个与 redis 核心的包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

注入Bean

@Autowired
public RedisTemplate redisTemplate;

依赖配置

  redis:
    database: 0
    host: 192.168.153.129
    port: 6379
    # password:
    # 连接超时时间
    timeout: 10000

RedisTemplate操作

redisTemplate.opsForValue();　　//操作字符串
redisTemplate.opsForHash();　　 //操作hash
redisTemplate.opsForList();　　 //操作list
redisTemplate.opsForSet();　　  //操作set
redisTemplate.opsForZSet();　 　//操作有序set

String

// 判断是否有key所对应的值，有则返回true，没有则返回false
redisTemplate.hasKey(key)

// 有则取出key值所对应的值
redisTemplate.opsForValue().get(key)

// 删除单个key值
redisTemplate.delete(key)

// 批量删除key
redisTemplate.delete(keys) //其中keys:Collection<K> keys

// 将当前传入的key值序列化为byte[]类型
redisTemplate.dump(key)

// 设置过期时间
public Boolean expire(String key, long timeout, TimeUnit unit) {
    return redisTemplate.expire(key, timeout, unit);
 }

 public Boolean expireAt(String key, Date date) {
    return redisTemplate.expireAt(key, date);
 }

// 查找匹配的key值，返回一个Set集合类型
public Set<String> getPatternKey(String pattern) {
    return redisTemplate.keys(pattern);
}

// 修改redis中key的名称
 public void renameKey(String oldKey, String newKey) {
    redisTemplate.rename(oldKey, newKey);
}
 
// 返回传入key所存储的值的类型
public DataType getKeyType(String key) {
    return redisTemplate.type(key);
} 

// 如果旧值存在时，将旧值改为新值
public Boolean renameOldKeyIfAbsent(String oldKey, String newKey) {
    return redisTemplate.renameIfAbsent(oldKey, newKey);
}

// 从redis中随机取出一个key
redisTemplate.randomKey()

// 返回当前key所对应的剩余过期时间
 public Long getExpire(String key) {
    return redisTemplate.getExpire(key);
}

// 返回剩余过期时间并且指定时间单位
public Long getExpire(String key, TimeUnit unit) {
    return redisTemplate.getExpire(key, unit);
}

// 将key持久化保存
public Boolean persistKey(String key) {
    return redisTemplate.persist(key);
}

// 将当前数据库的key移动到指定redis中数据库当中
public Boolean moveToDbIndex(String key, int dbIndex) {
    return redisTemplate.move(key, dbIndex);
}

// 设置当前的key以及value值
RedisTemplate.opsForValue().set(key, value)

// 设置当前的key以及value值并且设置过期时间
redisTemplate.opsForValue().set(key, value, timeout, unit)

// 返回key中字符串的子字符
public String getCharacterRange(String key, long start, long end) {
    return redisTemplate.opsForValue().get(key, start, end);
}

// 将旧的key设置为value，并且返回旧的key
public String setKeyAsValue(String key, String value) {
    return redisTemplate.opsForValue().getAndSet(key, value);
}

// 批量获取值
 public List<String> multiGet(Collection<String> keys) {
    return redisTemplate.opsForValue().multiGet(keys);
 }

// 在原有的值基础上新增字符串到末尾
redisTemplate.opsForValue().append(key, value)

// 以增量的方式将double值存储在变量中
 public Double incrByDouble(String key, double increment) {
    return redisTemplate.opsForValue().increment(key, increment);
 }

// 通过increment(K key, long delta)方法以增量方式存储long值（正值则自增，负值则自减）
public Long incrBy(String key, long increment) {
    return redisTemplate.opsForValue().increment(key, increment);
}

// 如果对应的map集合名称不存在，则添加否则不做修改
Map valueMap = new HashMap();  
valueMap.put("valueMap1","map1");  
valueMap.put("valueMap2","map2");  
valueMap.put("valueMap3","map3");  
redisTemplate.opsForValue().multiSetIfAbsent(valueMap); 

// 设置map集合到redis
Map valueMap = new HashMap();  
valueMap.put("valueMap1","map1");  
valueMap.put("valueMap2","map2");  
valueMap.put("valueMap3","map3");  
redisTemplate.opsForValue().multiSet(valueMap);  

// 获取字符串的长度
redisTemplate.opsForValue().size(key)

用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
redisTemplate.opsForValue().set(key, value, offset)

// 重新设置key对应的值，如果存在返回false，否则返回true
redisTemplate.opsForValue().setIfAbsent(key, value)

// 将值 value 关联到 key,并将 key 的过期时间设为 timeout
redisTemplate.opsForValue().set(key, value, timeout, unit)

// 将二进制第offset位值变为value
redisTemplate.opsForValue().setBit(key, offset, value)

// 对key所储存的字符串值，获取指定偏移量上的位(bit)
redisTemplate.opsForValue().getBit(key, offset)

Hash

  • String 类型的 field 和 value 映射表，hash 特别适合用于存储对象
  • Redis 中每个 hash 可以存储 2^32 - 1 键值对（40多亿）
// 获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null。
redisTemplate.opsForHash().get(key, field)

// 获取变量中的键值对
public Map<Object, Object> hGetAll(String key) {
    return redisTemplate.opsForHash().entries(key);
}

// 新增hashMap值
redisTemplate.opsForHash().put(key, hashKey, value)

// 以map集合的形式添加键值对
public void hPutAll(String key, Map<String, String> maps) {
    redisTemplate.opsForHash().putAll(key, maps);
} 

// 仅当hashKey不存在时才设置
public Boolean hashPutIfAbsent(String key, String hashKey, String value) {
    return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
} 

// 删除一个或者多个hash表字段 
public Long hashDelete(String key, Object... fields) {
    return redisTemplate.opsForHash().delete(key, fields);
} 

// 查看hash表中指定字段是否存在 
public boolean hashExists(String key, String field) {
    return redisTemplate.opsForHash().hasKey(key, field);
}  

// 给哈希表key中的指定字段的整数值加上增量increment 
public Long hashIncrBy(String key, Object field, long increment) {
    return redisTemplate.opsForHash().increment(key, field, increment);
} 
 public Double hIncrByDouble(String key, Object field, double delta) {
    return redisTemplate.opsForHash().increment(key, field, delta);
} 

// 获取所有hash表中字段 
redisTemplate.opsForHash().keys(key)
 
// 获取hash表中字段的数量 
redisTemplate.opsForHash().size(key) 

// 获取hash表中存在的所有的值 
public List<Object> hValues(String key) {
    return redisTemplate.opsForHash().values(key);
}
 
// 匹配获取键值对，ScanOptions.NONE为获取全部键对
public Cursor<Entry<Object, Object>> hashScan(String key, ScanOptions options) {
    return redisTemplate.opsForHash().scan(key, options);
}

List

// 通过索引获取列表中的元素
redisTemplate.opsForList().index(key, index)

// 获取列表指定范围内的元素(start开始位置, 0是开始位置，end 结束位置, -1返回所有)
redisTemplate.opsForList().range(key, start, end)

// 存储在list的头部，即添加一个就把它放在最前面的索引处
redisTemplate.opsForList().leftPush(key, value)

// 把多个值存入List中(value可以是多个值，也可以是一个Collection value)
redisTemplate.opsForList().leftPushAll(key, value)

// List存在的时候再加入
redisTemplate.opsForList().leftPushIfPresent(key, value)

// 如果pivot处值存在则在pivot前面添加
redisTemplate.opsForList().leftPush(key, pivot, value)

// 按照先进先出的顺序来添加(value可以是多个值，或者是Collection var2)
redisTemplate.opsForList().rightPush(key, value)
redisTemplate.opsForList().rightPushAll(key, value)

// 在pivot元素的右边添加值
redisTemplate.opsForList().rightPush(key, pivot, value)

// 设置指定索引处元素的值
redisTemplate.opsForList().set(key, index, value)

// 移除并获取列表中第一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止)
redisTemplate.opsForList().leftPop(key)
redisTemplate.opsForList().leftPop(key, timeout, unit)

// 移除并获取列表最后一个元素
redisTemplate.opsForList().rightPop(key)
redisTemplate.opsForList().rightPop(key, timeout, unit)

// 从一个队列的右边弹出一个元素并将这个元素放入另一个指定队列的最左边
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey)
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey, timeout, unit)

// 删除集合中值等于value的元素(index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; index<0, 从尾部开始删除第一个值等于value的元素)
redisTemplate.opsForList().remove(key, index, value)

// 将List列表进行剪裁
redisTemplate.opsForList().trim(key, start, end)

// 获取当前key的List列表长度
redisTemplate.opsForList().size(key)

Set

// 添加元素
redisTemplate.opsForSet().add(key, values)

// 移除元素(单个值、多个值)
redisTemplate.opsForSet().remove(key, values)

// 删除并且返回一个随机的元素
redisTemplate.opsForSet().pop(key)

// 获取集合的大小
redisTemplate.opsForSet().size(key)

// 判断集合是否包含value
redisTemplate.opsForSet().isMember(key, value)

// 获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合求交集)
redisTemplate.opsForSet().intersect(key, otherKey)

// 获取多个集合的交集(Collection var2)
redisTemplate.opsForSet().intersect(key, otherKeys)

// key集合与otherKey集合的交集存储到destKey集合中(其中otherKey可以为单个值或者集合)
redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey)

// key集合与多个集合的交集存储到destKey无序集合中
redisTemplate.opsForSet().intersectAndStore(key, otherKeys, destKey)

// 获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)
redisTemplate.opsForSet().union(key, otherKeys)

// key集合与otherKey集合的并集存储到destKey中(otherKeys可以为单个值或者是集合)
redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey)

// 获取两个或者多个集合的差集(otherKeys可以为单个值或者是集合)
redisTemplate.opsForSet().difference(key, otherKeys)

// 差集存储到destKey中(otherKeys可以为单个值或者集合)
redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)

// 随机获取集合中的一个元素
redisTemplate.opsForSet().randomMember(key)

// 获取集合中的所有元素
redisTemplate.opsForSet().members(key)

// 随机获取集合中count个元素
redisTemplate.opsForSet().randomMembers(key, count)

// 获取多个key无序集合中的元素（去重），count表示个数
redisTemplate.opsForSet().distinctRandomMembers(key, count)

// 遍历set类似于Interator(ScanOptions.NONE为显示所有的)
redisTemplate.opsForSet().scan(key, options)

ZSet

// 添加元素(有序集合是按照元素的score值由小到大进行排列)
redisTemplate.opsForZSet().add(key, value, score)

// 删除对应的value,value可以为多个值
redisTemplate.opsForZSet().remove(key, values)

// 增加元素的score值，并返回增加后的值
redisTemplate.opsForZSet().incrementScore(key, value, delta)

// 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
redisTemplate.opsForZSet().rank(key, value)

// 返回元素在集合的排名,按元素的score值由大到小排列
redisTemplate.opsForZSet().reverseRank(key, value)

// 获取集合中给定区间的元素(start 开始位置，end 结束位置, -1查询所有)
redisTemplate.opsForZSet().reverseRangeWithScores(key, start,end)

// 按照Score值查询集合中的元素，结果从小到大排序
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)
redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max)
//返回值为:Set<ZSetOperations.TypedTuple<V>>

// 从高到低的排序集中获取分数在最小和最大值之间的元素
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)

// 根据score值获取集合元素数量
redisTemplate.opsForZSet().count(key, min, max)

// 获取集合的大小
redisTemplate.opsForZSet().size(key)
redisTemplate.opsForZSet().zCard(key)

// 获取集合中key、value元素对应的score值
redisTemplate.opsForZSet().score(key, value)

// 移除指定索引位置处的成员
redisTemplate.opsForZSet().removeRange(key, start, end)

// 移除指定score范围的集合成员
redisTemplate.opsForZSet().removeRangeByScore(key, min, max)

// 获取key和otherKey的并集并存储在destKey中（其中otherKeys可以为单个字符串或者字符串集合）
redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)

// 获取key和otherKey的交集并存储在destKey中（其中otherKeys可以为单个字符串或者字符串集合）
redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)

// 遍历集合（和iterator一模一样）
Cursor<TypedTuple<Object>> scan = opsForZSet.scan("test3", ScanOptions.NONE);
while (scan.hasNext()){
    ZSetOperations.TypedTuple<Object> item = scan.next();
    System.out.println(item.getValue() + ":" + item.getScore());
}

使用 FastJsonRedisSerializer 设置 Redis 序列化方式

@Configuration
public class RedisConfig {

   @Bean
   public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // key序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // value序列化
        redisTemplate.setValueSerializer(new FastJsonRedisSerializer<>(Object.class));
        // Hash key序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // Hash value序列化
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
   }
}

StringRedisTemplate

最常用的 Redis 客户端，存取 key 和 value 都是字符串类型数据。默认采用 String 的序列化策略StringRedisSerializer

StringRedisTemplate简介

  • StringRedisTemplate 继承 RedisTemplate

  • 两者的数据是不共通：StringRedisTemplate 管理自己的数据，RedisTemplate 管理自己的数据

  • 序列化类不同

    • RedisTemplate 使用 JdkSerializationRedisSerializer，将数据先序列化成字节数组然后在存入 Redis
    • StringRedisTemplate 使用 StringRedisSerializer

  • 使用

    • StringRedisTemplate：本来存的是字符串数据或者你要存取的数据就是字符串类型数据
    • RedisTemplate：数据是复杂的对象类型，而取出时又不想做任何数据转换

RedisTemplate 中存取数据都是字节数组。当 Redis 中存入的数据是可读形式而非字节数组时，使用RedisTemplate 取值会无法获取导出数据，获得的值为 null

使用StringRedisTemplate

引入 spring-boot-starter-data-redis 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

注入Bean

@Autowired
public StringRedisTemplate stringRedisTemplate;

依赖配置

  redis:
    database: 0
    host: 192.168.153.129
    port: 6379
    # password:
    # 连接超时时间
    timeout: 10000

StringRedisTemplate操作

// 向 Redis 里存入数据和设置缓存时间
stringRedisTemplate.opsForValue().set("test", "100",60*10,TimeUnit.SECONDS);

// val - 1
stringRedisTemplate.boundValueOps("test").increment(-1);

// 根据 key 获取缓存中的 val
stringRedisTemplate.opsForValue().get("test")

// val + 1
stringRedisTemplate.boundValueOps("test").increment(1);

// 根据 key 获取过期时间
stringRedisTemplate.getExpire("test")

// 根据 key 获取过期时间并换算成指定单位
stringRedisTemplate.getExpire("test",TimeUnit.SECONDS) 

// 根据 key 删除缓存
stringRedisTemplate.delete("test");

// 检查 key 是否存在，返回 boolean 值
stringRedisTemplate.hasKey("546545"); 

// 向指定key中存放set集合
stringRedisTemplate.opsForSet().add("red_123", "1","2","3");

// 设置过期时间
stringRedisTemplate.expire("red_123",1000 , TimeUnit.MILLISECONDS);

// 根据key查看集合中是否存在指定数据
stringRedisTemplate.opsForSet().isMember("red_123", "1")

// 根据key获取set集合
stringRedisTemplate.opsForSet().members("red_123");
  • 当需要存取的数据是 String 类型时，使用 StringRedisTemplate
  • 当需要存取的数据是 Object 时，使用 RedisTemplate（需要定义好序列化策略）
标题：SpringBoot使用Redis
作者：Hefery
地址：http://hefery.icu/articles/2022/04/04/1649037633551.html