flea-frame-cache使用之整合Memcached和Redis接入
整合Memcached和Redis接入
1. 参考
[flea-frame-cache使用之整合Memcached和Redis接入 源代码]
2. 依赖
Memcached-Java-Client-3.0.2.jar
<!-- Memcached相关 -->
<dependency>
<groupId>com.whalin</groupId>
<artifactId>Memcached-Java-Client</artifactId>
<version>3.0.2</version>
</dependency><!-- Java redis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.0.1</version>
</dependency>spring-context-4.3.18.RELEASE.jar
<!-- Spring相关 -->
<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>
<!-- Flea缓存建造者配置项集 -->
<cache-items key="FleaCacheBuilder" desc="Flea缓存建造者实现">
<cache-item key="MemCached" desc="MemCached的Flea缓存建造者实现">com.huazie.frame.cache.memcached.MemCachedFleaCacheBuilder</cache-item>
<cache-item key="Redis" desc="Redis的Flea缓存建造者实现">com.huazie.frame.cache.redis.RedisFleaCacheBuilder</cache-item>
</cache-items>
<!-- Redis缓存参数集 -->
<cache-params key="Redis" desc="Redis缓存配置数据">
<cache-param key="connectionTimeout" desc="Redis客户端socket连接超时时间">2000</cache-param>
<cache-param key="soTimeout" desc="Redis客户端socket读写超时时间">2000</cache-param>
<cache-param key="hashingAlg" desc="Redis分布式hash算法(1:MURMUR_HASH,2:MD5)">1</cache-param>
<cache-param key="pool.maxTotal" desc="Redis客户端Jedis连接池最大连接数">100</cache-param>
<cache-param key="pool.maxIdle" desc="Redis客户端Jedis连接池最大空闲连接数">10</cache-param>
<cache-param key="pool.minIdle" desc="Redis客户端Jedis连接池最小空闲连接数">0</cache-param>
<cache-param key="pool.maxWaitMillis" desc="Redis客户端Jedis连接池获取连接时的最大等待毫秒数">2000</cache-param>
</cache-params>
<!-- MemCached缓存参数集 -->
<cache-params key="MemCached" desc="MemCached缓存配置数据">
<cache-param key="initConn" desc="初始化时对每个服务器建立的连接数目">20</cache-param>
<cache-param key="minConn" desc="每个服务器建立最小的连接数">20</cache-param>
<cache-param key="maxConn" desc="每个服务器建立最大的连接数">500</cache-param>
<cache-param key="maintSleep" desc="自查线程周期进行工作，其每次休眠时间">60000</cache-param>
<cache-param key="nagle" desc="Socket的参数，如果是true在写数据时不缓冲，立即发送出去">true</cache-param>
<cache-param key="socketTO" desc="Socket阻塞读取数据的超时时间">3000</cache-param>
<cache-param key="socketConnectTO" desc="Socket连接超时时间">3000</cache-param>
<!--
0 - native String.hashCode();
1 - original compatibility
2 - new CRC32 based
3 - MD5 Based
-->
<cache-param key="hashingAlg" desc="MemCached分布式hash算法">3</cache-param>
</cache-params>
<!-- Flea缓存数据集 -->
<cache-datas>
<cache-data type="fleaAuth" desc="Flea Auth缓存数据所在组配置">authGroup</cache-data>
<cache-data type="fleaJersey" desc="Flea Jersey缓存数据所在组配置">configGroup</cache-data>
<cache-data type="fleaFrame" desc="Flea Frame配置数据所在组配置">configGroup</cache-data>
</cache-datas>
<!-- Flea缓存组集 -->
<cache-groups>
<cache-group group="authGroup" desc="Flea权限数据缓存组">MemCached</cache-group>
<cache-group group="configGroup" desc="Flea配置数据缓存组">Redis</cache-group>
</cache-groups>
<!-- Flea缓存服务器集 -->
<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-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="fleaparadetail" 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="fleaFrame" expiry="0" desc="Flea菜单收藏夹数据缓存" />
</caches>
<!-- 其他缓存定义配置文件引入 -->
<cache-files>
<cache-file>
<location>flea/cache/flea-auth-cache.xml</location>
<!-- 不包含指定KEY缓存
<executions>
<execution>fleaauthuser</execution>
<execution>fleaauthprivilege</execution>
</executions>
-->
</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缓存工厂中获取。
/**
* <p> 核心Flea缓存类 </p>
*
* @author huazie
*/
public class CoreFleaCache extends AbstractFleaCache {
private AbstractFleaCache fleaCache; // 指定Flea缓存实现
/**
* <p> 带参数构造方法，初始化核心Flea缓存类 </p>
*
* @param name 缓存主关键字
*/
public CoreFleaCache(String name) {
super(name, CacheConfigManager.getExpiry(name));
// 根据缓存主关键字name获取指定Flea缓存对象
fleaCache = FleaCacheFactory.getFleaCache(name);
// 取指定Flea缓存的缓存类型
cache = fleaCache.getCache();
}
@Override
public Object getNativeValue(String key) {
return fleaCache.getNativeValue(key);
}
@Override
public void putNativeValue(String key, Object value, long expiry) {
fleaCache.putNativeValue(key, value, expiry);
}
@Override
public void deleteNativeValue(String key) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug1(new Object() {}, "KEY = {}", key);
}
fleaCache.deleteNativeValue(key);
}
@Override
public String getSystemName() {
// 获取缓存初始化配置项集之缓存所属系统名配置项
CacheItem cacheItem = CacheConfigManager.getCacheItem(FleaCacheConfigConstants.FLEA_CACHE_INIT, FleaCacheConfigConstants.SYSTEM_NAME);
if (ObjectUtils.isEmpty(cacheItem)) {
throw new RuntimeException("无法获取缓存系统名，请检查flea-cache-config.xml配置【<cache-item key=" + FleaCacheConfigConstants.SYSTEM_NAME + " >】\"");
}
return cacheItem.getValue();
}
}3.4 定义Flea缓存工厂类 --- FleaCacheFactory
该类根据缓存名（即缓存主关键字）所创建的Flea缓存都存入 ConcurrentMap<String, AbstractFleaCache> 中。newCache 方法主要是根据缓存名查找相关缓存 cache，再找到缓存数据 cache-data，接着找到缓存组 cache-group，最后根据缓存组所属的缓存系统，查找缓存配置项 cache-item，获取对应Flea缓存的建造者实现，可参见 flea-cache-config.xml 配置。
/**
* <p> Flea Cache 工厂类 </p>
*
* @author huazie
* @version 1.0.0
* @since 1.0.0
*/
public class FleaCacheFactory {
private static final ConcurrentMap<String, AbstractFleaCache> fleaCacheMap = new ConcurrentHashMap<String, AbstractFleaCache>();
/**
* <p> 根据缓存主关键字name获取指定Flea缓存对象 </p>
*
* @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);
}
/**
* <p> 根据缓存主关键字name创建一个Flea缓存对象 </p>
*
* @param name 缓存主关键字（对应 flea-cache.xml {@code <cache key="缓存主关键字"></cache>}）
* @return Flea缓存对象
* @since 1.0.0
*/
private static AbstractFleaCache newFleaCache(String name) {
// 获取Flea缓存配置信息
Cache cache = CacheConfigManager.getCache(name);
if (ObjectUtils.isEmpty(cache)) {
throw new RuntimeException("无法初始化Flea缓存，请检查flea-cache.xml配置【<cache key=" + name + " >】");
}
// 获取Flea缓存归属数据配置信息
CacheData cacheData = CacheConfigManager.getCacheData(cache.getType());
if (ObjectUtils.isEmpty(cacheData)) {
throw new RuntimeException("无法初始化Flea缓存，请检查flea-cache-config.xml配置【<cache-data type=" + cache.getType() + " >】");
}
// 获取Flea缓存组
CacheGroup cacheGroup = CacheConfigManager.getCacheGroup(cacheData.getGroup());
if (ObjectUtils.isEmpty(cacheGroup)) {
throw new RuntimeException("无法初始化Flea缓存，请检查flea-cache-config.xml配置【<cache-group group=" + cacheData.getGroup() + " >】");
}
// 获取缓存系统名
String cacheSystem = cacheGroup.getCache();
// 获取Flea缓存参数
CacheParams cacheParams = CacheConfigManager.getCacheParams(cacheSystem);
if (ObjectUtils.isEmpty(cacheParams)) {
throw new RuntimeException("无法初始化Flea缓存，请检查flea-cache-config.xml配置【<cache-params key=" + cacheGroup.getCache() + " >】");
}
// 获取Flea缓存服务器
List<CacheServer> cacheServerList = CacheConfigManager.getCacheServer(cacheGroup.getGroup());
if (CollectionUtils.isEmpty(cacheServerList)) {
throw new RuntimeException("无法初始化Flea缓存，请检查flea-cache-config.xml配置【<cache-server group=" + cacheGroup.getGroup() + " >】");
}
// 获取指定缓存系统名对应的Flea缓存建造者
CacheItem cacheItem = CacheConfigManager.getCacheItem(CacheConstants.FleaCacheConfigConstants.FLEA_CACHE_BUILDER, cacheSystem);
if (ObjectUtils.isEmpty(cacheItem)) {
throw new RuntimeException("无法初始化Flea缓存，请检查flea-cache-config.xml配置【<cache-item key=" + cacheSystem + " >】");
}
// Flea缓存建造者
String builder = cacheItem.getValue();
if (ObjectUtils.isEmpty(builder)) {
throw new RuntimeException("无法初始化Flea缓存，请检查flea-cache-config.xml配置【<cache-item key=" + cacheSystem + " ></cache-item>】配置项值不能为空");
}
AbstractFleaCache fleaCache;
try {
IFleaCacheBuilder fleaCacheBuilder = (IFleaCacheBuilder) ReflectUtils.newInstance(builder);
fleaCache = fleaCacheBuilder.build(name, cacheServerList, cacheParams);
} catch (Exception e) {
throw new RuntimeException("构建Flea缓存出现异常：\n" + e);
}
return fleaCache;
}
}3.5 定义Flea缓存建造者接口类 --- IFleaCacheBuilder
/**
* <p> Flea缓存建造者接口类 </p>
*
* @author huazie
*/
public interface IFleaCacheBuilder {
/**
* <p> 构建Flea缓存对象 </p>
*
* @param name 缓存主关键字
* @param cacheServerList 缓存服务器集
* @param cacheParams 缓存参数集
* @return Flea缓存对象
*/
AbstractFleaCache build(String name, List<CacheServer> cacheServerList, CacheParams cacheParams);
}3.6 定义Memcached Flea缓存建造者 --- MemCachedFleaCacheBuilder
该类实现 IFleaCacheBuilder，用于构建基于 Memcached 的 Flea 缓存，即创建一个 MemCachedFleaCache。
/**
* <p> MemCached的Flea缓存建造者实现 </p>
*
* @author huazie
*/
public class MemCachedFleaCacheBuilder implements IFleaCacheBuilder {
@Override
public AbstractFleaCache build(String name, List<CacheServer> cacheServerList, CacheParams cacheParams) {
if (CollectionUtils.isEmpty(cacheServerList)) {
return null;
}
// 获取失效时长
long expiry = CacheConfigManager.getExpiry(name);
// 获取MemCached服务器所在组名
String group = cacheServerList.get(0).getGroup();
// 通过组名来获取 MemCached客户端类
MemCachedClient memCachedClient = new MemCachedClient(group);
// 获取MemCachedPool，并初始化连接池
MemCachedPool memCachedPool = MemCachedPool.getInstance(group);
memCachedPool.initialize(cacheServerList, cacheParams);
// 创建一个MemCached Flea缓存类
AbstractFleaCache fleaCache = new MemCachedFleaCache(name, expiry, memCachedClient);
return fleaCache;
}
}3.7 定义Redis Flea缓存建造者 --- RedisFleaCacheBuilder
该类实现 IFleaCacheBuilder，用于构建基于Redis的Flea缓存，即创建一个 RedisFleaCache。
/**
* <p> Redis的Flea缓存建造者实现 </p>
*
* @author huazie
*/
public class RedisFleaCacheBuilder implements IFleaCacheBuilder {
@Override
public AbstractFleaCache build(String name, List<CacheServer> cacheServerList, CacheParams cacheParams) {
if (CollectionUtils.isEmpty(cacheServerList)) {
return null;
}
// 获取失效时长
long expiry = CacheConfigManager.getExpiry(name);
// 获取缓存组名
String group = cacheServerList.get(0).getGroup();
// 初始化连接池
RedisPool.getInstance(group).initialize(cacheServerList, cacheParams);
// 获取Redis客户端代理类
RedisClient redisClient = RedisClientProxy.getProxyInstance(group);
// 创建一个Redis Flea缓存
AbstractFleaCache fleaCache = new RedisFleaCache(name, expiry, redisClient);
return fleaCache;
}
}3.8 定义核心Flea缓存管理类 --- CoreFleaCacheManager
核心Flea缓存管理类 CoreFleaCacheManager 继承 AbstractFleaCacheManager ，实现 newCache 方法，用于创建一个核心 Flea 缓存。
/**
* <p> 核心Flea缓存管理类 </p>
*
* @author huazie
* @version 1.0.0
* @since 1.0.0
*/
public class CoreFleaCacheManager extends AbstractFleaCacheManager {
@Override
protected AbstractFleaCache newCache(String name, long expiry) {
return new CoreFleaCache(name);
}
}3.9 整合接入自测 --- FleaCacheTest
首先，这里需要按照 Flea缓存配置文件 ( flea-cache-config.xml) 中的缓存服务器 cache-server 中地址部署相应的 Memcached 和 Redis 服务，可参考笔者的 这篇博文。
@Test
public void testCoreFleaCache() {
try {
AbstractFleaCacheManager manager = FleaCacheManagerFactory.getFleaCacheManager(CacheEnum.FleaCore.getName());
AbstractFleaCache cache = manager.getCache("fleaparadetail");
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。
/**
* <p> 核心Spring缓存类 </p>
*
* @author huazie
*/
public class CoreSpringCache extends AbstractSpringCache {
/**
* <p> 带参数构造方法 </p>
*
* @param name 缓存主关键字
* @param fleaCache Flea Cache具体实现
*/
public CoreSpringCache(String name, IFleaCache fleaCache) {
super(name, fleaCache);
}
/**
* <p> 带参数构造方法 </p>
*
* @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。
/**
* <p> 核心Spring缓存管理类 </p>
*
* @author huazie
*/
public class CoreSpringCacheManager extends AbstractSpringCacheManager {
@Override
protected AbstractSpringCache newCache(String name, long expiry) {
return new CoreSpringCache(name);
}
}
4.3 Spring配置
<!-- 配置核心Flea缓存管理类 RedisSpringCacheManager -->
<bean id="coreSpringCacheManager" class="com.huazie.frame.cache.core.CoreSpringCacheManager" />
<!-- 开启缓存 -->
<cache:annotation-driven cache-manager="coreSpringCacheManager" proxy-target-class="true"/>4.4 缓存自测
private ApplicationContext applicationContext;
@Before
public void init() {
applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
LOGGER.debug("ApplicationContext={}", applicationContext);
}
@Test
public 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 接入的工作已经全部完成，相信各位已经能够接入系统~~~
