Springboot2.0整合Redis缓存+Ehcache缓存

客官°小女子只卖身不卖艺 2022-01-30 01:57 819阅读 0赞

## Redis缓存与Ehcache缓存区别： ##

**主要区别：**  
1、Ehcache直接在jvm虚拟机中缓存，速度快，效率高；但是缓存共享麻烦，集群分布式应用不方便，Ehcache和工程一起启动（系统挂了缓存就没了）  
2、Redis 是通过socket访问到缓存服务，效率比ecache低，比数据库要快很多，处理集群和分布式缓存方便，有成熟的方案，需要单独部署服务（可持久化），

**总结：**  
如果是单个应用或者对缓存访问要求很高的应用，用ehcache。  
如果是大型系统，存在缓存共享、分布式部署、缓存内容很大的，建议用redis。

## 一、SpringBoot2.0整合Redis+Ehcache步骤： ##

1、pom.xml 支持

<dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
    </dependency>
    
    <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、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 配置文件编写

<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>

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:  
![在这里插入图片描述][20190517163157652.png]  
![20190517163101731.png][]  
getRedis:  
![在这里插入图片描述][20190517163117335.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70]  
Redis服务器中数据（注意CacheManagerConfig 配置文件中有设置30秒过期时间）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70 1]

## 整合成功，但以上仅仅是方法上的注解用法。 ##

## 二、下面提供一些工具方法，用作非注解用法操作。 ##

**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;
        }

[20190517163157652.png]: /images/20220130/308c1a63116d488abcbd612502ea3e88.png
[20190517163101731.png]: /images/20220130/bc0e0282860b4bbcae965618ab1a5050.png
[20190517163117335.png]: /images/20220130/31cea1e2ceee43d584d1466df46c587a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70]: /images/20220130/f712044bfd124a93a4dffb55112bc2f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70 1]: /images/20220130/b596d581136142f3836049fb69397667.png