文章目录
基于Spring的Redis+ehcache
Redis 缓存配置
在项目中添加 Redis 的依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
示例 Redis 配置
spring:
redis:
host: 127.0.0.1
port: 6379
password: 123456
database: 1
在上述配置文件中，host 和 port 属性指定了 Redis 服务器的主机名和端口号，password 属性用于指定 Redis 服务器的密码（如果有的话），而 database 属性则指定了 Redis 服务器使用的数据库编号。
Redis 的默认序列化器是 JdkSerializationRedisSerializer，但是在实际使用中，由于其序列化后的大小通常比较大，因此我们通常使用 StringRedisSerializer 或者 Jackson2JsonRedisSerializer 将缓存值序列化为字符串或者 JSON 格式。以下是一个自定义序列化器的示例
@Configuration
public class RedisConfig{
/**
* redisTemplate 默认使用JDK的序列化机制, 存储二进制字节码, 所以自定义序列化类
* @param redisConnectionFactory redis连接工厂类
* @return RedisTemplate
*/
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory
redisConnectionFactory) {
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
// 使用Jackson2JsonRedisSerialize 替换默认序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL,
JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
// 设置value的序列化规则和 key的序列化规则
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}
通过自定义 Bean 配置了 RedisTemplate，使用 StringRedisSerializer 序列化 Redis 键，并使用 Jackson2JsonRedisSerializer 序列化 Redis 值为 JSON 格式。
yml 配置如下
spring:
cache:
type: redis
redis:
cache-null-values: false #查询结果为 null 不进行缓存
time-to-live: 90000ms #缓存毫秒 设置过期时间
use-key-prefix: true #配置key的前缀 如果指定了前缀，就用指定的，如果没有，就默认使
# 用缓存的名字作为前缀
cache-names: userCache #缓存名称列表
@Cacheable 注解
@Service
public class UserService {
@Cacheable(value = "userCache", key = "#id")
public User getUserById(Long id) {
// 查询用户并返回
}
}
@Cacheable 注解用于标记 getUserById 方法，而 value 属性则用于指定缓存的存储区域的名称。Redis 中的 key 将由 Cacheable 注解中的 key 属性指定。
此例中，key 属性设置为 #id，意味着将使用方法参数 id 作为 Redis 缓存的键。
以多个参数作为 key 来缓存数据。可以对 key 属性使用表达式 language（SpEL）来设置多个参数。
@Service
public class UserService {
@Cacheable(value = "userCache", key = "#id + '_' + #name")
public User getUserByIdAndName(Long id, String name) {
// 查询用户并返回
}
}
此例中，使用表达式语言（SpEL）将 id 和 name 两个参数组合成了一个 Redis 缓存键。
@CacheEvict 注解
清除 Redis 缓存中的数据
@Service
public class UserService {
@Cacheable(value = "userCache", key = "#id")
public User getUserById(Long id) {
// 查询用户并返回
}
@CacheEvict(value = "userCache", key = "#id")
public void deleteUserById(Long id) {
// 删除用户并返回
}
@CacheEvict(value = "userCache", allEntries = true)
public void deleteAllUsers() {
// 删除所有用户并返回
}
}
此例中，添加了删除单个用户和删除所有用户两个方法，allEntries 属性为 true 以删除所有缓存中的数据。
缓存配置
期望的使用方式
@Cacheable(cacheNames = "demoCache#3600", key = "#id")
通过 # 分隔，后面部分表示此 Cache 的TTL（单位：秒）
删除 yml 的 cache 配置，保留 redis 配置。
spring:
redis:
host: 127.0.0.1
port: 6379
password: 123456
database: 1
编写配置类
/**
* @Description: redis缓存配置类
*/
public class MyRedisCacheManager extends RedisCacheManager {
public MyRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
super(cacheWriter, defaultCacheConfiguration);
}
public RedisCache createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) {
String arrays[] = StringUtils.delimitedListToStringArray(name,"#");
// proCache#1000
if(arrays.length > 1){
name = arrays[0];
cacheConfig = cacheConfig.entryTtl(Duration.ofSeconds(Long.parseLong(arrays[1])));
}
return super.createRedisCache(name,cacheConfig);
}
}
/**
* @Description: Redis配置类
*/
@Configuration
@EnableCaching //开启缓存
public class RedisConfig extends CachingConfigurerSupport {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.database}")
private int database;
@Bean
public CacheManager cacheManager() {
//默认配置
RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(60)) //默认时间
.computePrefixWith(cacheName -> "myCache:" + cacheName);
MyRedisCacheManager myRedisCacheManager =
new MyRedisCacheManager(
RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory())
,defaultCacheConfig);
return myRedisCacheManager;
}
@Bean
public RedisConnectionFactory redisConnectionFactory() {
//创建连接Redis工厂
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setHostName(host);
redisStandaloneConfiguration.setPort(port);
redisStandaloneConfiguration.setDatabase(database);
redisStandaloneConfiguration.setPassword(password);
LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration);
return factory;
}
/**
* redisTemplate 默认使用JDK的序列化机制, 存储二进制字节码, 所以自定义序列化类
* @param redisConnectionFactory redis连接工厂类
* @return RedisTemplate
*/
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory
redisConnectionFactory) {
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
// 使用Jackson2JsonRedisSerialize 替换默认序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL,
JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
// 设置value的序列化规则和 key的序列化规则
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}
测试
@Service
public class ProviderServiceImpl implements ProviderService {
@Resource
ProviderMapper providerMapper;
@Cacheable(cacheNames = "proList#2000")
@Override
public ResultLayui findList() {
return ResultLayui.success(providerMapper.findListCount(),providerMapper.findList());
}
@Cacheable(cacheNames = "proByid#100", key = "#id")
@Override
public ResultJSON findById(Integer id) {
return ResultJSON.success(providerMapper.findById(id));
}
}
调用 controller 层相关 API 接口
@RestController
@RequestMapping("/provider")
@CrossOrigin // 跨域请求
@Slf4j
public class ProviderController {
@Resource
private ProviderService providerService;
@GetMapping("/lists")
public ResultLayui list(){
return providerService.findList();
}
@GetMapping("/byId")
public ResultJSON byId(Integer id){
return ResultJSON.success(providerService.findById(id));
}
}
http://localhost:8080/provider/lists
http://localhost:8080/provider/byId?id=1
http://localhost:8080/provider/byId?id=2
