redis学习笔记_隋小bai

已于 2022-04-22 13:15:18 修改
阅读量312 收藏
点赞数
分类专栏： 非关系形数据库 文章标签： redis 缓存
于 2022-03-11 13:53:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44066672/article/details/123423106
版权

简介

Redis是以Key-Value形式进行存储的NoSQL数据库。
​	Redis是使用C语言进行编写的。
​	平时操作的数据都在内存中，效率特高，读的效率110000/s，写81000/s，所以多把Redis当做缓存工具使用。
​	Redis以solt（槽）作为数据存储单元，每个槽中可以存储N多个键值对。Redis中固定具有16384。理论上可以实现一个槽是一个Redis。每个向Redis存储数据的key都会进行crc16算法得出一个值后对16384取余就是这个key存放的solt位置。
​	同时通过Redis Sentinel提供高可用，通过Redis Cluster提供自动分区。

常用五大类型

String（字符串  用法： 键  值）
Hash（哈希 类似Java中的 map  用法： 键  键值对）
List（列表  用法：键 集合 不可以重复）
Set（集合 用法：键 集合 可以重复）
Zset（sorted set 有序集合    用法： 键  值 值）

String

string 是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象。string 类型是 Redis 最基本的数据类型，string 类型的值最大能存储 512MB。
应用场景：  
String是最常用的一种数据类型，普通的key/value存储都可以归为此类，value其实不仅是String

Hash（哈希）

Redis hash 是一个键值(key=>value)对集合。

Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

使用场景：存储、读取、修改用户属性

List（列表）

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

应用场景：  
 Lists的另一个应用就是消息队列，可以利用Lists的PUSH操作，将任务存在Lists中，然后工作线程再用POP操作将任务取出进行执行。

Set（集合）

Redis的Set是string类型的无序集合。

​使用场景：需要去重的条件

zset(sorted set：有序集合)

Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。
使用场景：1.带有权重的元素，比如一个游戏的用户得分排行榜 
         2.比较复杂的数据结构，一般用到的场景不算太多

常用命令

Key操作

1  exists

​	判断key是否存在。

​	语法：exists key名称

​	返回值：存在返回数字，不存在返回0

 2 expire

​	设置key的过期时间，单位秒

​	语法：expire key 秒数

​	返回值：成功返回1，失败返回0

 3 ttl

​	查看key的剩余过期时间

​	语法：ttl key

​	返回值：返回剩余时间，如果不过期返回-1

 4 del

​	根据key删除键值对。

​	语法：del key

​	返回值：被删除key的数量

字符串值(String)

1 set

​	设置指定key的值

​	语法：set key value

​	返回值：成功OK

2 get

​	获取指定key的值

​	语法：get key

​	返回值：key的值。不存在返回nil

3 setnx

​	当且仅当key不存在时才新增。

​	语法：setnx key value

​	返回值：不存在时返回1，存在返回0

4 setex

​	设置key的存活时间，无论是否存在指定key都能新增，如果存在key覆盖旧值。同时必须指定过期时间。

​	语法：setex key seconds value

​	返回值：OK

哈希表(Hash)

1 hset

​	给key中field设置值。

​	语法：hset key field value

​	返回值：成功1，失败0

2 hget

​	获取key中某个field的值

​	语法：hget key field 

​	返回值：返回field的内容

3 hmset

​	给key中多个filed设置值

​	语法：hmset key field value field value

​	返回值：成功OK

4 hmget

​	一次获取key中多个field的值

​	语法：hmget key field field

​	返回值：value列表

5 hvals

​	获取key中所有field的值

​	语法：hvals key

​	返回值：value列表

6 hgetall

​	获取所有field和value

​	语法：hgetall key

​	返回值：field和value交替显示列表

7 hdel

​	删除key中任意个field

​	语法：hdel key field field

​	返回值：成功删除field的数量

列表（List）

1 Rpush

​	向列表末尾中插入一个或多个值

​	语法；rpush key value value

​	返回值：列表长度

2 lrange

​	返回列表中指定区间内的值。可以使用-1代表列表末尾

​	语法：lrange list 0 -1

​	返回值：查询到的值

3 lpush

​	将一个或多个值插入到列表前面

​	语法：lpush key value value

​	返回值：列表长度

4 llen

​	获取列表长度

​	语法：llen key

​	返回值：列表长度

5 lrem

​	删除列表中元素。count为正数表示从左往右删除的数量。负数从右往左删除的数量。

​	语法：lrem key count value

​	返回值：删除数量。

集合(Set)

set和java中集合一样。

1 sadd

​	向集合中添加内容。不允许重复。

​	语法：sadd key value value value

​	返回值：集合长度

2 scard

​	返回集合元素数量

​	语法：scard key

​	返回值：集合长度

3 smembers 

​	查看集合中元素内容

​	语法：smembers key

​	返回值：集合中元素

有序集合（Sorted Set）

有序集合中每个value都有一个分数（score），根据分数进行排序。

1 zadd

​	向有序集合中添加数据

​	语法：zadd key score value score value

​	返回值：长度

2 zrange

​	返回区间内容，withscores表示带有分数

​	语法：zrange key 区间 [withscores]

​	返回值：值列表

Redis持久化策略

RDB

rdb模式是默认模式，可以在指定的时间间隔内生成数据快照（snapshot），默认保存到dump.rdb文件中。当redis重启后会自动加载dump.rdb文件中内容到内存中。

​	用户可以使用SAVE（同步）或BGSAVE（异步）手动保存数据。

​	可以设置服务器配置的save选项，让服务器每隔一段时间自动执行一次BGSAVE命令，可以通过save选项设置多个保存条件，但只要其中任意一个条件被满足，服务器就会执行BGSAVE命令。
　　	例如：
　　	save 900 1
　　	save 300 10
　　	save 60 10000
　　那么只要满足以下三个条件中的任意一个，BGSAVE命令就会被执行
　　服务器在900秒之内，对数据库进行了至少1次修改
　　服务器在300秒之内，对数据库进行了至少10次修改
　　服务器在60秒之内，对数据库进行了至少10000次修改

1 优点

​	rdb文件是一个紧凑文件，直接使用rdb文件就可以还原数据。

​	数据保存会由一个子进程进行保存，不影响父进程。

​	恢复数据的效率要高于aof

2 缺点

​	每次保存点之间导致redis不可意料的关闭，可能会丢失数据。

​	由于每次保存数据都需要fork()子进程，在数据量比较大时可能会比较耗费性能。

AOF

AOF默认是关闭的，需要在配置文件中开启AOF。Redis支持AOF和RDB同时生效，如果同时存在，AOF优先级高于RDB（Redis重新启动时会使用AOF进行数据恢复）

​	监听执行的命令，如果发现执行了修改数据的操作，同时直接同步到数据库文件中。

1 优点

​	相对RDB数据更加安全。

2 缺点

​	相同数据集AOF要大于RDB。

​	相对RDB可能会慢一些。

开启

修改redis.con配置文件
# 默认no
appendonly yes
# aof文件名
appendfilename "appendonly.aof"

redis工具类

package com.zh.sui.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
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.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * @author suizh
 * @version 1.0
 * @date 2021/11/15 13:17
 */
@Configuration
@EnableCaching //开启注解
public class RedisConfig {
    /**
     * retemplate相关配置
     *
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);
        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();
        return template;
    }
    /**
     * 对hash类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }
    /**
     * 对redis字符串类型数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }
    /**
     * 对链表类型的数据操作
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }
    /**
     * 对无序集合类型的数据操作
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }
    /**
     * 对有序集合类型的数据操作
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}


package com.zh.sui.utils;

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 suizh
 * @version 1.0
 * @date 2021/11/15 13:17
 */
@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    /**
     * 指定缓存失效时间
     * @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(String.valueOf(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;
        }
    }
}
隋小白
关注
专栏目录
redis-6.2.6_win10.zip
11-21
Redis是一款高性能的键值存储系统，常用于数据库、缓存和消息中间件等场景。标题中的"redis-6.2.6_win10.zip"表明这是Redis 6.2.6版本的Windows 10兼容版本。由于Redis官方并未直接提供Windows版，描述中提到的...
Redis：ZSet数据结构使用
程序员无羡的博客
03-27 745
Redis：ZSet数据结构使用
RedisTemplate使用最详解（五）--- opsForZSet()
热门推荐
weixin_43658899的博客
10-31 3万+
1、add(K key, V value, double score) 向指定key中添加元素，按照score值由小到大进行排列 集合中对应元素已存在，会被覆盖，包括score redisTemplate.opsForZSet().add("zSet", "aaa", 1); redisTemplate.opsForZSet().add("zSet", "bbb", 2); redisTemplate.opsForZSet().add("zSet", "ccc", 3); 2、add(K key
Redies
不以人人的意志为转义乃天道
08-02 764
redisTemplate.opsForList().size(waveRedisKey) list的总长度 如果没有key 则返回零 可以用来判断list是否为空或者是否有key 返回存储在键中的列表的长度。如果键不存在，则将其解释为空列表，并返回0。key不存在的时候返回也是0 Long qwewqewqewqe = redisTemplate.opsForList().s...
RedisTemplate.opsForSet()用法简介并举例
一起coding，一起嗨。
08-08 3738
是RedisTemplate类提供的用于操作Set类型的方法。它可以用于对Redis中的Set数据结构进行各种操作，如添加元素、获取元素、删除元素等。请注意，示例中的"myset"是集合的键名，“value1”、"value2"等是要添加、移除或判断的元素值。方法的常见用法，你可以根据具体的业务需求选择适合的方法进行操作。
Redis opsForZSet 用法
qq_44499717的博客
04-26 6234
Redis opsForZSet 用法 1、add(K key, V value, double score) 添加元素到变量中同时指定元素的分值。 Java代码 收藏代码 redisTemplate.opsForZSet().add(“zSetValue”,“A”,1); redisTemplate.opsForZSet().add(“zSetValue”,“B”,3); redisTemplate.opsForZSet().add(“zSetValue”,“C”,2); redisTemplate.o
Redis学习笔记.zip
最新发布
06-06
简单来说 redis 就是一个数据库，不过与传统数据库不同的是 redis 的数据是存在内存中的，所以存写速度非常快，因此 redis 被广泛应用于缓存方向。另外，redis 也经常用来做分布式锁。redis 提供了多种数据类型来...
Redis全套学习笔记
05-25
Redis 是一款高性能的键值数据库，它以非关系型、内存存储的方式提供快速的数据访问。Redis 的设计目标是为了处理高并发、高扩展性场景，以及大数据存储问题。它支持多种数据结构，包括字符串(String)、链表(List)、...
redis_redis_python_
10-01
标题中的“redis_redis_python_”暗示了我们讨论的是如何使用Python编程语言来操作Redis数据库。Redis是一个开源的、基于键值对的数据存储系统，常用于数据缓存、消息队列和实时数据分析等领域。Python提供了丰富的...
Redis_Windows_6.2.6版本
06-28
Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object...
Java 操作Redis封装RedisTemplate的常用方法工具类（获取key对应的过期时间、判断某个key是否存在、添加、删除、取值、查找匹配的key值）
weixin_45541084的博客
05-12 3479
Java 操作Redis封装RedisTemplate的常用方法工具类 import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.util.Set; import java.util.concurrent.TimeUnit; /** * @Author Ly
Redis 学习笔记
zhj52666的博客
08-04 620
redis 学习笔记 1 简介 Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。它支持存储的 value 类型相对更多，包括 String(字符串)、List(列表)、Set(集合)、Sorted Set(有序集合) 和 Hash(哈希)。在此基础上，Redis 支持各种不同方式的排序。为了保证效率，数据都是缓存在内存中。Redis 可以周期性的
RedisTemplate 使用总结
qq_42599762的博客
07-16 1166
最近在做一个项目，考虑到有累计，排行，缓存等功能；而Redis是一个基于内存的数据库，而且提供了 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等多种数据类型;因此考虑使用Redis.最终决定使用Spring-data-redis 的RedisTemplate来实现Redis的访问操作。 一、 通用操作工具 1、常用的分布式...
Redis基础
weixin_55441614的博客
07-07 526
Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
java list判断key是否存在,Map.containsKey方法——判断Map集合对象中是否包含指定的键名...
weixin_39945679的博客
03-11 3109
containsKey方法用来判断Map集合对象中是否包含指定的键名。语法 boolean containsKey(Object key)返回值：如果Map集合中包含指定的键名，则返回true；否则返回false。参数：key是要查询的Map集合的键名对象。本示例首先使用HashMap类创建Map集合对象，并向集合中添加几个元素，然后调用containsKey方法查询是否包含指定的键名。publ...
RedisTemplate - 常用集合之opsFor系列
weixin_48358336的博客
11-15 3071
一、opsForValue 简单的Key-Value操作 1、set(K key, V value) 该方法是向Redis新增一个key-value，由方法参数可知k-v可以是泛型，也就是说我们k-v不一定要是传统的String-String，还可以是Object-Object...
RedisTemplate使用最详解（四）--- opsForSet()
weixin_43658899的博客
10-31 3万+
1、add(K key, V… var2) 向key中批量添加值 redisTemplate.opsForSet().add("set", "aa", "bb", "cc"); redisTemplate.opsForSet().add("set", "ee"); 2、members(K key) 获取key中的值 Set set = redisTemplate.opsForSet().members("set"); System.out.println("set = " + set); 3
redisTemplate.opsForValue().get(KEY)从Redis中取出的值为null 的解决方法
林夕
03-18 6553
最近，博主在整理毕设时就遇到一个问题：我往Redis中存手机验证码，我把手机号当做key ，验证码当做value 存储到 Redis 中，但是在我在需要在登录操作中取验证码时遇到一个问题：困惑： 我Redis 中明明存的有，但是就是取不到，显示为null。我调试了好久，最后在一篇文章中找到了解决方法： 其实问题表象很诡异，但问题的原因很简单，就是Redis中存数据和取数据时采用了不同的RedisTemplate导致的。 我之前的redisTemplate 的注入方法一个写的是： 解决方法：
redisTemplate.opsForValue().get(KEY)从Redis中取出的值为null 存入的key被加上了引号
向来萧瑟也无畏
04-01 2万+
存入redis后，key左右多了个双引号。
redis 返回值 REDIS_REPLY_NIL
05-10
REDIS_REPLY_NIL 是 Redis 返回值中的一种，表示 Redis 中不存在对应的键值。当我们使用 Redis 的 GET 命令获取一个不存在的键值时，Redis 会返回 REDIS_REPLY_NIL。同样地，当我们使用 DEL 命令删除一个不存在的键...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值