springboot整合redis做缓存管理详解

最新推荐文章于 2025-03-13 17:32:49 发布
最新推荐文章于 2025-03-13 17:32:49 发布
阅读量1.1k 收藏 8
点赞数 2
分类专栏： springboot 文章标签： Springboot redis cache 缓存管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/douya2016/article/details/95915627
版权
本文介绍了Redis的特点、安装方法，以及在Spring Boot中使用Redis做缓存的配置。详细讲解了四种常用序列化器的优缺点，推荐使用GenericJackson2JsonRedisSerializer。还介绍了Spring提供的缓存注解，如@Cacheable、@CacheEvict、@CachePut等，并给出了项目源码下载地址。

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

Redis安装

     Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

     Redis 与其他 key - value 缓存产品有以下三个特点：

  •        Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
  •        Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
  •        Redis支持数据的备份，即master-slave模式的数据备份。

    redis安装传送门

pom.xml依赖

<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
		<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
		
		<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
		
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        
        <dependency>        
		    <groupId>com.fasterxml.jackson.core</groupId>
		    <artifactId>jackson-annotations</artifactId>
		</dependency>
		
		<dependency>
		    <groupId>com.alibaba</groupId>
		    <artifactId>druid-spring-boot-starter</artifactId>
		    <version>1.1.10</version>
		</dependency>
			
		<dependency>
	        <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-devtools</artifactId>
	        <optional>true</optional>
	    </dependency>
	</dependencies>

application.yml配置

server:
  port: 8080
  
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/dycai?useUnicode=true&characterEncoding=utf8&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: "088114"
  redis:
    host: localhost
    port: 6379
    password: 
    database: 0

mybatis:
  mapper-locations: classpath:mapper/*.xml

使用redis做缓存配置

配置部分主要是配置缓存管理器CacheManager 和RedisTemplate

Redis采用key-value存储的存储方式，对key和value需要序列化，常用四种序列化器StringRedisSerializer、JdkSerializationRedisSerializer、Jackson2JsonRedisSerializer、GenericJackson2JsonRedisSerializer的详细介绍如下：

1、StringRedisSerializer：

      优点：开发者友好，轻量级，效率也比较高
                 缺点：只能序列化String类型，如果key使用该序列化器，则key必须为String类型

2、jdkSerializationRedisSerializer：RestTemplate类默认的序列化方式，如果指定序列化器，则为它
                优点：反序列化时不需要提供类型信息（class）
                缺点：a、首先它要求存储的对象都必须实现java.io.Serializable接口，比较笨重
                          b、其次，他存储的为二进制数据，这对开发者是不友好的，无法直观查看数据
                          c、序列化后的结果非常庞大，是JSON格式的5倍左右，这样就会消耗redis服务器的大量内存。  

3、Jackson2JsonRedisSerializer：把一个对象以Json的形式存储，效率高且对调用者友好
                 优点：速度快，序列化后的字符串短小精悍，不需要存储对象实现java.io.Serializable接口
                 缺点：那就是此类的构造函数中有一个类型参数，必须提供要序列化对象的类型信息(.class对象)，反序列化用到了该                              类型信息 

4、GenericJackson2JsonRedisSerializer：基本和上面的Jackson2JsonRedisSerializer功能差不多，使用方式也差不多，但不需要提供类型信息，推荐使用；

以上四种序列化方式如何配置见下面的代码片段，下面的代码片段采用的是StringRedisSerializer序列化key，GenericJackson2JsonRedisSerializer序列化value；

@Configuration
@EnableCaching
public class CacheConfig{
	/**
	 * 配置缓存管理器RedisCacheManager
	 * Redis采用key-value存储的存储方式，对key和value需要序列化
	 * Redis的序列化方式由StringRedisSerializer，JdkSerializationRedisSerializer，GenericJackson2JsonRedisSerializer，GenericJackson2JsonRedisSerializer等
	 * RedisCacheManager默认采用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value
	 * @param redisConnectionFactory
	 * @return
	 */
	@Bean
	public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
//		StringRedisSerializer序列器：
//		优点：开发者友好，轻量级，效率也比较高
//		缺点：只能序列化String类型，如果key使用该序列化器，则key必须为String类型
		RedisSerializer<String> redisSerializer = new StringRedisSerializer();
		
//		jdkSerializationRedisSerializer序列化器：RestTemplate类默认的序列化方式，如果指定序列化器，则为它
//		优点：反序列化时不需要提供类型信息（class）
//		缺点：1、首先它要求存储的对象都必须实现java.io.Serializable接口，比较笨重
//			  2、其次，他存储的为二进制数据，这对开发者是不友好的
//			  3、序列化后的结果非常庞大，是JSON格式的5倍左右，这样就会消耗redis服务器的大量内存。		
//		ClassLoader loader = this.getClass().getClassLoader();
//		JdkSerializationRedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer(loader);
		
//		Jackson2JsonRedisSerializer序列化器：把一个对象以Json的形式存储，效率高且对调用者友好
//		优点：速度快，序列化后的字符串短小精悍，不需要存储对象实现java.io.Serializable接口
//		缺点：那就是此类的构造函数中有一个类型参数，必须提供要序列化对象的类型信息(.class对象)，反序列化用到了该类型信息
//		Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
//		ObjectMapper objectMapper = new ObjectMapper();
//		objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		
//		GenericJackson2JsonRedisSerializer序列化器：基本和上面的Jackson2JsonRedisSerializer功能差不多，使用方式也差不多，
//		但不需要提供类型信息，推荐使用
		GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
		RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
				.entryTtl(Duration.ofMinutes(10))	//设置失效时间
				.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
				.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer));
		
		RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory)
				.cacheDefaults(config)
				.build();
		
		return redisCacheManager;
	}
	
	@Bean
	public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
		RedisTemplate<String, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();		
		template.setKeySerializer(new StringRedisSerializer());
		template.setValueSerializer(genericJackson2JsonRedisSerializer);		
		template.setHashKeySerializer(new StringRedisSerializer());
		template.setHashValueSerializer(genericJackson2JsonRedisSerializer);
		template.afterPropertiesSet();
		return template;
	}
}

实列

代码结构如下

UserController.java

package cn.cai.microservice.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import cn.cai.microservice.entiy.User;
import cn.cai.microservice.service.UserService;

@RestController
public class UserController {	
	private static final Logger log = LoggerFactory.getLogger(UserController.class);
	@Autowired
	private UserService userService;
	
	@PostMapping("/get/UserInfo/{userName}")
	public User getUserInfoByName(@PathVariable(value="userName") String userName) {
		long startTime = System.currentTimeMillis();
		User user =  userService.getUserInfoByName(userName);
		log.info("查询耗时：" + (System.currentTimeMillis() - startTime) + "ms");
		return user;
	}
	
	@PostMapping("/update/UserInfo")
	public void updateUserInfo(@RequestBody User user) {
		userService.updateUserInfo(user);
	}
	
	@PostMapping("/delete/userInfo/{userName}")
	public void deleteUserInfo(@PathVariable(value="userName") String userName) {
		userService.deleteUserInfo(userName);
	}
	
	@PostMapping("/insert/UserInfo")
	public void insertUserInfo(@RequestBody User user) {
		userService.insertUserInfo(user);
	}
	
}

UserDao.java

package cn.cai.microservice.dao;

import cn.cai.microservice.entiy.User;

public interface UserDao {
	User getUserInfoByName(String userName);
	
	void updateUserInfo(User user);
	
	void deleteUserInfo(String userName);
	
	void insertUserInfo(User user);
}

User.java

package cn.cai.microservice.entiy;

import java.io.Serializable;

//如果采用的是JdkSerializationRedisSerializer序列化器序列化value，则存储对象必须实现Serializable接口
//其他序列化器，可以不实现
public class User implements Serializable{

	private static final long serialVersionUID = 1L;
	private String userName;
	private String password;
	private String email;
	
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	@Override
	public String toString() {
		return "User [userName=" + userName + ", password=" + password + ", email=" + email + "]";
	}
}

UserService.java

     Spring提供缓存注解@Cacheable、@CacheEvict、@CachePut

     @Cacheable：如果缓存之中能够查找到，就不执行该注解下面的方法，如果找不到，就执行方法，将方法的返回结果作为value防止到缓存中；

     @CachePut：不管缓存之中能否查找到，该注解下的方法都会被执行，且用返回结果作为value更新缓存

     @CachePut：删除指定key的缓存 

package cn.cai.microservice.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import cn.cai.microservice.dao.UserDao;
import cn.cai.microservice.entiy.User;

@Service
public class UserService {
	private static final Logger log = LoggerFactory.getLogger(UserService.class);	
	@Autowired
	private UserDao userDao;	
	
//	注解@Cacheable：如果缓存之中能够查找到，就不执行该注解下面的方法；
//	如果找不到，就执行方法，将方法的返回结果作为value防止到缓存中；
	@Cacheable(value="userInfoCache", key="#userName")
	public User getUserInfoByName(String userName) {
		log.info("查询" + userName + "信息");
		User user = userDao.getUserInfoByName(userName);
		return user;
	}

//	注解@CachePut：不管缓存之中能否查找到，该注解下的方法都会被执行，且用返回结果作为value更新缓存
	@CachePut(value="userInfoCache", key="#user.userName")
	public User updateUserInfo(User user) {
		log.info("更新" + user.getUserName() + "信息");
		userDao.updateUserInfo(user);	
		return user;
	}

//	注解@CachePut：删除指定key的缓存 
	@CacheEvict(value="userInfoCache", key="#userName")
	public void deleteUserInfo(String userName) {
		log.info("删除" + userName + "信息");
		userDao.deleteUserInfo(userName);	
	}
	
	@CachePut(value="userInfoCache", key="#user.userName")
	public User insertUserInfo(User user) {
		userDao.insertUserInfo(user);
		return user;
	}
	
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

<mapper namespace="cn.cai.microservice.dao.UserDao">

	<select id="getUserInfoByName" resultType="cn.cai.microservice.entiy.User">
		select * from userInfo where userName=#{userName}
	</select>
	
	<update id="updateUserInfo">
		update userInfo set
			password=#{password},
			email=#{email}
		where userName=#{userName} 
	</update>

	<delete id="deleteUserInfo">
		delete from userInfo where userName=#{userName}
	</delete>
	
	<insert id="insertUserInfo">
		insert into 
			userInfo(userName, password, email) values(#{userName}, #{password}, #{email})
	</insert>
</mapper>

SpringbootRedisCacheApplication.java

package cn.cai.microservice;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan({"cn.cai.microservice.dao"})
public class SpringbootRedisCacheApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringbootRedisCacheApplication.class, args);
	}

}

项目源码下载地址：https://github.com/xdouya/springboot-redis-cache

当时调试的时候遇到了很多坑，如有疑问，留言交流。

如果觉得有用，请记得给颗星星哦！

参考：https://www.runoob.com/redis/redis-intro.html

           https://blog.youkuaiyun.com/f641385712/article/details/84679456

 

 

【微服务】SpringBoot 整合Redis实现延时任务处理使用详解
congge
12-19 1万+
SpringBoot 整合Redis实现延时任务处理使用详解
【微服务】springboot整合redis哨兵集群使用详解
congge
08-02 6077
springboot整合redis哨兵集群使用详解
spring+redis作为缓存，带springTest配置
03-27
spring+redis作为缓存，带springTest配置,导入resource下的数据库文件，配置数据库地址和redis地址，点击test文件夹下的测试方法即可运行，也可完善页面运行。
SpringBoot整合Redis来实现缓存技术
无发可说的博客
07-01 268
1.概述 随着互联网技术的发展，对技术要求也越来越高，所以在当期情况下项目的开 发中对数据访问的效率也有了很高的要求，所以在项目开发中缓存技术使用的也越 来越多，因为它可以极大的提高系统的访问速度，关于缓存的框架也种类繁多，比 如 Redis、Ehchahe、JBoss Cache、Voldemort、Cacheonix 等等，今天主要介绍的 是使用现在非常流行的 NoSQL 数据库（Redis）来实现我们的缓存需求。 2.SpringBoot 简介 Spring Boot 是由 Pivotal 团队
redis在SpringBoot中的使用
最新发布
小野喵喵。的博客
03-13 1094
Redis是一个开源的高性能键值对数据库，支持多种数据结构，如字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）等。核心原理1. 单线程模型redis使用单线程处理命令（核心逻辑），避免了多线程竞争问题。通过非阻塞I/O多路复用监听多个客户端连接，高效处理请求。所有操作原子性执行，无需加锁。2. 持久化机制原理：RDB是redis的默认持久化方式，会将redis在内存中的数据生成快照文件保存到硬盘上。
用spring管理redis缓存，使框架更加优雅
qq_29707325的博客
03-25 371
一、配置maven的pom.xml 文件     &lt;!-- redis --&gt; &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&gt;jedis&lt;/artifactId&gt; &lt;version&gt;2.8.1&lt;/version&
Spring boot集成Redis
热门推荐
abombhz的专栏
09-28 5万+
Spring boot集成Activemq 本Markdown编辑器使用[StackEdit][6]修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 新建Spring boot工程 登录http://s
2021-2-19[ springboot 集成spring自定义缓存管理器基于redis ]
AoLuo的博客
02-19 203
引包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 2.代码部分 import org.springframework.cach.
Springboot整合redis注解做缓存
kingtok的博客
09-27 3644
Springboot整合redis注解法做缓存 一般来说数据库的访问量不多的话,是完全不需要实现缓存的,但一旦用户多了起来,你的数据库又不支持缓存机制,及很容易发生宕机,所以我们用到了springboot集成的redis缓存来解决这个问题 主要Maven依赖 <dependencies> <dependency> <groupId>org....
SpringBoot整合redis
weixin_65019617的博客
12-02 909
Redis（Remote Dictionary Server）是一个开源的、高性能的键值对存储系统，常被用作数据库、缓存和消息中间件。Redis 支持多种数据结构，如字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set），并且提供了丰富的功能和操作。
SpringBoot2整合Redis缓存三步骤代码详解
08-24
主要介绍了SpringBoot2整合Redis缓存三步骤,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring 使用 Ehcache 技术指南
FireFox1997
07-06 783
在 Java 企业应用开发中，缓存是一种非常重要的技术，可以有效提高应用的性能和响应速度。Ehcache 是一个非常流行的开源缓存解决方案，广泛应用于各种 Java 应用中。本文将介绍如何在 Spring 框架中集成和使用 Ehcache。
使用Redis作为Spring Boot的缓存管理器步骤
qq_42168543的博客
12-07 583
使用redis作为springboot项目的缓存 Spring Boot 自带了基于ConcurrentHashMap的 Simple 缓存管理器，Simple 只适合单体应用或者开发环境使用，再或者是一个小微系统，通常应用为分布式应用时，则需要集成 EhCache、Redis 等分布式缓存管理器。 给项目添加Redis缓存的步骤： 导入redis缓存的启动器 <dependency> <groupId>org.springframework.boot&
SpringCloud框架如何集成Redis缓存技术
听风动的博客
04-11 2619
1.首先要在spring boot项目pom.xml文件中添加Redis需要的依赖包，可在生成springboot项目选择自动引入： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-...
spring boot利用redis作为缓存
文无第一，武无第二
10-26 1103
在 Spring Boot 中，可以使用 Spring Cache abstraction 来实现缓存功能。Spring Cache abstraction 是 Spring 框架提供的一个抽象层，它对底层缓存实现（如 Redis、Ehcache、Caffeine 等）进行了封装，使得在不同的缓存实现之间切换变得更加方便。Spring Cache Abstraction 的实现原理主要是通过在运行时动态创建代理对象来实现的。
SpringBoot使用Redis实现缓存
少年闰土
03-10 669
上一章已经介绍了如何在 SpringBoot 中如何使用缓存，本章将介绍如何将缓存和 Redis 结合使用。
docker安装redis连接redis可视化工具Redis Desktop Manager+springboot项目使用Cache缓存+springboot项目整合 Redis 实现缓存
小宋的博客
06-11 3948
今天进一步学习了redis的相关知识，希望下面的博客可以给博友们带来帮助。 docker安装redis连接Redis Desktop Manager 启动docker (系统控制ctl:control) systemctl start docker 查找Docker Hub上的redis镜像 docker search redis 这里我们拉取官方的默认redis镜像 docker pu...
Spring Security结合Redis实现缓存功能
xxxzzzqqq_的博客
03-10 673
本文简单介绍了下 Redis 的使用，结合 SpringSecurity 用于用户注册时增加验证码校验逻辑，以及用户登录时将用户名存储到 Redis 中，以供后续使用。验证码的逻辑在实际项目中可以添加，用户信息存储则推荐考虑 JWT，本文案例还未自定义授权处理逻辑，相对来说还是较简单。
四、SpringBoot封装整合Redis缓存实战
believer
04-11 2602
目录SpringBoot封装整合Redis缓存实战一、从零开始认识 redis1.1、redis 概述1.2、redis 安装1.3、redis 图形管理工具的安装二、redis 常用命令操作2.1、redis的数据类型2.1.1、字符串类型 string2.1.2、哈希类型 hash2.1.3、列表类型 list2.1.4、集合类型 set2.1.5、有序集合类型 sortedset2.2、常用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值