千家信息网

请输入关键字词

热门搜索排行

最新搜索排行

导航： 首页 > 互联网科技 >

SpringBoot集成Redis开启缓存机制的方法

发表于：2026-11-02 作者：千家信息网编辑
千家信息网最后更新 2026年11月02日，本文小编为大家详细介绍"SpringBoot集成Redis开启缓存机制的方法"，内容详细，步骤清晰，细节处理妥当，希望这篇"SpringBoot集成Redis开启缓存机制的方法"文章能帮助大家解决疑惑
千家信息网最后更新 2026年11月02日SpringBoot集成Redis开启缓存机制的方法

本文小编为大家详细介绍"SpringBoot集成Redis开启缓存机制的方法"，内容详细，步骤清晰，细节处理妥当，希望这篇"SpringBoot集成Redis开启缓存机制的方法"文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

集成springboot+redis+mybatis plus的一个小demo

pom文件

    4.0.0    com.wlient    springboot_mq_redis    0.0.1-SNAPSHOT    springboot_mq_redis    Demo project for Spring Boot            1.8        UTF-8        UTF-8        2.3.7.RELEASE                            org.springframework.boot            spring-boot-starter-amqp                            org.springframework.boot            spring-boot-starter-data-redis                            org.springframework.boot            spring-boot-starter-web                            com.baomidou            mybatis-plus-boot-starter            3.4.2                            org.springframework.boot            spring-boot-devtools            runtime            true                            mysql            mysql-connector-java            runtime                            org.projectlombok            lombok            true                            org.springframework.boot            spring-boot-starter-test            test                                                org.junit.vintage                    junit-vintage-engine                                                        junit            junit            test                            org.springframework.amqp            spring-rabbit-test            test                            org.aspectj            aspectjweaver            1.9.6                                    redis.clients            jedis            3.2.0                                    com.github.xiaoymin            knife4j-spring-boot-starter            2.0.7                            com.alibaba            fastjson            1.2.76                                                    org.springframework.boot                spring-boot-dependencies                ${spring-boot.version}                pom                import                                                                org.apache.maven.plugins                maven-compiler-plugin                3.8.1                                    1.8                    1.8                    UTF-8                                                        org.springframework.boot                spring-boot-maven-plugin                2.3.7.RELEASE                                    com.wlient.springboot_mq_redis.SpringbootMqRedisApplication                                                                            repackage                                                    repackage

yaml文件

spring:  redis:    host: 1.117.89.11    port: 6378    password: Terry123456.    timeout: 60s    database: 2    lettuce:      pool:        # 连接池中的最小空闲连接        min-idle: 0        # 连接池中的最大空闲连接        max-idle: 8        # 连接池的最大数据库连接数        max-active: 8        # #连接池最大阻塞等待时间（使用负值表示没有限制）        max-wait: -1ms      #spring cache 配置      cache:        type: redis        redis:          #      key过期时间 半小时          time-to-live: 1800000 #毫秒

CacheConfig

@Configurationpublic class CacheConfig  {        @Bean        CacheManager cacheManager(RedisConnectionFactory connectionFactory) {                RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();                //common信息缓存配置                RedisCacheConfiguration userCacheConfiguration = defaultCacheConfig                                // 设置 key为string序列化                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))                                // 设置value为json序列化                                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())).disableCachingNullValues();                Map redisCacheConfigurationMap = new HashMap<>();                //entryTtl设置缓存失效时间，单位是秒                redisCacheConfigurationMap.put("common", userCacheConfiguration.entryTtl(Duration.ofSeconds(30)));                //设置CacheManager的值序列化方式为JdkSerializationRedisSerializer,但其实RedisCacheConfiguration默认就是使用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value,所以以下注释代码为默认实现                //ClassLoader loader = this.getClass().getClassLoader();                //JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer(loader);                //RedisSerializationContext.SerializationPair pair = RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);                //RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);                Set cacheNames = new HashSet<>();                cacheNames.add("common");                //初始化RedisCacheManager                RedisCacheManager cacheManager = RedisCacheManager.builder(connectionFactory).cacheDefaults(defaultCacheConfig).initialCacheNames(cacheNames).withInitialCacheConfigurations(redisCacheConfigurationMap).build();                return cacheManager;        }}
RedisConfig
package com.wlient.springboot_mq_redis.Configuar;import com.fasterxml.jackson.annotation.JsonAutoDetect;import com.fasterxml.jackson.annotation.PropertyAccessor;import com.fasterxml.jackson.databind.ObjectMapper;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.RedisTemplate;import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;import org.springframework.data.redis.serializer.StringRedisSerializer;@Configurationpublic class RedisConfig {    @Bean    @SuppressWarnings("all")    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {        RedisTemplate template = new RedisTemplate();        template.setConnectionFactory(factory);        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);        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;    }}
SpringCacheConfig
package com.wlient.springboot_mq_redis.Configuar;import org.springframework.boot.autoconfigure.cache.CacheProperties;import org.springframework.boot.context.properties.EnableConfigurationProperties;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.serializer.RedisSerializationContext;import org.springframework.data.redis.serializer.RedisSerializer;/** * spring cache 配置 */@EnableConfigurationProperties(CacheProperties.class)@Configuration@EnableCachingpublic class SpringCacheConfig {    @Bean    public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.string()))                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json()));        CacheProperties.Redis redisProperties = cacheProperties.getRedis();        //将配置文件中所有的配置都生效        if (redisProperties.getTimeToLive() != null) {            config = config.entryTtl(redisProperties.getTimeToLive());        }        if (redisProperties.getKeyPrefix() != null) {            config = config.prefixKeysWith(redisProperties.getKeyPrefix());        }        if (!redisProperties.isCacheNullValues()) {            config = config.disableCachingNullValues();        }        if (!redisProperties.isUseKeyPrefix()) {            config = config.disableKeyPrefix();        }        return config;    }}
RedisService
package com.wlient.springboot_mq_redis.service;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.stereotype.Service;import org.springframework.util.CollectionUtils;import javax.annotation.Resource;import java.util.Collection;import java.util.List;import java.util.Map;import java.util.Set;import java.util.concurrent.TimeUnit;@Servicepublic class RedisService {    @Resource    private RedisTemplate redisTemplate;    // =============================common============================    /**     * 指定缓存失效时间     * @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(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 hmget(String key) {        return redisTemplate.opsForHash().entries(key);    }    /**     * HashSet     * @param key 键     * @param map 对应多个键值     * @return true 成功 false 失败     */    public boolean hmset(String key, Map 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 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 items 项 可以使多个 不能为null     */    public void hdel(String key, Collection items) {        redisTemplate.opsForHash().delete(key, items.toArray());    }    /**     * 判断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 delta 要增加几(大于0)     * @return     */    public double hincr(String key, String item, double delta) {        if (delta < 0) {            throw new RuntimeException("递增因子必须大于0");        }        return redisTemplate.opsForHash().increment(key, item, delta);    }    /**     * hash递减     * @param key 键     * @param item 项     * @param delta 要减少记(小于0)     * @return     */    public double hdecr(String key, String item, double delta) {        if (delta < 0) {            throw new RuntimeException("递减因子必须大于0");        }        return redisTemplate.opsForHash().increment(key, item, -delta);    }    // ============================set=============================    /**     * 根据key获取Set中的所有值     * @param key 键     * @return     */    public Set 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 values 值 可以是多个     * @return 成功个数     */    public long sSet(String key, Collection values) {        try {            return redisTemplate.opsForSet().add(key, values.toArray());        } 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 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 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 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;        }    }}
Application
@SpringBootApplication@MapperScan("com.wlient.springboot_mq_redis.dao")@EnableCachingpublic class SpringbootMqRedisApplication {    public static void main(String[] args) {        SpringApplication.run(SpringbootMqRedisApplication.class, args);    }}
主要是添加@EnableCaching注解开启缓存
缓存有两种方式:
方式一：直接使用对RedisTemplate进行封装的RedisService进行缓存操作
controller层
    @Autowired    RedisService redisService;        @GetMapping("selectOne2")    public ServiceResult selectOne2(Integer id) {        User user =  (User) redisService.get("selectOne2::"+id);        if (user == null){            user = userService.queryById2(id);            redisService.set("selectOne2::"+id,user);        }        System.out.println(user);        return ServiceResult.ok(user);    }
方式二：使用注解
作用于Service层
@Service("userService")@CacheConfig(cacheNames = "departmentsService")public class UserServiceImpl implements UserService {    @Resource    private UserDao userDao;    /**     * 通过ID查询单条数据     *     * @param id 主键     * @return 实例对象     */    @Override    @Cacheable(key = "#root.methodName+':'+#id")    public User queryById(Integer id) {        User user = this.userDao.selectById(id);        return user;    }}
使用注解比较方便，但是不够灵活。
使用封装类增加了代码量，但是可以满足大部分需求
配置文件详解
RedisConfig：redis cache，设置key，value的序列化方式等
SpringCacheConfig：spring cache 配置
这两个文件缺一不可，缺失SpringCacheConfig配置文件，那么存入redis的数据会乱码
CacheConfig：可有可无，只是根据需求采用的配置（从项目里copy的）
读到这里，这篇"SpringBoot集成Redis开启缓存机制的方法"文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注行业资讯频道。


        


        
 很赞哦！ 

        


        



        缓存
            时间
            多个
            序列
            成功
            数据
            方式
            配置
            文件
            个数
            因子
            索引
            方法
            机制
            普通
            最大
            内容
            文章
            注解
            UTF-8
    
数据库的安全要保护哪些东西
数据库安全各自的含义是什么
生产安全数据库录入
数据库的安全性及管理
数据库安全策略包含哪些
海淀数据库安全审计系统
建立农村房屋安全信息数据库
易用的数据库客户端支持安全管理
连接数据库失败ssl安全错误
数据库的锁怎样保障安全

科技与互联网发展
互联网金融公司科技
安徽鑫晟辉互联网科技
易通互联网络科技有限公司
碳银互联网科技有限公司
大白互联网科技
互联网科技公司做什么
互联网科技大会案例
广西拼得多互联网科技有限公司
哈尔滨秒房互联网科技有限公司
佳云科技和互联网广告
湖北码尼互联网科技有限公司电话
阿大互联网科技有限公司
未来五年的互联网科技
链环科技传统企业怎么转型互联网
城市宝互联网科技有限公司
易租星互联网科技有限公司
第三届互联网大会安防黑科技
恒生科技指数 中概互联网
伍佰万互联网科技是干嘛的
保险科技 互联网保险
广东猪兼强互联网科技有限公司
互联网科技工作委员会主任
互联网科技资迅
与互联网科技公司
猫创互联网科技
小米互联网科技园设置
苏州五指互联网络科技有限
洛阳昕诺飞互联网科技有限公司
互联网科技职业技能培训学校
        

        


        
        

        

          
        

      
    


    



    

      

        
相关文章

      

      
    






   





  



































0