Redis缓存与Ehcache缓存区别：
主要区别：
1、Ehcache直接在jvm虚拟机中缓存，速度快，效率高；但是缓存共享麻烦，集群分布式应用不方便，Ehcache和工程一起启动（系统挂了缓存就没了）
2、Redis 是通过socket访问到缓存服务，效率比ecache低，比数据库要快很多，处理集群和分布式缓存方便，有成熟的方案，需要单独部署服务（可持久化），
总结：
如果是单个应用或者对缓存访问要求很高的应用，用ehcache。
如果是大型系统，存在缓存共享、分布式部署、缓存内容很大的，建议用redis。
一、SpringBoot2.0整合Redis+Ehcache步骤：
1、pom.xml 支持
<!-- ehcache 缓存 -->
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
</dependency>
<!--开启缓存支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、application.properties 配置文件配置Redis与Ehcache
#缓存
spring.cache.type=ehcache
spring.cache.ehcache.config=ehcache.xml
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=12345
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=-1
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1s
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=500
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=50
# 连接超时时间（毫秒）
#spring.redis.timeout=0s
3、ehcache.xml 配置文件编写
<!-- 在cacheManager 的属性（Map<String, Ehcache> ）ehcaches 中生成两个key[DEFAULT_CACHE, MENU_CACHE] 的Ehcache对象 -->
<ehcache>
<diskStore path="java.io.tmpdir" />
<defaultCache maxElementsInMemory="1000" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="false" />
<cache name="CACHE_EHCACHE" maxElementsInMemory="10000" eternal="true" timeToIdleSeconds="0" timeToLiveSeconds="0" overflowToDisk="true" />
</ehcache>
<!-- 1.必须要有的属性： name: cache的名字，用来识别不同的cache，必须惟一。 -->
<!-- maxElementsInMemory: 内存管理的缓存元素数量最大限值。 -->
<!-- maxElementsOnDisk: 硬盘管理的缓存元素数量最大限值。默认值为0，就是没有限制。 -->
<!-- eternal: 设定元素是否持久话。若设为true，则缓存元素不会过期。 -->
<!-- overflowToDisk: 设定是否在内存填满的时候把数据转到磁盘上。 -->
<!-- 2.下面是一些可选属性： timeToIdleSeconds： 设定元素在过期前空闲状态的时间，只对非持久性缓存对象有效。默认值为0,值为0意味着元素可以闲置至无限长时间。 -->
<!-- timeToLiveSeconds: 设定元素从创建到过期的时间。其他与timeToIdleSeconds类似。 -->
<!-- diskPersistent: 设定在虚拟机重启时是否进行磁盘存储，默认为false.(我的直觉，对于安全小型应用，宜设为true)。 -->
<!-- diskExpiryThreadIntervalSeconds: 访问磁盘线程活动时间。 -->
<!-- diskSpoolBufferSizeMB: 存入磁盘时的缓冲区大小，默认30MB,每个缓存都有自己的缓冲区。 -->
<!-- memoryStoreEvictionPolicy: 元素逐出缓存规则。共有三种，Recently Used (LRU)最近最少使用，为默认。 First In First Out (FIFO)，先进先出。Less Frequently Used(specified as LFU)最少使用 -->
4、CacheManagerConfig.java 建一个配置Redis与Ehcache的配置类
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.Resource;
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.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
@Configuration
@EnableCaching
@EnableConfigurationProperties(CacheProperties.class)
public class CacheManagerConfig extends CachingConfigurerSupport {
private final CacheProperties cacheProperties;
CacheManagerConfig(CacheProperties cacheProperties) {
this.cacheProperties = cacheProperties;
}
/**h
* cacheManager名字
*/
public interface CacheManagerNames {
/**
* redis
*/
String REDIS_CACHE_MANAGER = "redisCacheManager";
/**
* ehCache
*/
String EHCACHE_CACHE_MAANGER = "ehCacheCacheManager";
}
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setConnectionFactory(factory);
//key序列化方式
template.setKeySerializer(redisSerializer);
//value序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);
return template;
}
@Primary
@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间30秒
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(30))
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.disableCachingNullValues();
RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
.cacheDefaults(config)
.build();
return cacheManager;
}
/**
* 创建ehCacheCacheManager
*/
@Bean
public EhCacheCacheManager ehCacheCacheManager() {
Resource location = this.cacheProperties
.resolveConfigLocation(this.cacheProperties.getEhcache().getConfig());
return new EhCacheCacheManager(EhCacheManagerUtils.buildCacheManager(location));
}
}
5、写一个Controller 测试一下
@Controller
@Slf4j
public class CacheController {
@Cacheable(key = "#key", cacheManager = CacheManagerConfig.CacheManagerNames.EHCACHE_CACHE_MAANGER, value = "CACHE_EHCACHE")
@RequestMapping("/getEhcache")
@ResponseBody
public String getEhcache(String key) {
log.info("—— ehcache ——");
return "cache:" + key;
}
@Cacheable(key = "#key", value = "CACHE_REDIS")
@RequestMapping("/getRedis")
@ResponseBody
public String getRedis(String key) {
log.info("—— redis Cache ——");
return "cache:" + key;
}
}
测试结果：(每个接口访问2次、只有第一次输出log，说明已成功)
getEhcache:
getRedis:
Redis服务器中数据（注意CacheManagerConfig 配置文件中有设置30秒过期时间）
整合成功，但以上仅仅是方法上的注解用法。
二、下面提供一些工具方法，用作非注解用法操作。
Ehcache缓存相关工具类：
1、接口类（提供一些常用方法，和初始化缓存方法）
ICacheManager.java
import java.util.Map;
public interface ICacheManager {
/**
* 启动时，从数据库获取所有缓存数据，放入缓存中
*/
void initCacheData();
/**
*
* @Title: initCache
* @Description: 初始化缓存管理器
* @return void 返回类型
* @throws
*/
void initCache();
/**
* 往本缓中存入一条记录，如果key已存在，则覆盖并返回原值
* 参考MAP的put方法
* @param key
* @param value
* @return
*/
void put(Object key, Object value);
/**
* 根据key获取缓存记录数据
* @param key
* @return
*/
Object get(Object key);
/**
* 删除键为KEY的缓存记录
* @param key
*/
void evict(Object key);
/**
* 清除该缓存实例的所有缓存记录
*/
void clear();
/**
* 重新刷新该缓存记录，通常是clear()和initCacheFormSql()的组合
*/
void refresh();
/**
*
* @Title: put
* @Description: 将Map映射到缓存中
* @param @param map 设定文件
* @return void 返回类型
* @throws
*/
public void put(Map<String, Object> map);
}
2、ICacheManager接口实现类
import com.weixin.demo.config.CacheManagerConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.Cache.ValueWrapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.context.annotation.Primary;
import javax.annotation.PostConstruct;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public abstract class SimpleCacheManager implements ICacheManager {
@Autowired
protected CacheManagerConfig springCacheManager;
protected Cache springCache;
public abstract String getCacheKey();
public void clear() {
springCache.clear();
}
public Object get(Object key) {
ValueWrapper valueWrapper = springCache.get(key);
if (valueWrapper != null)
return springCache.get(key).get();
else
return null;
}
public abstract void initCacheData();
public void put(Object key, Object value) {
springCache.put(key, value);
}
public void refresh() {
this.clear();
this.initCacheData();
}
public void evict(Object key) {
springCache.evict(key);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public void put(Map map) {
Set<Map.Entry> set = map.entrySet();
for (Iterator<Map.Entry> it = set.iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
this.put(entry.getKey(), entry.getValue());
}
}
/**
* 执行先后顺序: Constructor > @PostConstruct > InitializingBean > init-method
*/
@PostConstruct
public void initCache() {
springCache = this.springCacheManager.ehCacheCacheManager().getCache(getCacheKey());
if (this.springCache == null)
throw new RuntimeException("请检查ehcache.xml 中是否配置 name=" + getCacheKey());
initCacheData();
}
}
3、如果需要做类似数据字典预选缓存可以 继承上面的实现类。比如下面做数据字典的缓存：
下面这个类只是个参考的例子：
import com.weixin.demo.entity.TsysDict;
import com.weixin.demo.service.ITsysDictService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class DictCacheManager extends SimpleCacheManager {
private static final Logger logger = LoggerFactory.getLogger(DictCacheManager.class);
@Autowired
private ITsysDictService dictService;
@Override
public String getCacheKey() {
return "DICT_CACHE";
}
@Override
public void initCacheData() {
logger.debug("###### 初始化 字典 数据开始 ######");
List<TsysDict> dictList = new TsysDict().selectAll();
for(TsysDict dict : dictList){
if(dict != null){
this.springCache.put(dict.getDictId(), dict.getDictName());
}
}
logger.debug("###### 初始化 字典 数据结束 ######");
}
/**
* 刷新单条记录
* @param key
*/
public void refresh(Object key) {
if(key == null)
return ;
String dictCode = key.toString().trim();
if("".equals(dictCode)){
return ;
}
TsysDict dict = new TsysDict().selectOne("dict_code",dictCode);
this.evict(dict.getDictId());
this.put(dict.getDictId(), dict.getDictName());
}
}
4、controller类 非注解类操作Ehcache缓存
如果Ehcache存在则直接从Ehcache中获取，否则从数据库获取并且加入Ehcache缓存中。
/**
* 获取 ehCache 中的数据
* @param id
* @return
*/
@RequestMapping("/getEhcache")
@ResponseBody
public Object getE(Integer id){
if(dictCacheManager.get(id)!=null){
log.info("———— 查询Ehcache缓存 ————");
return dictCacheManager.get(id);
}else {
log.info("———— 查询DB数据库 ————");
TbCache tbCache = new TbCache().selectById(id);
dictCacheManager.put(tbCache.getId(),tbCache);
return tbCache;
}
}
Redis缓存相关工具类：
1、RedisUtil.java
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
/**
* Redis工具类
*/
@Component
public final class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/**
* 指定缓存失效时间
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
// ============================String=============================
/**
* 普通缓存获取
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
* @param key 键
* @param delta 要增加几(大于0)
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
* @param key 键
* @return
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0)
expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
2、controller写个测试方法
如果redis存在则从redis中获取，否则从数据获取并且添加到Redis缓存中。
（注意：RedisUtil类操作的缓存有效期默认是-1， 也就是永久存在的，RedisUtil有相关的过期方法设置）
@RequestMapping("/getRedis")
@ResponseBody
public Object get(Integer id){
String key = "tbCache:"+id;
if(redisUtil.hasKey(key)){
log.info("———— 查询Redis数据库 ————");
System.out.println(key+" 过期时间："+redisUtil.getExpire(key));
return redisUtil.get(key);
}
log.info("———— 查询DB数据库 ————");
TbCache tbCache = new TbCache().selectById(id);
redisUtil.set(key,tbCache);
return tbCache;
}
1275
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
