AI 助理
备案控制台
开发者社区 数据库 文章 正文

SpringBoot——实现对Redis五种数据类型的增删改查

2023-02-15 562
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
简介： SpringBoot——实现对Redis五种数据类型的增删改查

文章目录


一、添加Redis依赖

二、application.properties

三、添加配置类

四、测试

TestRedisString

TestRedisList

TestRedisHash

Article

TestRedisSet

TestRedisZSet


一、添加Redis依赖


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

二、application.properties


# 应用名称
spring.application.name=springboot_redis
server.port=8085
#配置Redis，redis的host是虚拟机服务器上的IP地址，端口6379
spring.redis.host=127.0.0.1
spring.redis.port=6379

三、添加配置类


package com.ljx.springboot_redis.config;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;
import java.time.Duration;
/**
 * @Author: Ljx
 * @Date: 2021/12/1 13:34
 * @role:
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{
    private static final StringRedisSerializer STRING_SERIALIZER = new StringRedisSerializer();
    private static final GenericJackson2JsonRedisSerializer JACKSON__SERIALIZER = new GenericJackson2JsonRedisSerializer();
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //设置缓存过期时间
        RedisCacheConfiguration redisCacheCfg=RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(STRING_SERIALIZER))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(JACKSON__SERIALIZER));
        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheCfg)
                .build();
    }
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        // key序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // value序列化
        redisTemplate.setValueSerializer(JACKSON__SERIALIZER);
        // Hash key序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // Hash value序列化
        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

四、测试


TestRedisString


package com.ljx.springboot_redis;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
 * @Author: Ljx
 * @Date: 2021/12/1 0:52
 * @role:
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
class TestRedisString {
    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    @Test
    public void testSet(){
        //向数据库中保存 name heima
        redisTemplate.opsForValue().set("name","heima");
        //相关数据保存 name1 heima1  有效时间为10s
        redisTemplate.opsForValue().set("name1","heima1",10, TimeUnit.SECONDS);
        //替换 heima        heXXa  offset 索引位置是从0开始
        redisTemplate.opsForValue().set("name","XX",2);
        //当key不存在的时候，执行保存操作；当key存在时，什么都不做
        redisTemplate.opsForValue().setIfAbsent("name","heima");
        //批量保存
        Map<String,String> map = new HashMap<>();
        map.put("name2","heima2");
        map.put("name3","heima3");
        map.put("name3","heima3");
        redisTemplate.opsForValue().multiSet(map);
        //追加 当key存在时，会执行追加操作；当key不存在时，会执行保存操作
        redisTemplate.opsForValue().append("name5","heima");
    }
    @Test
    public void testGet(){
        //根据key获取value
        String value = redisTemplate.opsForValue().get("name");
        System.out.println(value);
        //首先根据key获取value，然后再根据value进行截取。从start位置截取到end位置【包含start和end】
        String name = redisTemplate.opsForValue().get("name", 5, 7);
        System.out.println(name);
        //批量获取
        List<String> keys = new ArrayList<>();
        keys.add("name2");
        keys.add("name3");
        keys.add("name4");
        List<String> values = redisTemplate.opsForValue().multiGet(keys);
        for (String s : values) {
            System.out.println(s);
        }
        //根据key获取value的长度
        Long size = redisTemplate.opsForValue().size("name");
        System.out.println(size);
    }
    @Test
    public void testIncrement(){
        redisTemplate.opsForValue().set("age","18");
//        自增1
        redisTemplate.opsForValue().increment("age");
        System.out.println(redisTemplate.opsForValue().get("age"));
//        自增6
        redisTemplate.opsForValue().increment("age",6);
        System.out.println(redisTemplate.opsForValue().get("age"));
//        自减
        redisTemplate.opsForValue().decrement("age");
    }
    //删除
    @Test
    public void testDelete(){
//        单个删除
        redisTemplate.delete("name");
        List<String> list = new ArrayList<>();
        list.add("name2");
        list.add("name3");
        list.add("name4");
//        批量删除
        redisTemplate.delete(list);
    }
}

TestRedisList


package com.ljx.springboot_redis;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import javax.swing.*;
import java.util.List;
/**
 * @Author: Ljx
 * @Date: 2021/12/1 20:24
 * @role:
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisList {
    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    //增加
    @Test
    public void testAdd(){
        //从左边添加一个元素
        redisTemplate.opsForList().leftPush("students","zhangshan");
        //从左边添加多个元素
        redisTemplate.opsForList().leftPush("students","lishi","wangwu");
        //从右边添加一个元素
        redisTemplate.opsForList().rightPush("students","zhangshan1");
        //从右边添加多个元素
        redisTemplate.opsForList().rightPush("students","lishi1","wangwu1");
    }
    @Test
    public void testFind(){
        //根据key和元素索引进行查询
        //0和正数代表从左边开始
        //负数代表从右边开始
        String students = redisTemplate.opsForList().index("students", 1);
        System.out.println(students);
        String students1 = redisTemplate.opsForList().index("students", -1);
        System.out.println(students1);
        //范围查询
        //根据key 【start,end】 包括首尾
        List<String> students2 = redisTemplate.opsForList().range("students", 0, 2);
        for (String s : students2) {
            System.out.println(s);
        }
    }
    //删除
    @Test
    public void testRemove(){
        //从左边删除第一个元素
        String s = redisTemplate.opsForList().leftPop("students");
        //从右边删除第一个元素
        String s1 = redisTemplate.opsForList().rightPop("students");
        //count > 0; 删除左边起第几个等于指定值的元素
        //count < 0; 删除右边起第几个等于指定值的元素
        //count = 0; 删除所有等于value的元素
        //删除左边起第二个wangwu
        redisTemplate.opsForList().remove("students",2,"wangwu");
    }
}

TestRedisHash


package com.ljx.springboot_redis;
import com.ljx.springboot_redis.uesr.Article;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
 * @Author: Ljx
 * @Date: 2021/12/1 13:07
 * @role:
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisHash {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void testPut(){
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
        Article article = new Article();
        article.setTitle("title");
        article.setCreateTime(new Date());
        article.setAuthor("lixiang");
        redisTemplate.opsForHash().put("article","1",article);
    }
    @Test
    public void testGet(){
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
        //判断hashkey是否存在
//        Boolean article = redisTemplate.opsForHash().hasKey("article", "2");
//        System.out.println(article);
//
//        //根据key和hashkey获取操作
//        Article article1 = (Article) redisTemplate.opsForHash().get("article", "2");
//        System.out.println(article1);
//        //根据key获取所有的hashkey
//        Set<String> set = redisTemplate.opsForHash().keys("article");
//        for (Object s : set) {
//            System.out.println(s);
//        }
        List<Article> articles = redisTemplate.opsForHash().values("article");
        for (Article article : articles) {
            System.out.println(article);
        }
        Map<String,Article> map = redisTemplate.opsForHash().entries("article");
        for (Map.Entry<String, Article> entry : map.entrySet()) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
    //删除
    @Test
    public void testDelete(){
        //当hash中的数据全被删除后，整个hash就没了
        redisTemplate.opsForHash().delete("article","1","2");
    }
}

Article


package com.ljx.springboot_redis.uesr;
import javax.xml.crypto.Data;
import java.io.Serializable;
import java.util.Date;
/**
 * @Author: Ljx
 * @Date: 2021/12/1 13:12
 * @role:
 */
public class Article implements Serializable {
    private String author;
    private Data createTime;
    private String title;
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public Data getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Data createTime) {
        this.createTime = createTime;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    @Override
    public String toString() {
        return "Article{" +
                "author='" + author + '\'' +
                ", createTime=" + createTime +
                ", title='" + title + '\'' +
                '}';
    }
    public void setCreateTime(Date date) {
    }
}

TestRedisSet


package com.ljx.springboot_redis;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
import java.util.Set;
/**
 * @Author: Ljx
 * @Date: 2021/12/1 20:48
 * @role:
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisSet {
    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    //增加
    @Test
    public void testAdd(){
        redisTemplate.opsForSet().add("Students","zhangsan","lishi","wangwu","Zhangsan");
    }
    //查询
    @Test
    public void testFind(){
        //查询所有元素
        Set<String> students = redisTemplate.opsForSet().members("Students");
        for (String student : students) {
            System.out.println(student);
        }
        //随机获取一个元素
        String students1 = redisTemplate.opsForSet().randomMember("Students");
        System.out.println(students1);
        //随机获取多个元素【可能会重复】
        List<String> list = redisTemplate.opsForSet().randomMembers("Students", 2);
        for (String s : list) {
            System.out.println(s);
        }
    }
    //删除
    @Test
    public void testRemove(){
        //移除元素，并返回移除成功个数
        Long remove = redisTemplate.opsForSet().remove("Students", "zhangsan", "wangwu");
        System.out.println(remove);
        //随机移除指定集合中的多少个元素
        List<String> students = redisTemplate.opsForSet().pop("Students", 2);
        for (String student : students) {
            System.out.println(student);
        }
    }
    //多集合操作
    @Test
    public void testMoreSet(){
        redisTemplate.opsForSet().add("names1","zhangsan","li","wangwu");
        redisTemplate.opsForSet().add("names2","zhangsan","li","zhaoliu");
        //取交集
        Set<String> intersect = redisTemplate.opsForSet().intersect("names1", "names2");
        for (String s : intersect) {
            System.out.println(s);
        }
        //取并集
        Set<String> union = redisTemplate.opsForSet().union("names1", "names2");
        for (String s : union) {
            System.out.println(s);
        }
        //取差集[第一个集合中存在，但第二个集合中不存在的元素]
        Set<String> difference = redisTemplate.opsForSet().difference("names2", "names1");
        for (String s : difference) {
            System.out.println(s);
        }
    }
}

TestRedisZSet


package com.ljx.springboot_redis;
import org.junit.Before;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.Set;
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
class TestRedisZSet {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    @Test
    public void testAdd(){
        redisTemplate.opsForZSet().add("student","wangwu",60);
        redisTemplate.opsForZSet().add("student","lishi",100);
        redisTemplate.opsForZSet().add("student","zhangshan",90);
    }
//    分数的增减
    @Test
    public void testScore(){
        // 增加分数
        redisTemplate.opsForZSet().incrementScore("student","wangwu",30);
        // 减少分数
        redisTemplate.opsForZSet().incrementScore("student","wangwu",-50);
    }
    // 查询一个元素的信息
    @Test
    public void testFindOne(){
        //查询一个元素的分数
        Double score = redisTemplate.opsForZSet().score("student", "wangwu");
        System.out.println(score);
        //查询一个元素在集合中的排名  排名从0开始
        Long rank = redisTemplate.opsForZSet().rank("student", "zhangshan");
        System.out.println(rank);
    }
    //根据区间获取列表
    @Test
    public void testFindList(){
        //根据排名区间获取元素列表
        Set<String> students = redisTemplate.opsForZSet().range("student",0,2);
        for (String student : students) {
            System.out.println(student);
        }
        System.out.println("-------------");
        Set<ZSetOperations.TypedTuple<String>> student = redisTemplate.opsForZSet().rangeWithScores("student", 0, 2);
        for (ZSetOperations.TypedTuple<String> stringTypedTuple : student) {
            System.out.println(stringTypedTuple.getValue()+"同学，得了"+stringTypedTuple.getScore()+"分");
        }
        System.out.println("-----------------------------");
        //根据排名区间获取元素列表
        Set<String> students1 = redisTemplate.opsForZSet().rangeByScore("student",50,100);
        for (String student1 : students1) {
            System.out.println(student1);
        }
        System.out.println("-------------");
        Set<ZSetOperations.TypedTuple<String>> student1 = redisTemplate.opsForZSet().rangeByScoreWithScores("student", 50, 100);
        for (ZSetOperations.TypedTuple<String> stringTypedTuple : student1) {
            System.out.println(stringTypedTuple.getValue()+"同学，得了"+stringTypedTuple.getScore()+"分");
        }
    }
    //统计
    @Test
    public void testCount(){
        //统计一个集合中元素
        Long student = redisTemplate.opsForZSet().zCard("student");
        System.out.println(student);
        //根据一个分数区间统计元素数量
        Long count = redisTemplate.opsForZSet().count("student", 50, 100);
        System.out.println(count);
    }
    //删除
    @Test
    public void testRemove(){
        //根据key-value删除 value允许传入多个
        redisTemplate.opsForZSet().remove("student","zhangsan","lisi");
        //根据排名区间删除
        redisTemplate.opsForZSet().removeRange("student",0,1);
        //根据分数区间删除
        redisTemplate.opsForZSet().removeRangeByScore("student",70,90);
    }
}


文章标签：
云数据库 Tair（兼容 Redis）
Java
NoSQL
Redis
关键词：
云数据库 Tair（兼容 Redis）数据类型
springboot云数据库 Tair（兼容 Redis）
Spring Boot增删改查
云数据库 Tair（兼容 Redis）Springboot
云数据库 Tair（兼容 Redis）数据类型增删改查
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
允诺@晴天
目录
相关文章
图南(母晶晶)
|
16天前
|
存储 缓存 NoSQL
解决Redis缓存数据类型丢失问题
解决Redis缓存数据类型丢失问题
图南(母晶晶)
158 85
WangBai
|
1月前
|
存储 NoSQL Redis
redis常见数据类型
Redis 是一种基于内存的键值存储数据库，支持字符串、哈希表、列表、集合及有序集合等多种数据类型，每种类型均有特定用途与适用场景，提供丰富的命令操作，适用于高速数据访问与处理。
WangBai
45 5
蓝易云
|
2月前
|
NoSQL Java API
springboot项目Redis统计在线用户
通过本文的介绍，您可以在Spring Boot项目中使用Redis实现在线用户统计。通过合理配置Redis和实现用户登录、注销及统计逻辑，您可以高效地管理在线用户。希望本文的详细解释和代码示例能帮助您在实际项目中成功应用这一技术。
蓝易云
49 4
蓝易云
|
2月前
|
存储 消息中间件 NoSQL
使用Java操作Redis数据类型的详解指南
通过使用Jedis库，可以在Java中方便地操作Redis的各种数据类型。本文详细介绍了字符串、哈希、列表、集合和有序集合的基本操作及其对应的Java实现。这些示例展示了如何使用Java与Redis进行交互，为开发高效的Redis客户端应用程序提供了基础。希望本文的指南能帮助您更好地理解和使用Redis，提升应用程序的性能和可靠性。
蓝易云
43 1
蓝易云
|
2月前
|
消息中间件 NoSQL Java
Spring Boot整合Redis
通过Spring Boot整合Redis，可以显著提升应用的性能和响应速度。在本文中，我们详细介绍了如何配置和使用Redis，包括基本的CRUD操作和具有过期时间的值设置方法。希望本文能帮助你在实际项目中高效地整合和使用Redis。
蓝易云
69 2
东方睿赢
|
3月前
|
缓存 NoSQL Java
Spring Boot与Redis：整合与实战
【10月更文挑战第15天】本文介绍了如何在Spring Boot项目中整合Redis，通过一个电商商品推荐系统的案例，详细展示了从添加依赖、配置连接信息到创建配置类的具体步骤。实战部分演示了如何利用Redis缓存提高系统响应速度，减少数据库访问压力，从而提升用户体验。
东方睿赢
173 2
听白
|
3月前
|
存储 消息中间件 NoSQL
Redis 数据类型
10月更文挑战第15天
听白
49 1
明弟有理想
|
3月前
|
JSON NoSQL Java
springBoot:jwt&redis&文件操作&常见请求错误代码&参数注解 (九)
该文档涵盖JWT（JSON Web Token）的组成、依赖、工具类创建及拦截器配置，并介绍了Redis的依赖配置与文件操作相关功能，包括文件上传、下载、删除及批量删除的方法。同时，文档还列举了常见的HTTP请求错误代码及其含义，并详细解释了@RequestParam与@PathVariable等参数注解的区别与用法。
明弟有理想
36 2
java冯坚持
|
3月前
|
NoSQL Java Redis
shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。
这篇文章介绍了如何使用Spring Boot整合Apache Shiro框架进行后端开发，包括认证和授权流程，并使用Redis存储Token以及MD5加密用户密码。
java冯坚持
49 0
shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。
刘大猫.
|
2月前
|
JavaScript NoSQL Java
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
刘大猫.
53 0

热门文章

最新文章

  • 1
    详解Spring Batch：在Spring Boot中实现高效批处理
  • 2
    Springboot通过SSE实现实时消息返回
  • 3
    使用 Spring Boot 执行数据库操作：全面指南
  • 4
    什么是JWT？如何使用Spring Boot Security实现它？
  • 5
    深入探索Spring Cloud与Spring Boot：构建微服务架构的实践经验
  • 6
    基于 SpringBoot 和 Vue 开发校园点餐订餐外卖跑腿Java源码
  • 7
    使用Spring Boot编写测试用例：实践与最佳实践
  • 8
    详解FreeMarker Template：在Spring Boot中实现动态内容生成
  • 9
    什么是Apache Kafka？如何将其与Spring Boot集成？
  • 10
    使用Qwen2.5+SpringBoot+SpringAI+SpringWebFlux的基于意图识别的多智能体架构方案
  • 1
    Redis经典问题：数据并发竞争
    507
  • 2
    Redis经典问题：数据不一致
    643
  • 3
    Redis经典问题：缓存击穿
    667
  • 4
    Redis数据结构精讲：选择与应用实战指南
    1335
  • 5
    Redis内存分析工具RDR
    1780
  • 6
    Redis基础命令集详解
    63
  • 7
    Mac上轻松几步搞定Docker与Redis安装：从下载安装到容器运行实测全程指南
    1015
  • 8
    Redis哨兵&分片集群
    102
  • 9
    Redis多级缓存
    64
  • 10
    Redis持久化&Redis主从
    57

    • 相关课程

    更多
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第三阶段
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第四阶段
  • 大数据实战项目 - 反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第六阶段
  • Redis入门实战演练
  • 云数据库 Redis 版使用教程
  • Redis数据库入门

    • 相关电子书

    更多
  • ApsaraDB for Redis——与创客同行
  • 微博的Redis定制之路
  • 云数据库Redis版的开源之路

    • 相关实验场景

    更多
  • 如何通过数据库Redis内网访问
  • Tair for Redis数据闪回：任意时间点数据恢复
  • 如何开通Redis的专属集群
  • 从零搭建Spring Boot的Hello World
  • 基于Redis实现在线游戏积分排行榜
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月