700字范文 > flea-cache使用之整合Memcached和Redis接入

flea-cache使用之整合Memcached和Redis接入

时间：2019-04-15 04:31:06

整合Memcached和Redis接入

1. 参考

flea-cache使用之整合Memcached和Redis接入源代码

2. 依赖

Memcached-Java-Client-3.0.2.jar

<dependency><groupId>com.whalin</groupId><artifactId>Memcached-Java-Client</artifactId><version>3.0.2</version></dependency>

jedis-3.0.1.jar

<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.0.1</version></dependency>

spring-context-4.3.18.RELEASE.jar

<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>4.3.18.RELEASE</version></dependency>

spring-context-support-4.3.18.RELEASE.jar

<dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>4.3.18.RELEASE</version></dependency>

3. 基础接入

经过上两篇博文的介绍，Memcached和Redis相信很多笔友都能成功的接入应用系统了。随着业务的复杂度上升，缓存的应用场景不断增多，单独的对接一个缓存系统，已经无法满足业务发展要求。

本文着眼于整合多套缓存接入：一个缓存cache对应一个缓存数据cache-data，一个缓存数据cache-data对应一个缓存组cache-group，多个缓存服务器cache-server关联一个缓存组cache-group，一个缓存组cache-group对应具体的缓存接入实现（目前支持Memcached和Redis）。

下面且听我慢慢道来：

3.1 Flea缓存配置文件

Flea缓存配置文件 ( flea-cache-config.xml)，用来整合Memcached和Redis的相关配置，包含了缓存数据，缓存组，缓存服务器，缓存参数以及其他缓存配置项。

<?xml version="1.0" encoding="UTF-8"?><flea-cache-config><cache-items key="FleaCacheInit" desc="缓存初始化配置项"><cache-item key="systemName" desc="缓存所属系统名">FleaFrame</cache-item></cache-items><cache-items key="FleaCacheBuilder" desc="Flea缓存建造者实现"><cache-item key="MemCached" desc="MemCached的Flea缓存建造者实现">com.huazie.fleaframework.cache.memcached.builder.MemCachedFleaCacheBuilder</cache-item><cache-item key="RedisSharded" desc="Redis分片模式下的Flea缓存建造者实现">com.huazie.fleaframework.cache.redis.builder.RedisShardedFleaCacheBuilder</cache-item><cache-item key="RedisCluster" desc="Redis集群模式下的Flea缓存建造者实现">com.huazie.fleaframework.cache.redis.builder.RedisClusterFleaCacheBuilder</cache-item></cache-items><cache-params><cache-param key="fleacore.nullCacheExpiry" desc="空缓存数据有效期（单位：s）">10</cache-param><cache-param key="redis.connectionTimeout" desc="Redis客户端socket连接超时时间（单位：ms）">2000</cache-param><cache-param key="redis.soTimeout" desc="Redis客户端socket读写超时时间（单位：ms）">2000</cache-param><cache-param key="redis.hashingAlg" desc="Redis分布式hash算法(1:MURMUR_HASH,2:MD5)">1</cache-param><cache-param key="redis.pool.maxTotal" desc="Redis客户端Jedis连接池最大连接数">100</cache-param><cache-param key="redis.pool.maxIdle" desc="Redis客户端Jedis连接池最大空闲连接数">10</cache-param><cache-param key="redis.pool.minIdle" desc="Redis客户端Jedis连接池最小空闲连接数">0</cache-param><cache-param key="redis.pool.maxWaitMillis" desc="Redis客户端Jedis连接池获取连接时的最大等待时间（单位：ms）">2000</cache-param><cache-param key="redis.maxAttempts" desc="Redis客户端操作最大尝试次数【包含第一次操作】">5</cache-param><cache-param key="redis.cluster.connectionTimeout" desc="Redis客户端socket连接超时时间（单位：ms）">2000</cache-param><cache-param key="redis.cluster.soTimeout" desc="Redis客户端socket读写超时时间（单位：ms）">2000</cache-param><cache-param key="redis.cluster.password" desc="Redis集群服务节点登录密码（集群各节点配置同一个）">huazie123</cache-param><cache-param key="memcached.initConn" desc="初始化时对每个服务器建立的连接数目">20</cache-param><cache-param key="memcached.minConn" desc="每个服务器建立最小的连接数">20</cache-param><cache-param key="memcached.maxConn" desc="每个服务器建立最大的连接数">500</cache-param><cache-param key="memcached.maintSleep" desc="自查线程周期进行工作，其每次休眠时间（单位：ms）">60000</cache-param><cache-param key="memcached.nagle" desc="Socket的参数，如果是true在写数据时不缓冲，立即发送出去">true</cache-param><cache-param key="memcached.socketTO" desc="Socket阻塞读取数据的超时时间（单位：ms）">3000</cache-param><cache-param key="memcached.socketConnectTO" desc="Socket连接超时时间（单位：ms）">3000</cache-param><cache-param key="memcached.hashingAlg" desc="MemCached分布式hash算法">3</cache-param></cache-params><cache-datas><cache-data type="fleaAuth" desc="Flea Auth缓存数据所在组配置">authGroup</cache-data><cache-data type="fleaFrame" desc="Flea Frame配置数据所在组配置">configGroup</cache-data><cache-data type="fleaJersey" desc="Flea Jersey配置数据所在组配置">configGroup</cache-data><cache-data type="fleaDynamic" desc="Flea 动态数据缓存所在组配置">dynamicGroup</cache-data></cache-datas><cache-groups><cache-group group="authGroup" desc="Flea权限数据缓存组">MemCached</cache-group><cache-group group="configGroup" desc="Flea配置数据缓存组">RedisSharded</cache-group><cache-group group="dynamicGroup" desc="Flea动态数据缓存组">RedisCluster</cache-group></cache-groups><cache-servers><cache-server group="authGroup" weight="1" desc="MemCached缓存服务器">127.0.0.1:31113</cache-server><cache-server group="authGroup" weight="1" desc="MemCached缓存服务器">127.0.0.1:31114</cache-server><cache-server group="configGroup" password="huazie123" weight="1" desc="Redis缓存服务器【分片模式】">127.0.0.1:10001</cache-server><cache-server group="configGroup" password="huazie123" weight="1" desc="Redis缓存服务器【分片模式】">127.0.0.1:10002</cache-server><cache-server group="configGroup" password="huazie123" weight="1" desc="Redis缓存服务器【分片模式】">127.0.0.1:10003</cache-server><cache-server group="dynamicGroup" desc="Redis缓存服务器【集群模式】">127.0.0.1:20011</cache-server><cache-server group="dynamicGroup" desc="Redis缓存服务器【集群模式】">127.0.0.1:20012</cache-server><cache-server group="dynamicGroup" desc="Redis缓存服务器【集群模式】">127.0.0.1:20021</cache-server><cache-server group="dynamicGroup" desc="Redis缓存服务器【集群模式】">127.0.0.1:20022</cache-server><cache-server group="dynamicGroup" desc="Redis缓存服务器【集群模式】">127.0.0.1:1</cache-server><cache-server group="dynamicGroup" desc="Redis缓存服务器【集群模式】">127.0.0.1:2</cache-server></cache-servers></flea-cache-config>

3.2 Flea缓存定义文件

Flea缓存定义文件（flea-cache.xml），用来定义各类缓存，其中key表示缓存主关键字，type表示一类缓存数据，expiry表示缓存生效时长（单位：秒【0：永久】）。

<?xml version="1.0" encoding="UTF-8"?><flea-cache><caches><cache key="fleaconfigdata" type="fleaFrame" expiry="86400" desc="Flea配置数据缓存" /><cache key="fleajerseyi18nerrormapping" type="fleaJersey" expiry="86400" desc="Flea Jersey 国际码和错误码映射缓存" /><cache key="fleajerseyresservice" type="fleaJersey" expiry="86400" desc="Flea Jersey 资源服务缓存" /><cache key="fleajerseyresclient" type="fleaJersey" expiry="86400" desc="Flea Jersey 资源客户端缓存" /><cache key="fleajerseyresource" type="fleaJersey" expiry="86400" desc="Flea Jersey 资源缓存" /><cache key="fleamenufavorites" type="fleaDynamic" expiry="0" desc="Flea菜单收藏夹数据缓存" /></caches><cache-files><cache-file><location>flea/cache/flea-auth-cache.xml</location></cache-file></cache-files></flea-cache>

3.3 定义核心Flea缓存类 — CoreFleaCache

该类同样继承抽象Flea缓存 AbstractFleaCache，实现其定义的抽象方法；内部定义成员变量fleaCache用于指定具体的Flea缓存实现（这个具体的实现，可参考 Memcached接入和 Redis分片模式接入），实现的三个方法getNativeValue，putNativeValue，deleteNativeValue内部采用具体Flea缓存实现fleaCache相应的方法实现读缓存、写缓存，删缓存；从构造方法可见，fleaCache通过FleaCacheFactory.getFleaCache(name)，从Flea缓存工厂中获取。

/*** 核心Flea缓存类，实现读、写和删除缓存的基本操作方法，用于整合各类缓存的接入。** 成员变量【{@code fleaCache}】，在构造方法中根据缓存数据主关键字* 指定具体的Flea缓存实现，在读、写和删除缓存的基本操作方法中调用* 【{@code fleaCache}】的具体实现。** @author huazie* @version 1.1.0* @since 1.0.0*/public class CoreFleaCache extends AbstractFleaCache {private static final FleaLogger LOGGER = FleaLoggerProxy.getProxyInstance(CoreFleaCache.class);private AbstractFleaCache fleaCache; // 指定Flea缓存实现/*** 初始化核心Flea缓存** @param name 缓存数据主关键字* @since 1.0.0*/public CoreFleaCache(String name) {super(name, CacheConfigUtils.getExpiry(name), CacheConfigUtils.getNullCacheExpiry());// 根据缓存数据主关键字name获取指定Flea缓存对象fleaCache = FleaCacheFactory.getFleaCache(name);// 取指定Flea缓存的缓存类型cache = fleaCache.getCache();}@Overridepublic Object getNativeValue(String key) {if (LOGGER.isDebugEnabled()) {LOGGER.debug1(new Object() {}, "KEY = {}", key);}return fleaCache.getNativeValue(key);}@Overridepublic Object putNativeValue(String key, Object value, int expiry) {if (LOGGER.isDebugEnabled()) {Object obj = new Object() {};LOGGER.debug1(obj, "CORE FLEA CACHE, KEY = {}", key);LOGGER.debug1(obj, "CORE FLEA CACHE, VALUE = {}", value);LOGGER.debug1(obj, "CORE FLEA CACHE, EXPIRY = {}s", expiry);LOGGER.debug1(obj, "CORE FLEA CACHE, NULL CACHE EXPIRY = {}s", getNullCacheExpiry());}return fleaCache.putNativeValue(key, value, expiry);}@Overridepublic Object deleteNativeValue(String key) {if (LOGGER.isDebugEnabled()) {LOGGER.debug1(new Object() {}, "KEY = {}", key);}return fleaCache.deleteNativeValue(key);}@Overridepublic String getSystemName() {return CacheConfigUtils.getSystemName();}}

3.4 定义Flea缓存工厂类 — FleaCacheFactory

该类根据缓存名（即缓存主关键字）所创建的Flea缓存都存入ConcurrentMap<String, AbstractFleaCache>中。newCache方法主要是根据缓存名查找相关缓存cache，再找到缓存数据cache-data，接着找到缓存组cache-group，最后根据缓存组所属的缓存系统，查找缓存配置项cache-item，获取对应Flea缓存的建造者实现，可参见flea-cache-config.xml配置。

/*** Flea Cache 工厂类，用于整合各类缓存接入时，创建具体的缓存实现类。** 同步集合类 {@code fleaCacheMap}，存储的键为缓存数据主关键字，* 对应缓存定义配置文件【flea-cache.xml】中的【{@code <cache* key="缓存数据主关键字"></cache>}】；它的值为具体的缓存实现类。** @author huazie* @version 1.1.0* @since 1.0.0*/public class FleaCacheFactory {private static final ConcurrentMap<String, AbstractFleaCache> fleaCacheMap = new ConcurrentHashMap<>();private FleaCacheFactory() {}/*** 根据缓存数据主关键字获取指定Flea缓存对象 ** @param name 缓存数据主关键字（对应 flea-cache.xml {@code <cache key="缓存数据主关键字"></cache>}）* @return Flea缓存对象* @since 1.0.0*/public static AbstractFleaCache getFleaCache(String name) {if (!fleaCacheMap.containsKey(name)) {synchronized (fleaCacheMap) {if (!fleaCacheMap.containsKey(name)) {fleaCacheMap.put(name, newFleaCache(name));}}}return fleaCacheMap.get(name);}/*** 根据缓存数据主关键字创建一个Flea缓存对象 ** @param name 缓存数据主关键字（对应 flea-cache.xml {@code <cache key="缓存数据主关键字"></cache>}）* @return Flea缓存对象* @since 1.0.0*/private static AbstractFleaCache newFleaCache(String name) {// 详见 GitHub 链接}}

3.5 定义Flea缓存建造者接口类 — IFleaCacheBuilder

/*** Flea缓存建造者接口类，定义了构建Flea缓存对象的通用接口。** 该接口由Flea缓存工厂类【{@code FleaCacheFactory}】使用，* 根据不同缓存数据归属缓存组所在的缓存类型，读取缓存配置中的* Flea缓存建造者配置项集，通过反射实例化具体的Flea缓存。** @author huazie* @version 1.0.0* @since 1.0.0*/public interface IFleaCacheBuilder {/*** 构建Flea缓存对象** @param name 缓存数据主关键字* @param cacheServerList 缓存服务器集* @return Flea缓存对象* @since 1.0.0*/AbstractFleaCache build(String name, List<CacheServer> cacheServerList);}

3.6 定义Memcached Flea缓存建造者 — MemCachedFleaCacheBuilder

该类实现IFleaCacheBuilder，用于构建基于Memcached的Flea缓存，即创建一个MemCachedFleaCache。

/*** MemCached Flea缓存建造者实现类，用于整合各类缓存接入时创建MemCached Flea缓存。** 缓存定义文件【flea-cache.xml】中，每一个缓存定义配置都对应缓存配置文件* 【flea-cache-config.xml】中的一类缓存数据，每类缓存数据都归属一个缓存组，* 每个缓存组都映射着具体的缓存实现名，而整合各类缓存接入时，* 每个具体的缓存实现名都配置了Flea缓存建造着实现类。** 可查看Flea缓存配置文件【flea-cache-config.xml】，获取* MemCached Flea缓存建造者配置项【{@code <cache-item key="MemCached">}】** @author huazie* @version 1.1.0* @since 1.0.0*/public class MemCachedFleaCacheBuilder implements IFleaCacheBuilder {private static final FleaLogger LOGGER = FleaLoggerProxy.getProxyInstance(MemCachedFleaCacheBuilder.class);@Overridepublic AbstractFleaCache build(String name, List<CacheServer> cacheServerList) {if (CollectionUtils.isEmpty(cacheServerList)) {throw new FleaCacheConfigException("无法初始化MemCached Flea缓存，缓存服务器列表【cacheServerList】为空");}// 获取缓存数据有效期（单位：s）int expiry = CacheConfigUtils.getExpiry(name);// 获取空缓存数据有效期（单位：s）int nullCacheExpiry = CacheConfigUtils.getNullCacheExpiry();// 获取MemCached服务器所在组名String group = cacheServerList.get(0).getGroup();// 通过组名来获取 MemCached客户端类MemCachedClient memCachedClient = new MemCachedClient(group);// 获取MemCachedPool，并初始化连接池MemCachedPool.getInstance(group).initialize(cacheServerList);// 创建一个MemCached Flea缓存类AbstractFleaCache fleaCache = new MemCachedFleaCache(name, expiry, nullCacheExpiry, memCachedClient);if (LOGGER.isDebugEnabled()) {Object obj = new Object() {};LOGGER.debug1(obj, "Pool Name = {}", MemCachedPool.getInstance(group).getPoolName());LOGGER.debug1(obj, "Pool = {}", MemCachedPool.getInstance(group).getSockIOPool());}return fleaCache;}}

3.7 定义Redis分片模式Flea缓存建造者 — RedisShardedFleaCacheBuilder

该类实现IFleaCacheBuilder，用于构建基于Redis的Flea缓存，即创建一个分片模式的RedisFleaCache。

/*** Redis分片模式Flea缓存建造者实现类，用于整合各类缓存接入时创建Redis Flea缓存。** 缓存定义文件【flea-cache.xml】中，每一个缓存定义配置都对应缓存配置文件* 【flea-cache-config.xml】中的一类缓存数据，每类缓存数据都归属一个缓存组，* 每个缓存组都映射着具体的缓存实现名，而整合各类缓存接入时，* 每个具体的缓存实现名都配置了Flea缓存建造着实现类。** 可查看Flea缓存配置文件【flea-cache-config.xml】，* 获取Redis Flea缓存建造者配置项【{@code <cache-item key="RedisSharded">}】** @author huazie* @version 1.1.0* @see FleaCacheFactory* @since 1.0.0*/public class RedisShardedFleaCacheBuilder implements IFleaCacheBuilder {private static final FleaLogger LOGGER = FleaLoggerProxy.getProxyInstance(RedisShardedFleaCacheBuilder.class);@Overridepublic AbstractFleaCache build(String name, List<CacheServer> cacheServerList) {if (CollectionUtils.isEmpty(cacheServerList)) {throw new FleaCacheConfigException("无法初始化分片模式下Redis Flea缓存，缓存服务器列表【cacheServerList】为空");}// 获取缓存数据有效期（单位：s）int expiry = CacheConfigUtils.getExpiry(name);// 获取空缓存数据有效期（单位：s）int nullCacheExpiry = CacheConfigUtils.getNullCacheExpiry();// 获取缓存组名String group = cacheServerList.get(0).getGroup();// 初始化指定连接池名【group】的Redis分片模式连接池RedisShardedPool.getInstance(group).initialize(cacheServerList);// 获取分片模式下的指定连接池名【group】的Redis客户端RedisClient redisClient = RedisClientFactory.getInstance(group);// 创建一个Redis Flea缓存AbstractFleaCache fleaCache = new RedisFleaCache(name, expiry, nullCacheExpiry, CacheModeEnum.SHARDED, redisClient);if (LOGGER.isDebugEnabled()) {Object obj = new Object() {};LOGGER.debug1(obj, "Pool Name = {}", RedisShardedPool.getInstance(group).getPoolName());LOGGER.debug1(obj, "Pool = {}", RedisShardedPool.getInstance(group).getJedisPool());}return fleaCache;}}

3.8 定义Redis集群模式Flea缓存建造者 — RedisClusterFleaCacheBuilder

该类实现IFleaCacheBuilder，用于构建基于Redis的Flea缓存，即创建一个集群模式的RedisFleaCache。

/*** Redis集群模式Flea缓存建造者实现类，用于整合各类缓存接入时创建Redis Flea缓存。** 缓存定义文件【flea-cache.xml】中，每一个缓存定义配置都对应缓存配置文件* 【flea-cache-config.xml】中的一类缓存数据，每类缓存数据都归属一个缓存组，* 每个缓存组都映射着具体的缓存实现名，而整合各类缓存接入时，* 每个具体的缓存实现名都配置了Flea缓存建造着实现类。** 可查看Flea缓存配置文件【flea-cache-config.xml】，* 获取Redis Flea缓存建造者配置项【{@code <cache-item key="RedisCluster">}】** @author huazie* @version 1.1.0* @see FleaCacheFactory* @since 1.1.0*/public class RedisClusterFleaCacheBuilder implements IFleaCacheBuilder {private static final FleaLogger LOGGER = FleaLoggerProxy.getProxyInstance(RedisClusterFleaCacheBuilder.class);@Overridepublic AbstractFleaCache build(String name, List<CacheServer> cacheServerList) {if (CollectionUtils.isEmpty(cacheServerList)) {throw new FleaCacheConfigException("无法初始化集群模式下Redis Flea缓存，缓存服务器列表【cacheServerList】为空");}// 获取缓存数据有效期（单位：s）int expiry = CacheConfigUtils.getExpiry(name);// 获取空缓存数据有效期（单位：s）int nullCacheExpiry = CacheConfigUtils.getNullCacheExpiry();// 获取缓存组名String group = cacheServerList.get(0).getGroup();// 初始化指定连接池名【group】的Redis集群模式连接池RedisClusterPool.getInstance(group).initialize(cacheServerList);// 获取集群模式下的指定连接池名【group】的Redis客户端类RedisClient redisClient = RedisClientFactory.getInstance(group, CacheModeEnum.CLUSTER);// 创建一个Redis Flea缓存AbstractFleaCache fleaCache = new RedisFleaCache(name, expiry, nullCacheExpiry, CacheModeEnum.CLUSTER, redisClient);if (LOGGER.isDebugEnabled()) {Object obj = new Object() {};LOGGER.debug1(obj, "Pool Name = {}", RedisClusterPool.getInstance(group).getPoolName());LOGGER.debug1(obj, "JedisCluster = {}", RedisClusterPool.getInstance(group).getJedisCluster());}return fleaCache;}}

3.9 定义核心Flea缓存管理类 — CoreFleaCacheManager

核心Flea缓存管理类CoreFleaCacheManager继承AbstractFleaCacheManager，实现newCache方法，用于创建一个核心Flea缓存。

/*** 核心Flea缓存管理类，用于接入Flea框架管理核心Flea缓存。** 核心Flea缓存是Flea框架提供出来的整合各类缓存的缓存实现。** 方法 {@code newCache}，用于创建一个核心Flea缓存，* 它里面包含了读、写、删除和清空缓存的基本操作。** @author huazie* @version 1.0.0* @see CoreFleaCache* @since 1.0.0*/public class CoreFleaCacheManager extends AbstractFleaCacheManager {@Overrideprotected AbstractFleaCache newCache(String name, int expiry) {return new CoreFleaCache(name);}}

3.10 整合接入自测 — FleaCacheTest

首先，这里需要按照 Flea缓存配置文件 (flea-cache-config.xml中的缓存服务器cache-server中地址部署相应的 Memcached 和 Redis 服务，可参考笔者的这篇博文。

@Testpublic void testCoreFleaCache() {try {AbstractFleaCacheManager manager = FleaCacheManagerFactory.getFleaCacheManager(CacheEnum.FleaCore.getName());AbstractFleaCache cache = manager.getCache("fleaconfigdata");LOGGER.debug("Cache={}", cache);//#### 1. 简单字符串// cache.put("menu1", "huazie");// cache.put("menu2", "helloworld");cache.get("menu1");cache.get("menu2");// cache.delete("menu1");// cache.clear();cache.getCacheKey();LOGGER.debug(cache.getCacheName() + ">>>" + cache.getCacheDesc());} catch (Exception e) {LOGGER.error("Exception:", e);}}

经过上面的介绍，核心Flea缓存相关的内容，基本上算是讲解完毕。在不改变现有业务代码的基础上，相关缓存cache可以通过修改其归属的缓存数据类型type，实现各类缓存数据，多种缓存系统之间的无缝迁移。

4. 进阶接入

4.1 定义核心Spring缓存类 — CoreSpringCache

核心Spring缓存CoreSpringCache同样继承抽象Spring缓存 AbstractSpringCache，用于对接Spring；从构造方法可见，该类初始化使用核心Flea缓存类CoreFleaCache。

/*** 核心Spring缓存类 ** @author huazie*/public class CoreSpringCache extends AbstractSpringCache {/*** 带参数构造方法 ** @param name缓存主关键字* @param fleaCache Flea Cache具体实现*/public CoreSpringCache(String name, IFleaCache fleaCache) {super(name, fleaCache);}/*** 带参数构造方法 ** @param name 缓存主关键字*/public CoreSpringCache(String name) {super(name, new CoreFleaCache(name));}}

4.2 定义核心Spring缓存管理类 — CoreSpringCacheManager

核心Spring缓存管理类CoreSpringCacheManager继承抽象Spring缓存管理类 AbstractSpringCacheManager，用于对接Spring；基本实现同核心Flea缓存管理类CoreFleaCacheManager，唯一不同在于newCache的实现，这边是new一个核心Spring缓存CoreSpringCache。

/*** 核心Spring缓存管理类，用于接入Spring框架管理核心Spring缓存。** 核心Spring缓存是Flea框架提供出来的整合各类缓存的缓存实现。** 方法【{@code newCache}】用于创建一个核心Spring缓存，* 而它内部是由核心Flea缓存【{@code CoreFleaCache}】实现具体的* 读、写、删除和清空缓存的基本操作。** @author huazie* @version 1.0.0* @see CoreSpringCache* @since 1.0.0*/public class CoreSpringCacheManager extends AbstractSpringCacheManager {@Overrideprotected AbstractSpringCache newCache(String name, int expiry) {return new CoreSpringCache(name);}}

4.3 Spring配置

<bean id="coreSpringCacheManager" class="com.huazie.fleaframework.cache.core.manager.CoreSpringCacheManager" /><cache:annotation-driven cache-manager="coreSpringCacheManager" proxy-target-class="true"/>

4.4 缓存自测

private ApplicationContext applicationContext;@Beforepublic void init() {applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");LOGGER.debug("ApplicationContext={}", applicationContext);}@Testpublic void testCoreSpringCache() {try {AbstractSpringCacheManager manager = (CoreSpringCacheManager) applicationContext.getBean("coreSpringCacheManager");LOGGER.debug("CoreSpringCacheManager={}", manager);AbstractSpringCache cache = manager.getCache("fleaparadetail");LOGGER.debug("Cache={}", cache);//#### 1. 简单字符串//cache.put("menu1", "huazie");// cache.get("menu1");// cache.get("menu1", String.class);//#### 2. 简单对象(要是可以序列化的对象)//String user = new String("huazie");//cache.put("user", user);//LOGGER.debug(cache.get("user", String.class));cache.clear();//#### 3. List塞对象//List<String> userList = new ArrayList<String>();//userList.add("huazie");//userList.add("lgh");//cache.put("user_list", userList);//LOGGER.debug(cache.get("user_list",userList.getClass()).toString());} catch (Exception e) {LOGGER.error("Exception:", e);}}

4.5 业务逻辑层接入缓存管理

@Cacheable使用，value为缓存名，也作缓存主关键字，key为具体的缓存键

@Cacheable(value = "fleaparadetail", key = "#paraType + '_' + #paraCode")public FleaParaDetail getParaDetail(String paraType, String paraCode) throws Exception {List<FleaParaDetail> fleaParaDetails = fleaParaDetailDao.getParaDetail(paraType, paraCode);FleaParaDetail fleaParaDetailValue = null;if (CollectionUtils.isNotEmpty(fleaParaDetails)) {fleaParaDetailValue = fleaParaDetails.get(0);}return fleaParaDetailValue;}

结语

到目前为止，整合Memcached和Redis接入的工作已经全部完成，相信各位已经能够接入系统~~~

本内容不代表本网观点和政治立场，如有侵犯你的权益请联系我们处理。

网友评论

网友评论仅供其表达个人看法，并不表明网站立场。