Spring缓存使用
缓存注解
对于Spring，缓存组件例如EhCache是可拔插的，而缓存注解是通用的。
@Cacheable
标记在方法或者类上，标识该方法或类支持缓存。Spring调用注解标识方法后会将返回值缓存到redis，以保证下次同条件调用该方法时直接从缓存中获取返回值。这样就不需要再重新执行该方法的业务处理过程，提高效率。
@Cacheable常用的三个参数如下：
cacheNames 缓存名称
key 缓存的key，需要注意key的写法哈
condition 缓存执行的条件，返回true时候执行
cacheManager 使用的cacheManager的bean名称
sync 如果多个请求同时来访问同一个key的数据，则sync表示加锁同步，等第一个请求返回数据后，其他请求直接获取缓存里的数据。
@Cacheable(value = "DICT", key = "'getDictById'+#id", sync = true)
@CachePut
标记在方法或者类上，标识该方法或类支持缓存。每次都会执行目标方法，并将执行结果以键值对的形式存入指定的缓存中。
@CachePut(value = "DICT", key = "'getDictById'+#model.getId()")
@CacheEvict
@CacheEvict是用来标注在需要清除缓存元素的方法或类上的。@CacheEvict可以指定的属性有value、key、condition、allEntries和beforeInvocation。其中value、key和condition的语义与@Cacheable对应的属性类似。即
value表示清除操作是发生在哪些Cache上的（对应Cache的名称）；
key表示需要清除的是哪个key，如未指定则会使用默认策略生成的key；
condition表示清除操作发生的条件。
allEntries是boolean类型，表示是否需要清除缓存中的所有元素。默认为false，表示不需要。当指定了allEntries为true时，Spring Cache将忽略指定的key。
beforeInvocation 清除操作默认是在对应方法成功执行之后触发的，即方法如果因为抛出异常而未能成功返回时也不会触发清除操作。当我们指定该属性值为true时，Spring会在调用该方法之前清除缓存中的指定元素。
@CacheEvict(value = "DICT",key = "'getDictById'+#model.getId()",beforeInvocation=false)
使用Ehcache作为缓存
pom坐标
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.8.3</version>
</dependency>
<!-- Ehcache依赖此组件创建bean -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
ehcache.xml 配置文件
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
updateCheck="false">
<diskStore path="java.io.tmpdir/Tmp_EhCache" />
<!-- defaultCache，是默认的缓存策略 -->
<!-- 如果你指定的缓存策略没有找到，那么就用这个默认的缓存策略 -->
<!-- external：缓存对象是否一直存在，如果设置为true的话，那么timeout就没有效果，缓存就会一直存在，一般默认就是false -->
<!-- maxElementsInMemory：内存中可以缓存多少个缓存条目 -->
<!-- overflowToDisk：如果内存不够的时候，是否溢出到磁盘 -->
<!-- diskPersistent：是否启用磁盘持久化的机制，在jvm崩溃的时候和重启之间 -->
<!-- timeToIdleSeconds：对象最大的闲置的时间，如果超出闲置的时间，可能就会过期 单位：秒 当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大-->
<!-- timeToLiveSeconds：对象最多存活的时间 单位：秒 当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是存活时间无穷大-->
<!-- memoryStoreEvictionPolicy：当缓存数量达到了最大的指定条目数的时候，需要采用一定的算法，从缓存中清除一批数据，LRU，最近最少使用算法，最近一段时间内，最少使用的那些数据，就被干掉了 -->
<defaultCache
eternal="false"
maxElementsInMemory="1000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
memoryStoreEvictionPolicy="LRU" />
<!-- 手动指定的缓存策略 -->
<!-- 对不同的数据，缓存策略可以在这里配置多种 -->
<cache
name="local"
eternal="false"
maxElementsInMemory="1000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
memoryStoreEvictionPolicy="LRU" />
</ehcache>
EhcacheConfiguration.java
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
@Configuration
@EnableCaching
public class EhcacheConfiguration {
@Bean
public EhCacheManagerFactoryBean cacheManagerFactoryBean(){
EhCacheManagerFactoryBean bean = new EhCacheManagerFactoryBean();
bean.setConfigLocation(new ClassPathResource("ehcache.xml"));
bean.setShared(true);
return bean;
}
@Bean
public EhCacheCacheManager ehCacheCacheManager(EhCacheManagerFactoryBean bean){
return new EhCacheCacheManager(bean.getObject());
}
}
使用
@Service
public class EhcahceServiceImpl implements EhcahceService {
private static final String CACHE_STRATEGY = "local";
@CachePut(value=CACHE_STRATEGY,key="#root.methodName+#info.getProduct_id()")
@Override
public ProductInfo saveProductInfo(ProductInfo info) throws Exception {
return info;
}
@Cacheable(value=CACHE_STRATEGY,key="#root.methodName+#id")
@Override
public ProductInfo getProductInfoById(Long id) throws Exception {
return null;
}}
使用redis作为缓存
pom坐标
<!--redis 配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<exclusions>
<exclusion>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
yml配置
spring:
# redis配置
redis:
password: 123456
# 集群模式
cluster:
nodes: 127.0.0.1:1000,127.0.0.1:2000
# 哨兵模式
#sentinel:
#master: sentinel #哨兵的名字 #下面是所有哨兵集群节点
#nodes: 11.11.11.111:26379,11.11.11.111:26380
jedis:
pool:
#最大连接数
max-active: 200
#最大阻塞等待时间(负数表示没限制)
max-wait: -1
#最大空闲
max-idle: 8
#最小空闲
min-idle: 0
#连接超时时间
expireSecond: 604800 #7天
redisCacheManage配置
此处设计了两种不同cacheName的redis缓存
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
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.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
@Configuration
@EnableCaching
@Slf4j
public class CacheConfig {
@Value("${spring.redis.expireSecond}")
private Integer expireSecond;
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
return new RedisCacheManager(
RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
this.getRedisCacheConfigurationWithTtl(600), // 默认策略，未配置的 key 会使用这个
this.getRedisCacheConfigurationMap() // 指定 key 策略
);
}
private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
redisCacheConfigurationMap.put("Dict", this.getRedisCacheConfigurationWithTtl(600));
redisCacheConfigurationMap.put("COL_KEY", this.getRedisCacheConfigurationWithTtl(expireSecond));
return redisCacheConfigurationMap;
}
private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
RedisCacheConfiguration config = RedisCacheConfiguration
.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
.entryTtl(Duration.ofSeconds(seconds));
return config;
}
}
使用同上
同时使用两种缓存
配置
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.ClassPathResource;
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;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
@Configuration
@EnableCaching
@Slf4j
public class CacheConfig {
@Value("${spring.redis.expireSecond}")
private Integer expireSecond;
@Bean
public EhCacheManagerFactoryBean cacheManagerFactoryBean() {
EhCacheManagerFactoryBean bean = new EhCacheManagerFactoryBean();
bean.setConfigLocation(new ClassPathResource("ehcache.xml"));
bean.setShared(true);
return bean;
}
@Bean
@Primary
public EhCacheCacheManager ehCacheCacheManager(EhCacheManagerFactoryBean bean) {
return new EhCacheCacheManager(bean.getObject());
}
@Bean
public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
// 使用缓存的默认配置
RedisCacheConfiguration config = RedisCacheConfiguration
.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
.entryTtl(Duration.ofSeconds(expireSecond));
RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config);
return builder.build();
}
}
指定缓存使用
@Cacheable(value = CACHE_NAME, key = "#root.methodName+#code",cacheManager = "redisCacheManager")
当redis出现问题时，如何禁用redis，直连数据库
1.yml配置文件忽略掉redis配置
spring.autoconfigure.exclude:org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
2.根据条件加载CacheConfig类，当spring.redis.useRedis=true时加载，否则不加载
@ConditionalOnProperty(prefix = "spring.redis", value = "useRedis", havingValue = "true", matchIfMissing = true)
public class CacheConfig{}
Redis工具类
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnection;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;
import javax.annotation.Resource;
@Service
@ConditionalOnProperty(prefix = "spring.redis", value = "useRedis", havingValue = "true", matchIfMissing = true)
public class RedisService {
@Resource
private RedisConnectionFactory redisConnectionFactory;
//会出现循环依赖---Circular reference
//RedisService引用JedisPool--JedisPool在RedisService，只有创建RedisService的实例才可以获取JedisPool的bean
//所以需要单独拿出JedisPool的bean
/**
* 获取单个对象
*
* @param prefix
* @param key
* @param data
* @return
*/
public <T> T get(KeyPrefix prefix, String key, Class<T> data) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
//生成真正的key className+":"+prefix; BasePrefix:id1
String realKey = prefix.getPrefix() + key;
String sval = jedis.get(realKey);
//将String转换为Bean入后传出
T t = stringToBean(sval, data);
return t;
} finally {
returnToPool(jedisConnection);
}
}
/**
* 移除对象,删除
*
* @param prefix
* @param key
* @return
*/
public boolean delete(KeyPrefix prefix, String key) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
String realKey = prefix.getPrefix() + key;
long ret = jedis.del(realKey);
return ret > 0;//删除成功，返回大于0
} finally {
returnToPool(jedisConnection);
}
}
/**
* 设置单个、多个对象
*
* @param prefix
* @param key
* @param value
* @return
*/
public <T> boolean set(KeyPrefix prefix, String key, T value) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
String realKey = prefix.getPrefix() + key;
String s = beanToString(value);
if (s == null || s.length() <= 0) {
return false;
}
int seconds = prefix.getExpireSeconds();
if (seconds <= 0) { //永不过期
jedis.set(realKey, s);
} else {
jedis.setex(realKey, seconds, s);
}
return true;
} finally {
returnToPool(jedisConnection);
}
}
/**
* 减少值
*
* @param prefix
* @param key
* @return
*/
public <T> Long decr(KeyPrefix prefix, String key) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
String realKey = prefix.getPrefix() + key;
return jedis.decr(realKey);
} finally {
returnToPool(jedisConnection);
}
}
/**
* 增加值
*
* @param prefix
* @param key
* @return
*/
public <T> Long incr(KeyPrefix prefix, String key) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
String realKey = prefix.getPrefix() + key;
return jedis.incr(realKey);
} finally {
returnToPool(jedisConnection);
}
}
/**
* 获取key的过期时间
*/
public <T> Long ttl(KeyPrefix prefix, String key) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
String realKey = prefix.getPrefix() + key;
return jedis.ttl(realKey);
} finally {
returnToPool(jedisConnection);
}
}
/**
* 设置key的过期时间
*/
public <T> void setExpire(KeyPrefix prefix, String key, int expire) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
String realKey = prefix.getPrefix() + key;
jedis.expire(realKey, expire);
} finally {
returnToPool(jedisConnection);
}
}
/**
* 检查key是否存在
*
* @param prefix
* @param key
* @return
*/
public <T> boolean exitsKey(KeyPrefix prefix, String key) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
String realKey = prefix.getPrefix() + key;
return jedis.exists(realKey);
} finally {
returnToPool(jedisConnection);
}
}
/**
* 将字符串转换为Bean对象
* <p>
* parseInt()返回的是基本类型int 而valueOf()返回的是包装类Integer
* Integer是可以使用对象方法的 而int类型就不能和Object类型进行互相转换 。
* int a=Integer.parseInt(s);
* Integer b=Integer.valueOf(s);
*/
public static <T> T stringToBean(String s, Class<T> clazz) {
if (s == null || s.length() == 0 || clazz == null) {
return null;
}
if (clazz == int.class || clazz == Integer.class) {
return ((T)Integer.valueOf(s));
} else if (clazz == String.class) {
return (T)s;
} else if (clazz == long.class || clazz == Long.class) {
return (T)Long.valueOf(s);
} else {
JSONObject json = JSON.parseObject(s);
return JSON.toJavaObject(json, clazz);
}
}
/**
* 将Bean对象转换为字符串类型
*
* @param <T>
*/
public static <T> String beanToString(T value) {
//如果是null
if (value == null) {
return null;
}
//如果不是null
Class<?> clazz = value.getClass();
if (clazz == int.class || clazz == Integer.class) {
return "" + value;
} else if (clazz == String.class) {
return "" + value;
} else if (clazz == long.class || clazz == Long.class) {
return "" + value;
} else {
return JSON.toJSONString(value);
}
}
private void returnToPool(JedisConnection jedisConnection) {
if (jedisConnection != null) {
RedisConnectionUtils.releaseConnection(jedisConnection, redisConnectionFactory);
}
}
public <T> boolean set(String key, T value) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
//将T类型转换为String类型
String s = beanToString(value);
if (s == null) {
return false;
}
jedis.set(key, s);
return true;
} finally {
returnToPool(jedisConnection);
}
}
public <T> T get(String key, Class<T> data) {
JedisConnection jedisConnection = (JedisConnection)RedisConnectionUtils.getConnection(redisConnectionFactory, true);
Jedis jedis = null;
try {
jedis = jedisConnection.getNativeConnection();
String sval = jedis.get(key);
//将String转换为Bean入后传出
T t = stringToBean(sval, data);
return t;
} finally {
returnToPool(jedisConnection);
}
}
}
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
