spring中的@Cacheable缓存

1. 使用方法

在方法上面加上注解@Cacheable，

@Override
    @Cacheable(cacheNames = "userCache", key = "#id")
    public User getUserById(Long id) {
        System.out.println("查询数据库了");
        return getById(id);
    }

如果你的项目中引入了，这个依赖会自动的使用reids作为缓存

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

2.切换策略

如果不想使用默认的缓存策略，那么可以再配置文件中制定相关的策略，

spring:
  cache:
    type: caffeine

如果是制定上面的策略需要下载相关的依赖否则可能会报错

<!-- caffeine缓存-->
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
        </dependency>

3.工具类加@CacheConfig制定策略（推荐）

3.1 工具类

代码中制定了两种缓存的策略，1:Caffeine ,2：redis
制定1的换也是要引入相关的依赖文件的。
并且可以配置统一的key的过期时间等配置。

package com.jm.config;

import java.time.Duration;
import java.util.concurrent.TimeUnit;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

/**
 * 本地缓存配置
 */
@Configuration
@EnableCaching
public class CacheConfig {

    @Value("${cache.capacity:100}")
    private Integer capacity;

    @Value("${cache.invalidSeconds:600}")
    private Long invalidSeconds;

    @Value("${cache.maxSize:1000}")
    private Long maxSize;

    @Bean("cacheManager")
    @Primary
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(
            Caffeine.newBuilder().initialCapacity(capacity).expireAfterWrite(invalidSeconds, TimeUnit.SECONDS)
                .maximumSize(maxSize));
        return cacheManager;
    }

    @Bean("redisCacheManager")
    public CacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
            // 设置缓存过期时间为 invalidSeconds
            .entryTtl(Duration.ofSeconds(invalidSeconds));
        return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(config)
            .build();
    }
}

3.2使用方法

在类上加上@CacheConfig注解，并制定对应的缓存策略。配置到类上面就是整个类下面的方法都是这个策略，

@Service
@CacheConfig(cacheManager = "redisCacheManager")
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    @Override
    @Cacheable(cacheNames = "userCache", key = "#id",sync=true)
    public User getUserById(Long id) {
        System.out.println("查询数据库了");
        return getById(id);
    }
}

配置到方法上，只对这个方法生效，这个策略

 @Override
    @Cacheable(cacheNames = "userCache", key = "#id",cacheManager = "cacheManager",sync=true)
    public User getUserById(Long id) {
        System.out.println("查询数据库了");
        return getById(id);
    }在这里插入代码片

sync参数说明

当 sync = true 时，Spring 会同步执行缓存操作，确保在高并发场景下：
只有一个线程会执行方法体
其他线程会等待缓存结果而不是重复执行方法
优点：防止缓存击穿，减少重复计算
缺点：可能造成线程阻塞，增加响应时间

keyGenerator自定义key

备注说明

当然你也可以支持ehcahe，只有当你对数据持久化要求比较高的时候使用，当然我觉得90%的项目都不需要，我们只需要Caffeine就行了，他的性能比ehcache好太多了。