Redis：常见数据类型、命令、SpringBoot简单整合

已于 2022-11-29 20:12:26 修改
阅读量390 收藏
点赞数
分类专栏： Redis 文章标签： redis 数据库 java
于 2022-11-29 20:11:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HorinJsor/article/details/127160643
版权

编写：HorinJsor

文章目录

前言

Redis是一个key-value的数据库，key一般是String类型，不过value的类型多种多样。

一、Redis的通用命令

通用指令是部分数据类型的，都可以使用的指令，常见的有：

命令名称作用
KEYS *查看符合模板的所有key
DEL [key]删除指定的key
EXPIRE [key] [time]给一个key设置有效期，有效期到期时该key会被自动删除
TTL [key]查看一个KEY的剩余有效期

二、Redis的基本类型数据结构

以下为基本的数据结构，其他还有三种特殊类型：GEO、BitMap、HyperLog。

结构名称中文名特点示例
String字符串类型字节数组形式hello world
Hash散列无序字典 对象{name: “Jack”, age: 21}
List列表有序 可重复[A -> B -> C -> C]
Set集合无序 不可重复{A, B, C}
SortedSet有序集合可排序 不可重复{A: 1, B: 2, C: 3}

1.String类型

字符串类型，最简单的类型。
示例：
在这里插入图片描述
常用命令：

命令描述
SET [key] [val]添加一个键值对，若key存在则修改
GET [key]获取该key的val
SET [key] [val]添加一个键值对，若key存在则修改
MSET [key1] [val1] [key2] [val2] [key3] [val3]批量添加多个String类型的键值对
MGET [key1] [key2]根据多个key获取多个String类型的value
INCR [key]让一个*整型的key自增1
INCRBY [key] [步长]让一个整型的key自增并指定步长
INCRBYFLOAT [float key] [步长]让一个浮点类型的数字自增并指定步长
SETNX [key] [val]【纯新增】添加一个String类型的键值对，前提是这个key不存在，否则不执行
SET [key] [val] nx【纯新增】
EXPIRE [key] [time]给key设置有效期，单位秒
TTL [key]查看某key的剩余有效期(有效期-1为永久，-2为失效）

【扩展】key的层级结构

Key的命名建议：通过层级结构来规范命名。
Redis的key允许有多个单词形成层级结构，多个单词之间用’:'隔开，格式如下：

项目名:业务名:类型:id

示例：
在这里插入图片描述
![在这里插入图片描述](https://img-blog.csdnimg.cn/2418dec440cc4a16a3e1dc9f49b63bb3.png

2.Hash类型

Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构。
在这里插入图片描述

命令描述
HSET [key] [field] [value]添加或者修改hash类型key的field的值
HGET [key] [field]获取一个hash类型key的field的值
HMSET [ k e y 1 ] \color{#FF0000}{[key1] } [key1] [ f i e l d 1 ] [ v a l 1 ] \color{#FF00FF}{[field1] [val1]} [field1][val1] [ f i e l d 2 ] [ v a l 2 ] \color{#0000FF}{[field2] [val2]} [field2][val2]批量添加多个hash类型key的field的值
HMGET [key] [field1][ [field2]【获取一个key的需要的field值】 批量获取多个hash类型key的field的值
HGETALL [key]获取key中的所有的field和value
HKEYS [key]获取key中的所有的field
HVALS [key]获取key中的所有的value
HINCRBY [key] [field]让key的字段值自增并指定步
HSETNX【纯新增】添加一个key的field值，前提是这个field不存在，否则不执行

3.Hash类型

在这里插入图片描述

4.Set类型

在这里插入图片描述
在这里插入图片描述

5.SortedSet类型

在这里插入图片描述

ZSREVRANK：升序

二、Redis的Java客户端：SpringDataRedis的使用方式

1.引入依赖:

	<dependencies>
        <!--集成redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.1.7.RELEASE</version>
        </dependency>
        <!--序列化-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
            <scope>compile</scope>
        </dependency>
        <!--连接池依赖-->
		<dependency>
    		<groupId>org.apache.commons</groupId>
    		<artifactId>commons-pool2</artifactId>
		</dependency>
        </dependency>

2.配置文件

server:
  port: 10001

spring:
	redis:
    	host: 127.0.0.1
    	port: 6379
  lettuce:
  	pool:
  		max-active: 8 # 最大连接
  		max-idle: 8 # 最大空闲连接
  		min-idle: 0 # 最小空闲连接
  		max-wait: 100 # 连接等待时间

3.测试

@SpringBootTest
class RedisDemo1129ApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        // 插入一条string类型数据
        redisTemplate.opsForValue().set("a", "江江");
        System.out.println("name = " + redisTemplate.opsForValue().get("a"));
    }
}

4.自定义RedisTemplate：序列化配置类RedisConfig

为了节省redis资源，否则数据库会保存对象的多余相关信息。
在这里插入图片描述

4.1.需要引入FastJson依赖：

@Configuration
public class RedisConfig {
    // 这是我给大家写好的一个固定模板，大家在企业中，拿去就可以直接使用！
    // 自己定义了一个RedisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 我们为了自己开发方便，一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

4.2.也可以使用jackson（同样需要依赖）：

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
        throws UnknownHostException {
    // 创建Template
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    // 设置连接工厂
    redisTemplate.setConnectionFactory(redisConnectionFactory);
    // 设置序列化工具
    GenericJackson2JsonRedisSerializer jsonRedisSerializer = 
					new GeGenericJackson2JsonRedisSerializer();
    // key和 hashKey采用 string序列化
    redisTemplate.setKeySerializer(RedisSerializer.string()); 
    redisTemplate.setHashKeySerializer(RedisSerializer.string());
    // value和 hashValue采用 JSON序列化
    redisTemplate.setValueSerializer(jsonRedisSerializer);
    redisTemplate.setHashValueSerializer(jsonRedisSerializer);
    return redisTemplate;
}

4.3.或者使用StringRedisTemplate：Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。

省去了我们自定义RedisTemplate的过程。

@Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    public void json() throws JsonProcessingException {
        // 准备对象
        User user = new User("江江", 22);
        // 手动序列化
        String json = mapper.writeValueAsString(user);
        // 写入一条数据到redis
        stringRedisTemplate.opsForValue().set("user:200", json);

        // 读取数据
        String val = stringRedisTemplate.opsForValue().get("user:200");
        // 反序列化
        User user1 = mapper.readValue(val, User.class);
        System.out.println("user1 = " + user1);
    }

5.封装RedisUtils类

实际开发可以提升效率！！！

@Component
public final class RedisUtil {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;


    public Set<String> keys(String keys){
        try {
            return redisTemplate.keys(keys);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 指定缓存失效时间
     * @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((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }
    /**
     * 普通缓存获取
     * @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 值
     * @return true成功 false失败
     */
    public boolean setnx(String key, Object value) {
        try {
            redisTemplate.opsForValue().setIfAbsent(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 value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean setnx(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().setIfAbsent(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);
    }
    /**
     * 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);
    }
    /**
     * 根据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;
        }
    }
}

来源地址：SpringBoot如何整合Redis

总结

冲

HorinJsor
关注
专栏目录
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
SpringBoot——整合Redis
hssjsh的博客
07-28 2580
SpringBoot——SpringBoot集成Redis
如何使用Spring Boot框架整合Redis：超详细案例教程
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
06-14 1万+
成功在 Spring Boot 项目中整合了 Redis 并配置了连接池。我们使用连接池可以显著提高 Redis 操作的性能和资源管理效率。启动应用程序后，可以选中通过 Postman 或浏览器访问以下 URL，验证 Redis 操作是否成功。保持 Redis 操作类和控制器不变。它们已经实现了基本的 Redis 操作。是用于 Lettuce 连接池配置的依赖。目录下，添加 Redis 连接池的配置。确保你的项目包含了以下依赖。，这里就无需再次添加。类以支持连接池即可。
Redis入门：windows下springboot整合redis
weixin_48524739的博客
07-29 886
springboot整合redis，redis入门
Springboot整合Redis
桂林电子科技大学 -芳
03-29 1959
首先我们要知道Redis是什么：Redis一个NoSQL数据库，常用作缓存使用( cache )，用户访问应用，如果找数据的话会先访问redis，如果redis中有数据的话就直接返回发给用户，如果redis中没有的话我们再去查数据库，找到了数据之后一方面存到redis中，另一方面再反馈给用户，目的是说如果用户下次再访问类似的数据的话，redis中就有了。Redis如何启动：双击；客户端双击exit就退出了。
springboot3整合redis
2301_77138117的博客
08-09 1770
来源于。
【Redis | 第三篇】Springboot整合Redis
踢桃的成长之路
02-28 1152
Redsi系列第三篇主要介绍了Springboot快速整合Redis，以及常用的数据类型操作，对实战非常有大的帮助
springboot整合redis
热门推荐
lwj_07的博客
08-10 4万+
创建springboot整合redis工程： 首先我们要知道什么是redis： 三个步骤：补充：RedisTemplate对象提供了各种往redis数据库中存储数据的类型： 代码演示如下所示：注意：下面所有的步骤，要保证Redis数据库是开启的状态，要不然肯定连接不上Redis数据库 第一步： 第二步： 第三步： 又因为我们知道Redis数据库支持多种格式的存储数据形式，因此还可以往Redis数据库中存储哈希类型的数据（哈希类型：就类似于一个key里面又放入一个key，value），因此Redis
Redis入门详解(一)—Redis数据类型及命令、SpringBoot整合Redis
m0_68772878的博客
01-14 1137
非关系型数据库则对数据库的格式没有严格约束，形式松散，自由，并且不同的非关系型数据库存储的信息的格式也会有所不同，可以是以Json的文档形式储存，也可以是使用键值对的形式储存。在redis中，字符串有三种格式，分别是我们了解的String常规字符串，还有int和float，这三种格式在底层都是以字节数组形式储存，所以在redis中int和float也属于String，并且这两者可以进行自增自减操作。对于List而言，它的底层引用的是栈的概念，所以其命令具有入栈和出栈的命令，入栈为PUSH，出栈为POP。
如何用SpringBoot整合Redis（详细讲解~）
知识记录
07-15 3万+
springboot在现在的版本中操作Redis数据库用到了lettuce，而不是Jedis，如何使用springboot这个技术框架来整合redis呢？
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
图解Redis 05 | Zset数据类型的原理及应用场景
大厂小码农的博客
10-29 594
Zset 类型（有序集合）与 Set 类型相比，增加了一个排序属性 score。对于有序集合 Zset，每个元素由两个部分组成：一个是元素的值，另一个是用于排序的分数 score。有序集合继承了Set中成员唯一（元素值不能重复，分数可以重复）的特性，但不同之处在于，有序集合中的元素是按分数进行排序的。
CentOS 7系统下Redis Cluster集群一键部署脚本发布
最新发布
运维人生
11-02 196
环境准备：自动安装Redis所需的依赖包，并下载Redis源码。Redis安装：编译并安装Redis。配置文件生成：为每个Redis节点生成独立的配置文件。Redis实例启动：根据配置文件启动Redis实例。集群创建：使用redis-cli命令创建Redis Cluster集群。本文提供了一个在CentOS 7系统下Redis Cluster集群的一键部署脚本，帮助开发者快速搭建Redis Cluster集群。未来，我们将继续完善该脚本，增加更多的功能和配置选项，以满足不同场景下的需求。
短信登录的实现-redis和session的比较
2301_79748665的博客
10-29 796
我们之前只有一个拦截器，但是拦截的路径不是所有，如果用户一直访问的是不需要拦截的路径，那么他的token就不会刷新，就会失去登录状态，我们可以再加一个拦截器，第一个拦截一切路径，并且刷新有效期，第二个做登录校验；用户信息的key使用一个token来保存，一个是保证key的唯一性，一个是保证数据的安全性，因为token也就是key是要存在浏览器中的；因为session是存储在tomcat服务器中的，我们将来部署集群进行负载均衡，那么我们存储在一台tomcat服务器的数据无法实现共享；
【Redis：原理、架构与应用】
qq_42060170的博客
10-30 867
Redis（Remote Dictionary Server）是一款开源的内存数据库，以高性能和多样的数据结构著称，主要用作缓存系统、消息队列和会话管理等。它提供了丰富的数据结构，支持字符串、哈希、列表、集合等多种数据类型。Redis 具备快速读写、高可扩展性和灵活的数据持久化能力，是 NoSQL 数据库中的重要代表。Redis 将所有数据存储在内存中，因此访问速度极快，是处理高频、低延迟访问场景的理想选择。Redis 支持主从复制、哨兵、集群等高可用架构，能够在大规模分布式系统中实现高可靠性和数据冗余。
Redis中储存含LocalDateTime属性对象的序列化实现
Charles_Clark的博客
10-29 672
上面代码中配置 RedisTemplate 的序列化机制，以便能够序列化和反序列化包含 LocalDateTime 等 Java 8 时间类型的对象。•作用ObjectMapper 是 Jackson 库的核心类，用来将 Java 对象转换为 JSON 字符串，或者将 JSON 字符串解析为 Java 对象。Jackson 是一个非常流行的 JSON 序列化和反序列化库，ObjectMapper 是它的主要接口，用于处理复杂的对象和数据结构。•作用。
mac｜maven项目在idea中连接redis
WinterSeven的博客
10-30 378
新建一个数据库，名称必须为数字，测试一下是否可以连接，连接成功后选择确定。找到redis.conf配置文件（在上一篇的路径中），按下面编辑一下。idea-setting导入redis插件。项目右侧数据库图标导入redis。idea新建maven项目。pom.xml导入redis。构建系统选择maven。
深入理解Redis的四种模式
隔窗听雨眠的博客
10-29 550
Redis是一个内存数据存储系统，支持多种不同的部署模式，本文介绍了Redis的四种主要部署模式。
SpringBoot整合Redis实战：简单开发与Demo示例
"本文将介绍如何在SpringBoot项目中整合Redis并进行简单的开发，通过一个具体的Demo案例展示实际操作过程。" 在SpringBoot中整合Redis，主要用于实现高效的数据缓存和快速的数据读写功能。以下是一步步整合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值