springboot项目添加redis

最新推荐文章于 2025-06-03 21:18:25 发布
最新推荐文章于 2025-06-03 21:18:25 发布
阅读量5.8k 收藏 11
点赞数 6
CC 4.0 BY-SA版权
分类专栏： redis学习总结 spring学习总结
知识共享。
本文链接：https://blog.csdn.net/xiaoyu19910321/article/details/80598777
本文介绍如何在Spring Boot项目中集成Redis，包括添加依赖、配置属性、创建配置类及工具类，并提供了一些基本的Redis操作示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

准备一个hello Word的maven springboot 项目

添加redis maven依赖

打开项目 pom.xml 添加

<!-- redis添加 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
update 下载相应jar，构建项目。

添加redis的配置文件

编辑 appliation.propertise,添加如下代码

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0

添加 redis配置文件 .java

新建redisConfig.java,添加如下代码

package com.lushunde.demo;

import java.lang.reflect.Method;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * @Description redis加载
 * @ClassName RedisConfig
 * @Date 2017年9月10日
 * @author chendy
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 生成key的策略
     *
     * @return
     */
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

     @Bean
     public CacheManager  CacheManagercacheManager(RedisTemplate<?,?> redisTemplate) {
     CacheManager cacheManager = new RedisCacheManager(redisTemplate);
     return cacheManager;
     }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);

        // 修改rdis默认序列化方式为StringRedisSerializer
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(stringRedisSerializer);

        return redisTemplate;
    }

}

添加工具类

添加redisUtil.java

主要封装了redis操作String的方法

package com.lushunde.demo.redis;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

/**
 * @Description redis工具类
 * @ClassName RedisConfig
 * @Date 2017年9月10日
 * @author chendy
 */
@Service
public class RedisUtils {

    @Autowired
    private RedisTemplate<String,Object> 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
     * @return
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key);
    }
    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    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=============================  

    /**
     * 模糊查询key
     * @Title: keys
     * @param @param key
     * @return Set<String> key的集合
     */
    public Set<String> keys(String key) {
        return redisTemplate.keys(key);
    }

    /** 
     * 普通缓存获取 
     * @param key 键 
     * @return 值 
     */  
    public Object get(String key){  
        return key==null? null:redisTemplate.opsForValue().get(key);  
    }  

    /**
     * 普通缓存多个获取
     * @Title: mGet
     * @param key  String类型，以","号分割的多个键
     * @return Object   值
     */
    public Object mGet(String key){
        if (null == key || key.isEmpty()) {
            return null;
        }
        String[] keys = key.split(",");
        return mGet(keys);
    }
    /**
     * 普通缓存多个获取
     * @Title: mGet
     * @param key  String数组类型的多个键
     * @return Object   值
     */
    public Object mGet(String[] keys){
        if (null == keys || 0 == keys.length) {
            return null;
        }
        return mGet(Arrays.asList(keys));
    }
    /**
     * 普通缓存多个获取
     * @Title: mGet
     * @param key  List类型的多个键
     * @return Object   值
     */
    public Object mGet(List<String> keys){
        if (null == keys || 0 == keys.size()) {
            return null;
        }
        return redisTemplate.opsForValue().multiGet(keys);
    }  

    /** 
     * 普通缓存放入 
     * @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 @param map 多个键值对
     * @return true成功 false 失败 
     */
    public boolean mSet(Map<String,Object> map){  
        try {
            redisTemplate.opsForValue().multiSet(map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }  

    /** 
     * 递增 
     * @param key 键 
     * @param by 要增加几(大于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 by 要减少几(小于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 值 
     * @param time 时间(秒) 
     * @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 值 
     * @param time 时间(秒) 
     * @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
     */
    @Resource
    private RedisUtils redisUtils;

    @Scheduled(cron = "0/15 * * * * ?") //每天开始15秒执行一次
    public void test(){
        String s = (String) redisUtils.get("a");
        System.out.println(s);


        //redisUtils.hdecr(key, item, by)
    }
【SpringBoot】50、SpringBoot为Redis的key统一加上前缀
Asurplus
08-12 21万+
我们在实际的项目应用中，Redis一般都是用来缓存热点数据，一台服务器可能部署了多个应用，应用直接的 Redis 数据需要加上前缀区分开来，我们可以使用序列化的方式，统一为所有的 key 加上前缀 一、关于在 SpringBoot 中整合 Redis https://lizhou.blog.csdn.net/article/details/98358258 二、关于在 SpringBoot 中整合 Redis 实现序列化存储Java对象 https://lizhou.blog.csdn.net/artic
SpringBoot——整合Redis
戏拈秃笔的博客
05-25 908
SpringBoot整合Redis的一个典型小项目示例
Springboot项目中对Redis的使用
m0_64245578的博客
04-27 473
在pom.xml文件中添加Springboot的Redis依赖；
Spring Boot 整合 Redis 超详细教程
weixin_44966143的博客
02-28 5090
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。话不多说直接干货！！！
176. SpringBoot 整合 Redis
最新发布
weixin_43484713的博客
06-03 1355
本文介绍了SpringBoot整合Redis的基础配置方法。首先需要添加spring-boot-starter-data-redis核心依赖，可选用Lettuce或Jedis客户端。配置方面详细讲解了单机、集群和哨兵模式的连接参数设置，包括连接池优化和SSL安全连接。同时解析了SpringBoot的Redis自动配置原理，包括条件检查、连接工厂创建和模板配置流程。文章还提供了自定义配置示例，如覆盖默认RedisTemplate配置的方法。
【项目搭建三】SpringBoot引入redis
herogus的博客
01-20 940
springboot引入redis，使用Spring Data Redis访问和操作redis，使用lettuce或者jedis作为连接池，使用fastjson2作为序列化方式。
springboot项目使用Redis
d_liangzai的博客
06-28 1135
Redis的主要作用就是缓存数据，通常，会将关系型数据库（例如MySQL等）中的数据读取出来，写入到Redis中，后续，当需要获取数据时，将优先从Redis中读取，而不是从关系型数据库中读取。(当然也可以自定义，省省吧，没必要，一个方法而已)当服务器端启动时，就读取MySQL数据库，并将相关数据写入到Redis中，使得“启动完成时，Redis中就已经存入了需要缓存的数据”，这种做法称之为“缓存预热”。第一步，既然是对redis的操作，自然要先写对redis的操作，也就是redis接口和实现类，以方便调用。
SpringBoot项目中使用redis
qq_39176307的博客
05-10 6639
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、引入redis依赖二、配置application.properties三、编写配置类1、操作string2、操作list3、操作hash4、操作set5、操作zset完整代码总结 前言 简单介绍一下，springboot项目中如何使用redis。 一、引入redis依赖 <!-- redis依赖包 --> <dependency> <groupId>org.springframew.
多个SpringBoot项目采用redis实现Session共享功能
09-08
要实现SpringBoot项目中的Redis Session共享，首先需要在项目中添加必要的依赖。需要在`pom.xml`文件中引入`spring-boot-starter-data-redis`和`spring-session-data-redis`这两个依赖。这两个依赖分别提供了Spring ...
springboot3整合redis
m0_74825526的博客
02-15 1219
来源于。
Springboot项目中使用Redis
热门推荐
诗水人间
07-26 11万+
加入redis依赖 版本号由父工程管理 <!-- spring-boot 的redis依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 单节点配置Redis spring: redis:
SpringBoot项目使用redis缓存
hequnwang10的博客
07-31 321
这篇教程主要实现如何将redis整合到redis项目中。如何使用docker安装redis在这篇《docker安装redis》教程中讲解了 一、添加依赖 pom.xml <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId>
SpringBoot项目中Redis的使用
qq_45089709的博客
05-23 1121
在Spring Boot项目中使用Redis作为缓存或数据存储的步骤如下：首先，在pom.xml中添加Spring Data Redis依赖，并可选地添加连接池依赖。接着，在application.yml或application.properties中配置Redis服务器信息，包括主机、端口、密码等。如果需要自定义序列化方式，可以配置RedisTemplate，设置键和值的序列化器。然后，通过RedisTemplate进行常见的Redis操作，如存储、获取、删除键值对，以及操作哈希表、列表、集合等。此外，可
Spring Boot 接入 Redis
a35038438的博客
04-02 2368
Redis 是一种访问速度非常快的内存数据结构存储，用作数据库、缓存、消息代理和流引擎。提供 strings、hashes、lists、sets 等数据结构。可以解决会话缓存、消息队列、分布式锁、定期将数据集存储到硬盘等功能。通过 Redis 设计实现更详细的功能可查阅文章底部连接，特别是接口文档，它涵盖了所有可实现功能。
SpringBoot 使用redis
qq_65142821的博客
04-06 2091
【代码】SpringBoot 使用redis。
Spring Boot中使用Redis
shaopengjie的博客
08-23 1万+
1.Redis是基于内存的key-value结构数据库优点：基于内存存储，读写性能高适合存储热点数据（短时间被被大量用户读取的数据）2.NoSQL,泛指非关系型数据库，是关系型数据库的补充3.Redis应用场景：缓存，任务队列，消息队列，分布式锁,下载的redis是源文件，需要进行编译安装，Windows版本百度即可5.Linux下安装Redis安装过程中如果报错：You need tcl x.x or newer in order to run the Redis test。
springboot使用redis
m0_67401055的博客
08-02 5207
服务端,启动后不要关闭客户端,访问redis中的数据redis的图形界面客户端,执行方式是在这个文件的目录执行或者在这个jar包的目录下点击即可直接执行点击server,点击add,设置端口号就可以访问redis了。...
Springboot整合Redis
桂林电子科技大学 -芳
03-29 4549
首先我们要知道Redis是什么：Redis一个NoSQL数据库，常用作缓存使用( cache )，用户访问应用，如果找数据的话会先访问redis，如果redis中有数据的话就直接返回发给用户，如果redis中没有的话我们再去查数据库，找到了数据之后一方面存到redis中，另一方面再反馈给用户，目的是说如果用户下次再访问类似的数据的话，redis中就有了。Redis如何启动：双击；客户端双击exit就退出了。
SpringBoot使用Redis
qq_42799562的博客
01-06 240
Redis官网，安装教程我前面的文章Windows搭建Redis集群已经介绍过，如果还是不太明白，参照菜鸟教程，还是相当详细的。安装完成，服务正常启动如图： 使用IDEA创建一个SpringBoot项目： 添加pom.xml依赖 <!--Web--> <dependency> <groupId>org.springframework.boot</groupId> <artif.
springboot项目连接redis
03-20
首先需向项目的 Maven 构建文件中加入必要的依赖项： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis <groupId>org.springframework.boot <artifactId>spring-boot...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值