SpringBootCatch Redis 缓存

原创已于 2025-05-01 19:22:18 修改 · 1.2k 阅读

20 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#缓存 #redis #数据库

于 2025-01-17 09:56:36 首次发布

Java 专栏收录该内容

50 篇文章

订阅专栏

1. 注解方式使用Redis

1. 依赖

springbootCache：springboot缓存，这里使用注解方式缓存数据，依赖中引入redis，springboot就会使用redis来存放数据，也可以使用其他方式，但是注解不需要改变

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

2. 注解

注解	说明
@EnableCaching	开启缓存注解功能，通常加在启动类上
@Cacheable	在方法执行前先查询缓存中是否有数据，如果有数据，则直接返回缓存数据；如果没有缓存数据，调用方法并将方法返回值放到缓存中
@CachePut	将方法的返回值放到缓存中
@CacheEvict	将一条或多条数据从缓存中删除

3. 注解的使用

@Cacheable

    @Cacheable(cacheNames = "category", key="#categoryId")
    public Result<List<DishVO>> list(Long categoryId) {
		// TODO
        return Result.success(list);
    }

使用在controller方法上，并且是需要返回值
在redis中的key是：category::categoryId的值，categoryId是前端传入的参数，一个:在redis中相当于下一级目录
在redis中的value是此注解方法的返回值
当前端发起查询后，会先从reids中查找对应的key有则返回，没有则执行controller中的方法再返回，并且将返回值保存在redis中

@CachePut：很少用，一般修改后方法不会返回原数据

    @CachePut(cacheNames = "user", key = "#user.id")	// 建议使用 user.id 这种表达式
    // @CachePut(cacheNames = "user", key = "#p0.id")	// 第一个参数的 id 属性
    // @CachePut(cacheNames = "user", key = "#a0.id")	// 第一个参数的 id 属性
    // @CachePut(cacheNames = "user", key = "#result.id")	// 返回结果的 id 属性
    public User save(User user){
		// TODO: 数据库中插入user数据
        return user;
    }

用于插入和更新操作的controller方法上，数据发生变化时改变redis中保存的数据
注解的参数与上面的用法相同
在redis中保存的也是返回值的内容

@CacheEvict

    @CacheEvict(cacheNames = "category", allEntries = true)
    public Result<String> deleteById(Long id){
        // TODO: 数据库中删除 by id
        return Result.success();
    }

用于数据发生删除、更新后，用于删除redis中的数据
allEntries = true，确认删除redis中，category下所有的键值对
@CacheEvict(cacheNames = "category", key="categoryId")，删除指定的key

2. RedisTemplate

上面是通过注解的方式使用Redis，下面是通过RedisTemplate使用Redis

Springboot整合Redis：链接

1. 导入Spring Data Redis 的maven坐标

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

2. 配置Redis数据源

spring:
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 2	# 共有16个库，0-15

3. 编写配置类，配置序列化器

1. 配置序列化器

此配置类不是固定的，可自定义序列化器
spring已经创建好redisTemplate 对象，这里的配置是为了配置redis数据的key和value的序列化器
RedisSerializer.json()使用的是jackson对数据进行序列化

@Configuration
public class RedisConfiguration {
  // 配置spring data radis
  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

      RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
      redisTemplate.setConnectionFactory(redisConnectionFactory);

      redisTemplate.setKeySerializer(RedisSerializer.string());
      redisTemplate.setValueSerializer(RedisSerializer.json());

      redisTemplate.setHashKeySerializer(RedisSerializer.string());
      redisTemplate.setHashValueSerializer(RedisSerializer.json());

      redisTemplate.afterPropertiesSet();
      return redisTemplate;
  }
}

2. 使用fastjson2作为序列化工具

Jackson 无法直接处理 LocalDateTime 类型，这里使用fastjson2作为序列化器
依赖

    <dependency>
      <groupId>com.alibaba.fastjson2</groupId>
      <artifactId>fastjson2</artifactId>
    </dependency>

fastjson2的配置

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONReader;
import com.alibaba.fastjson2.JSONWriter;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import java.nio.charset.Charset;

public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
  public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  private Class<T> clazz;
  public FastJson2JsonRedisSerializer(Class<T> clazz) {
    super();
    this.clazz = clazz;
  }
  @Override
  public byte[] serialize(T t) throws SerializationException{
    if (t == null){ return new byte[0]; }
    return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);
  }
  @Override
  public T deserialize(byte[] bytes) throws SerializationException{
    if (bytes == null || bytes.length <= 0){ return null; }
    String str = new String(bytes, DEFAULT_CHARSET);
    return JSON.parseObject(str, clazz, JSONReader.Feature.SupportAutoType);
  }
}

redisConfig:

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.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
//@EnableCaching
public class RedisConfig {
  @Bean
  @SuppressWarnings(value = { "unchecked", "rawtypes" })
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(connectionFactory);
    FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
    // 使用StringRedisSerializer来序列化和反序列化redis的key值
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(serializer);
    // Hash的key也采用StringRedisSerializer的序列化方式
    template.setHashKeySerializer(new StringRedisSerializer());
    template.setHashValueSerializer(serializer);
    template.afterPropertiesSet();
    return template;
  }
}

4. 通过RedisTemplate对象，对不同类型数据的增删改查

Api	值的类型
redisTemplate.opsForValue()	String	字符串
redisTemplate.opsForHash()	Hash	键值对，类似map
redisTemplate.opsForList()	List	类似于栈的列表
redisTemplate.opsForSet()	Set	集合，不可重复
redisTemplate.opsForZSet()	ZSet	有序集合
redisTemplate	执行常用命令

5. 命令

在要使用redis的类中引入Bean，之后就可以使用了

  @Autowired
  private RedisTemplate<String, Object> redisTemplate;

1. String

    // 设置值
    redisTemplate.opsForValue().set("hello", "world");
    // 通过key获取值
    redisTemplate.opsForValue().get("hello");
    // 指定过期时间，和时间的单位
    redisTemplate.opsForValue().set("hello", "world", 60L, TimeUnit.SECONDS);
    // 在key不存在时设置key的值
    redisTemplate.opsForValue().setIfAbsent("hello", "world");

2. hash

    // 将哈希表 hash1 中的字段 field1 的值设为 value1
    redisTemplate.opsForHash().put("hash1", "field1", "value1");
    // 在哈希表 hash1 中，如果字段 field2 不存在，则设置字段的值为 value2
    redisTemplate.opsForHash().putIfAbsent("hash1", "field2", "value2");
    // 获取哈希表 hash1 中所有字段和值
    redisTemplate.opsForHash().entries("hash1");
    // 获取哈希表 hash1 中字段 field1 的值
    redisTemplate.opsForHash().get("hash1", "field1");
    // 获取哈希表 hash1 中的所有字段
    redisTemplate.opsForHash().keys("hash1");
    // 获取哈希表 hash1 中所有字段的值
    redisTemplate.opsForHash().values("hash1");
    // 删除哈希表 hash1 中的字段 field1
    redisTemplate.opsForHash().delete("hash1", "field1");

3. list

    // 在列表左边插入元素
    redisTemplate.opsForList().leftPush("list1", "value1");
    // 在列表右边插入元素
    redisTemplate.opsForList().rightPush("list1", "value2");
    // 获取列表 list1 中指定索引的元素
    redisTemplate.opsForList().index("list1", 0);
    // 获取列表 list1 中指定范围的元素
    redisTemplate.opsForList().range("list1", 0, -1);
    // 获取列表长度
    redisTemplate.opsForList().size("list1");
    // 移除列表 list1 中的第一个元素，并返回被移除的元素
    redisTemplate.opsForList().leftPop("list1");
    // 移除列表 list1 中的最后一个元素，并返回被移除的元素
    redisTemplate.opsForList().rightPop("list1");

4. set

    // 添加元素到集合中
    redisTemplate.opsForSet().add("set1", "value1", "value2", "value3");
    redisTemplate.opsForSet().add("set2", "value3", "value4", "value5");
    // 获取集合中所有元素
    redisTemplate.opsForSet().members("set1");
    // 判断元素是否在集合中
    redisTemplate.opsForSet().isMember("set1", "value1");
    // 获取集合中的成员数
    redisTemplate.opsForSet().size("set1");
    // 返回给定集合的交集
    redisTemplate.opsForSet().intersect("set1", "set2");
    // 返回给定集合的并集
    redisTemplate.opsForSet().union("set1", "set2");
    // 移除集合中的元素
    redisTemplate.opsForSet().remove("set1", "value1");

5. zset

    // 添加元素到有序集合中
    redisTemplate.opsForZSet().add("zset1", "value1", 11.0);
    redisTemplate.opsForZSet().add("zset1", "value2", 22.0);
    redisTemplate.opsForZSet().add("zset1", "value3", 33.0);
    // 获取有序集合中的所有元素
    redisTemplate.opsForZSet().range("zset1", 0, -1);
    // 获取有序集合中的元素个数
    redisTemplate.opsForZSet().size("zset1");
    // 获取有序集合中指定分数范围内的元素
    redisTemplate.opsForZSet().rangeByScore("zset1", 20, 30);
    // 有序集合中对指定成员的分数加上增量
    redisTemplate.opsForZSet().incrementScore("zset1", "value1", 10.0);
    // 移除有序集合中的元素
    redisTemplate.opsForZSet().remove("zset1", "value1");

6. 常用命令

    // 设置过期时间
    redisTemplate.expire("list1", 60L, TimeUnit.SECONDS);
    // 返回redis中所有的键
    redisTemplate.keys("*");
    // 检查给定的键是否存在
    redisTemplate.hasKey("key");
    // 返回key所储存的值类型
    redisTemplate.type("key");
    // 键存在时，删除键
    redisTemplate.delete("key");
    // 键如果不存在，设置键值；如果不存在返回值是true
    Boolean b = redisTemplate.opsForValue().setIfAbsent("key", "1", 1, TimeUnit.DAYS);
    // 键如果存在，设置键的值；如果键存在并设置成新的值，返回true
    Boolean b = redisTemplate.opsForValue().setIfPresent("key", "1", 1, TimeUnit.DAYS);
    // 自减，键为“key”的值减 1，返回减 1 后的值。默认减 1
    Long decrement = redisTemplate.opsForValue().decrement("key");
    // 自增
    Long increment = redisTemplate.opsForValue().increment("key");

	// 查询所有dish_开头的key
	Set keys = redisTemplate.keys("dish_*")
	// 删除所有的keys的数据，这里的参数可以传入集合，也可以传如单个的key
	redisTemplate.delete(keys)

3. Radis基础

1. 启动Radis服务

redis-server.exe redis.windows.conf

2. Radis的配置文件

配置文件：redis.windows.conf

Redis 配置文件（通常为 redis.conf）是一个文本文件，用于对 Redis 服务器的各种行为和特性进行配置。下面从配置文件结构、核心配置项、加载配置文件的方式等方面为你简要概述：

配置文件结构

redis.conf 文件由一系列的配置指令构成，每个指令占一行，格式为 配置项名配置值。配置文件里存在注释行，以 # 开头，用于解释配置项的用途和提供示例。

核心配置项

1. 通用配置

bind：指定 Redis 服务器监听的 IP 地址。默认值是 127.0.0.1，这意味着 Redis 仅在本地可访问。若要让 Redis 能从外部网络访问，可将其设置为服务器的公网 IP 地址或者 0.0.0.0（监听所有可用的网络接口）。

bind 0.0.0.0

port：指定 Redis 服务器监听的端口号，默认值是 6379。

port 6379

daemonize：指定 Redis 是否以守护进程模式运行。若设置为 yes，Redis 会在后台运行；若设置为 no，Redis 会在前台运行。默认值是 no。

daemonize yes

pidfile：指定 Redis 守护进程的 PID 文件路径。当 Redis 以守护进程模式运行时，会将进程 ID 写入该文件。

pidfile /var/run/redis_6379.pid

2. 日志配置

loglevel：指定日志的级别，可取值为 debug、verbose、notice、warning。默认值是 notice。

loglevel notice

logfile：指定日志文件的路径。若设置为空字符串 ""，日志会输出到标准输出。

logfile /var/log/redis/redis.log

3. 数据持久化配置

save：指定 Redis 进行数据快照的条件。格式为 save <秒> <更改数>，表示在指定的秒数内发生了指定数量的写操作时，Redis 会进行一次数据快照。可以配置多个 save 条件。

save 900 1
save 300 10
save 60 10000

appendonly：指定是否开启 AOF（Append Only File）持久化模式。若设置为 yes，Redis 会将所有写操作追加到 AOF 文件中，以保证数据的持久化。默认值是 no。

appendonly yes

appendfilename：指定 AOF 文件的名称。

appendfilename "appendonly.aof"

4. 安全配置

requirepass：指定 Redis 服务器的访问密码。若设置了密码，客户端在连接 Redis 时需要使用 AUTH 命令进行身份验证。

requirepass your_password

5. 内存管理配置

maxmemory：指定 Redis 服务器使用的最大内存量。当达到该内存限制时，Redis 会根据 maxmemory-policy 配置的策略进行内存回收。

maxmemory 100mb

maxmemory-policy：指定内存达到限制时的回收策略，可取值有 volatile-lru、allkeys-lru、volatile-random 等。
lru：最近使用
lfu：时间段内使用频率

maxmemory-policy volatile-lru

加载配置文件

启动 Redis 服务器时，可以通过 --config 选项指定要加载的配置文件：

redis-server /path/to/redis.conf

若不指定配置文件，Redis 会使用默认的配置。

动态修改配置

在 Redis 运行过程中，也可以使用 CONFIG SET 命令动态修改部分配置项：

CONFIG SET loglevel debug

不过，这种动态修改的配置在 Redis 重启后会失效。若要永久保存修改，需要手动修改配置文件。

3. radis常用命令

1. String：字符串

SET key value			 # 设置指定key的值
GET key			         # 获取指定key的值
SETEX key seconds value  # 设置指定key的值，并将 key 的过期时间设为 seconds 秒
SETNX key value	   	     # 只有在 key 不存在时设置 key 的值

2. hash：哈希

Redis hash 是一个string类型的 field 和 value 的映射表，hash特别适合用于存储对象，常用命令：

HSET key field value 	# 将哈希表 key 中的字段 field 的值设为 value
HGET key field 	        # 获取存储在哈希表中指定字段的值
HDEL key field		    # 删除存储在哈希表中的指定字段
HKEYS key 	        	# 获取哈希表中所有字段
HVALS key 		        # 获取哈希表中所有值

哈希操作命令

3. list：列表

Redis 列表是简单的字符串列表，按照插入顺序排序，常用命令：

LPUSH key value1 [value2] 	# 将一个或多个值插入到列表头部(左边)
RPUSH key value1 [value2]   # 将一个或多个值插入到列表尾部(右边)
LRANGE key start stop 		# 获取列表指定范围内的元素 
LRANGE key 0 -1             # 所有元素
RPOP key 			        # 移除并获取列表最后一个元素(右边)
LLEN key 			        # 获取列表长度

在这里插入图片描述

4. set：集合

Redis set 是string类型的无序集合。集合成员是唯一的，集合中不能出现重复的数据，常用命令：

SADD key member1 [member2] 	# 向集合添加一个或多个成员
SMEMBERS key 		        # 返回集合中的所有成员
SCARD key 			        # 获取集合的成员数
SINTER key1 [key2] 		    # 返回给定所有集合的交集
SUNION key1 [key2] 		    # 返回所有给定集合的并集
SREM key member1 [member2] 	# 删除集合中一个或多个成员

在这里插入图片描述

5. zset：有序集合

Redis 有序集合是string类型元素的集合，且不允许有重复成员。每个元素都会关联一个double类型的分数。常用命令：

ZADD key score1 member1 [score2 member2] 	# 向有序集合添加一个或多个成员
ZRANGE key start stop [WITHSCORES] 		    # 通过索引区间返回有序集合中指定区间内的成员
ZINCRBY key increment member 			    # 有序集合中对指定成员的分数加上增量 increment
ZREM key member [member ...] 			    # 移除有序集合中的一个或多个成员

在这里插入图片描述

示例

zadd zset 11.0 tom 22.0 jerry 31.0 jack

在这里插入图片描述

# 成员不能重复，会给成员关联的分数重新赋值
zadd zset 12.0 tom

在这里插入图片描述

# 关联的分数可以重复
zadd zset 12.0 lili

在这里插入图片描述

6. 通用命令

Redis的通用命令是不分数据类型的，都可以使用的命令：

KEYS pattern 		# 查找所有符合给定模式( pattern)的 key 
EXISTS key 			# 检查给定 key 是否存在
TYPE key 			# 返回 key 所储存的值的类型
DEL key 			# 该命令用于在 key 存在是删除 key

示例

KEYS *			# 返回Radis中所有的key

4. 数据持久化

1. RDB

优点是能生成紧凑的数据集，在恢复数据时速度快，适合大规模数据的备份与恢复；
缺点是可能会因间隔性持久化而导致数据丢失，尤其是在服务器故障时，最后一次快照后的修改可能会丢失

配置：

# 900秒内1次写操作，触发一次数据快照
save 900 1
# 快照保存的目录，./：保存在命令启动时的目录，一般写绝对路径
dir ./ 
# 快照保存名字
dbfilename demp.rdb

关闭RDB：

save ""

关闭RDB后，再次启动Redis会从demp.rdb中恢复快照，之后不会再产生新的快照

2. AOF

优点是通过记录所有写操作，能提供更精细的数据持久化，保证数据的完整性，即使发生故障也只会丢失最后一次写入的部分数据；
缺点是由于不断追加写操作，AOF 文件可能会变得很大，导致占用过多磁盘空间，并且在恢复数据时可能比 RDB 方式慢。

配置：

# 是否开启AOF
appendonly no
# AOF文件名称
appendfilename "appendonly.aof"
# 同步策略
appendfsync everysec | always | no

everysec：每秒同步一次
always：每执行一次写操作就同步一次，性能最低
no：交由操作系统控制，有线程空闲同步