迅捷redis测试

ipu-redis-example/.classpath

@@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
	<classpathentry kind="src" output="target/classes" path="src/main/java">
		<attributes>
			<attribute name="optional" value="true"/>
			<attribute name="maven.pomderived" value="true"/>
		</attributes>
	</classpathentry>
	<classpathentry kind="src" path="src/test/reources"/>
	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
		<attributes>
			<attribute name="optional" value="true"/>
			<attribute name="maven.pomderived" value="true"/>
		</attributes>
	</classpathentry>
	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
		<attributes>
			<attribute name="maven.pomderived" value="true"/>
		</attributes>
	</classpathentry>
	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
		<attributes>
			<attribute name="maven.pomderived" value="true"/>
		</attributes>
	</classpathentry>
	<classpathentry kind="output" path="target/classes"/>
</classpath>

ipu-redis-example/.gitignore

@@ -0,0 +1,2 @@
/target/
/.settings/

ipu-redis-example/ipu-cache.iml

@@ -0,0 +1,56 @@
<?xml version="1.0" encoding="UTF-8"?>
<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
  <component name="EclipseModuleManager">
    <conelement value="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER" />
    <src_description expected_position="0">
      <src_folder value="file://$MODULE_DIR$/src/main/java" expected_position="0" />
      <src_folder value="file://$MODULE_DIR$/src/test/reources" expected_position="1" />
      <src_folder value="file://$MODULE_DIR$/src/test/java" expected_position="2" />
    </src_description>
  </component>
  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_6">
    <output url="file://$MODULE_DIR$/target/classes" />
    <output-test url="file://$MODULE_DIR$/target/test-classes" />
    <content url="file://$MODULE_DIR$">
      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
      <sourceFolder url="file://$MODULE_DIR$/src/test/reources" isTestSource="false" />
      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
      <excludeFolder url="file://$MODULE_DIR$/target" />
    </content>
    <orderEntry type="sourceFolder" forTests="false" />
    <orderEntry type="library" name="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER" level="application" />
    <orderEntry type="inheritedJdk" />
    <orderEntry type="library" scope="TEST" name="Maven: junit:junit:3.8.1" level="project" />
    <orderEntry type="library" name="Maven: log4j:log4j:1.2.8" level="project" />
    <orderEntry type="module" module-name="ipu-basic" />
    <orderEntry type="library" name="Maven: com.ai.ipu:ipu-common:3.1-SNAPSHOT" level="project" />
    <orderEntry type="library" name="Maven: com.mashape.unirest:unirest-java:1.3.8" level="project" />
    <orderEntry type="library" name="Maven: org.apache.httpcomponents:httpclient:4.3.2" level="project" />
    <orderEntry type="library" name="Maven: org.apache.httpcomponents:httpcore:4.3.1" level="project" />
    <orderEntry type="library" name="Maven: commons-logging:commons-logging:1.0.4" level="project" />
    <orderEntry type="library" name="Maven: org.apache.httpcomponents:httpasyncclient:4.0.1" level="project" />
    <orderEntry type="library" name="Maven: org.apache.httpcomponents:httpcore-nio:4.3.2" level="project" />
    <orderEntry type="library" name="Maven: org.apache.httpcomponents:httpmime:4.3.2" level="project" />
    <orderEntry type="library" name="Maven: org.json:json:20160810" level="project" />
    <orderEntry type="library" name="Maven: dom4j:dom4j:1.6.1" level="project" />
    <orderEntry type="library" name="Maven: xml-apis:xml-apis:1.0.b2" level="project" />
    <orderEntry type="library" name="Maven: jaxen:jaxen:1.1.1" level="project" />
    <orderEntry type="library" name="Maven: jdom:jdom:1.0" level="project" />
    <orderEntry type="library" name="Maven: xerces:xercesImpl:2.6.2" level="project" />
    <orderEntry type="library" name="Maven: xom:xom:1.0" level="project" />
    <orderEntry type="library" name="Maven: xerces:xmlParserAPIs:2.6.2" level="project" />
    <orderEntry type="library" name="Maven: xalan:xalan:2.6.0" level="project" />
    <orderEntry type="library" name="Maven: com.ibm.icu:icu4j:2.6.1" level="project" />
    <orderEntry type="library" name="Maven: org.jsoup:jsoup:1.7.2" level="project" />
    <orderEntry type="library" name="Maven: org.apache.commons:commons-lang3:3.4" level="project" />
    <orderEntry type="library" name="Maven: org.apache.poi:poi:3.9" level="project" />
    <orderEntry type="library" name="Maven: commons-codec:commons-codec:1.3" level="project" />
    <orderEntry type="library" name="Maven: com.alibaba:fastjson:1.2.38" level="project" />
    <orderEntry type="library" name="Maven: org.yaml:snakeyaml:1.23" level="project" />
    <orderEntry type="library" name="Maven: com.ai.wade:wade-data:1.0" level="project" />
    <orderEntry type="library" name="Maven: com.ai.wade:wade-cache:1.0" level="project" />
    <orderEntry type="library" name="Maven: com.ai.wade:wade-apache:1.0" level="project" />
    <orderEntry type="library" name="Maven: redis.clients:jedis:2.9.0" level="project" />
    <orderEntry type="library" name="Maven: org.apache.commons:commons-pool2:2.4.2" level="project" />
  </component>
</module>

ipu-redis-example/pom.xml

@@ -0,0 +1,78 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.ai.ipu</groupId>
		<artifactId>ipu-aggregator</artifactId>
		<version>3.1-SNAPSHOT</version>
	</parent>
	
	<artifactId>ipu-cache</artifactId>
	<packaging>jar</packaging>
	<name>ipu-cache</name>
	<url>http://maven.apache.org</url>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<jedis>2.9.0</jedis>
	</properties>
	<dependencies>
		<!-- Central jar -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
		</dependency>
		<dependency>
			<groupId>com.ai.ipu</groupId>
			<artifactId>ipu-basic</artifactId>
		</dependency>
		<dependency>
			<groupId>com.ai.ipu</groupId>
			<artifactId>ipu-common</artifactId>
		</dependency>
		<dependency>
			<groupId>com.ai.wade</groupId>
			<artifactId>wade-cache</artifactId>
		</dependency>
		<dependency>
			<groupId>com.ai.wade</groupId>
			<artifactId>wade-apache</artifactId>
		</dependency>
		<dependency>
		    <groupId>redis.clients</groupId>
		    <artifactId>jedis</artifactId>
		    <version>${jedis}</version>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-javadoc-plugin</artifactId>
				<version>2.9.1</version>
				<configuration>
					<nodeprecated>true</nodeprecated>
					<doclet>com.ai.ipu.javadoc.IpuDoclet</doclet>
					<useStandardDocletOptions>false</useStandardDocletOptions>
					<docletArtifact>
						<groupId>com.ai.ipu</groupId>
						<artifactId>ipu-javadoc</artifactId>
						<version>${ipu}</version>
					</docletArtifact>
					<encoding>UTF-8</encoding>
					<docencoding>UTF-8</docencoding>
					<charset>UTF-8</charset>
					<author>true</author>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

ipu-redis-example/readme.txt

@@ -0,0 +1,16 @@
1. 配置文件命名原则：
第三方组件的自带配置文件，命名前缀加上ipu_，如：ipu-mybatis-config.xml。
2.redis环境和端口
121.42.183.206为测试环境；123.57.35.51地址是正式环境，不要作为测试服务。
redis服务的端口为10000-10999
(
kafka 9000-9999
mqtt 7000-7999
coap 5000-5999
rest 8000-8999
zookeeper 2000-2999
redis 10000-10999
ngnix 80
ftp 21
)

ipu-redis-example/src/main/java/com/ai/ipu/cache/CacheFactory.java

@@ -0,0 +1,124 @@
package com.ai.ipu.cache;
import java.util.HashMap;
import java.util.Map;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.cache.config.IpuCacheConfig;
import com.ai.ipu.cache.mem.impl.WadeMemCache;
import com.ai.ipu.cache.redis.RedisCacheFactory;
import com.ai.ipu.cache.redis.impl.JedisCache;
import com.ai.ipu.cache.redis.impl.JedisClusterCache;
import com.ai.ipu.cache.util.IpuCacheConstant;
import com.ailk.cache.memcache.MemCacheFactory;
/**
 * 缓存工厂方法
 */
public class CacheFactory {
    private static final ILogger LOGGER = IpuLoggerFactory.createLogger(CacheFactory.class);
    private static Map<String, ICache> caches = new HashMap<String, ICache>();
    public static final String DEFAULT_CACHE_NAME = "redis";
    
    private CacheFactory() {
    }
    public enum CacheType {
        mem, redis, jvm, wadeMem;
    }
    /**
     * 根据ipu-cache.xml或memcache.xml中的配置信息构造缓存实例
     * @param type 缓存的类型
     * @param cacheName 缓存的名称
     * @return 缓存的实例
     * @throws Exception
     */
    @SuppressWarnings("unused")
    public static ICache getCache(CacheType type, String cacheName) throws Exception {
        ICache cache = caches.get(cacheName);
        if (null == cache) { // 首次使用时加载缓存
            cache = getCache(cache, type, cacheName);
        }
        return cache;
    }
    /**
     * 根据ipu-cache.xml中的配置信息构造缓存实例，
     * @param cacheName 缓存的名称
     * @return 缓存的实例
     * @throws Exception
     */
    public static ICache getCache(String cacheName) throws Exception {
        String cacheType = IpuCacheConfig.getCacheType(cacheName);
        cacheType = cacheType == null ? DEFAULT_CACHE_NAME : cacheType;
        return getCache(CacheType.valueOf(cacheType), cacheName);
    }
    
    private static ICache createCache(CacheType type, String cacheName) throws Exception {
        /* 根据cacheName获取缓存类型 */
        switch (type) {
        case mem:
            break;
        case redis:
            if (IpuCacheConstant.ClientType.JEDIS_CLIENT.equalsIgnoreCase(IpuCacheConfig.getCacheDefaultAttr(cacheName,
                    IpuCacheConstant.Redis.CLIENT_TYPE, IpuCacheConstant.ClientType.JEDIS_CLIENT)))
                return new JedisCache(RedisCacheFactory.getJedis(cacheName));
            else
                return new JedisClusterCache(RedisCacheFactory.getJedisCluster(cacheName));
        case jvm:
            
            break;
        case wadeMem:
            return new WadeMemCache(MemCacheFactory.getCache(cacheName));
        default:
            break;
        }
        return null;
    }
    
    /**
     * 判断是否IPU缓存实例是否存在
     * @return {@code true} 存在; {@code false} 不存在
     */
    public static boolean isIpuCache(String cacheName) throws Exception {
        Map<String, Object> cacheEntity = IpuCacheConfig.getCacheEntity(cacheName);
        return cacheEntity != null && !cacheEntity.isEmpty();
    }
    
    /**
     * redis使用后，需要手工释放，进行资源回收
     * 集群不需要释放
     * 
     * @param cacheName
     * @param cache redis实例
     * @throws Exception
     */
    public static void close(String cacheName, ICache cache) throws Exception {
        if (cache == null)
            return;
        if (cache instanceof JedisCache)
            ((JedisCache)cache).close();
        else if (caches!=null && !caches.isEmpty())
            caches.remove(cacheName);
    }
    
    private static ICache getCache(ICache iCache, CacheType type, String cacheName) throws Exception {
        ICache cache = iCache;
        synchronized (CacheFactory.class) {
            if (cache!=null){ //避免时间差
                return cache;
            }
            cache = createCache(type, cacheName);
            if(!(type.equals(CacheType.redis)&&IpuCacheConstant.ClientType.JEDIS_CLIENT.equalsIgnoreCase(IpuCacheConfig.getCacheDefaultAttr(cacheName,
                    IpuCacheConstant.Redis.CLIENT_TYPE, IpuCacheConstant.ClientType.JEDIS_CLIENT))))
            {
                caches.put(cacheName, cache);
                LOGGER.info("初始化缓存"+cacheName+"成功");
            }
        }
        return cache;
    }
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/ICache.java

@@ -0,0 +1,42 @@
package com.ai.ipu.cache;
/**
 * cache接口定义
 */
public interface ICache {
    
    /**
     * 存
     * @return 是否存储成功
     */
    public boolean put(Object key, Object value) throws Exception;
    /**
     * 取
     * @return 存储的缓存的值
     */
    public Object get(Object key) throws Exception;
    /**
     * 移除
     * @return 是否移除成功
     */
    public boolean remove(Object key) throws Exception;
    /**
     * 清除
     */
    public void clear() throws Exception;
    
    /**
     * key是否存在
     * @return key是凑存在
     */
    public boolean keyExists(String cacheKey);
    
    /**
     * 存
     * @return 是否存储成功
     */
    public boolean put(Object key, Object value, int secondTimeout) throws Exception;
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/config/IpuCacheConfig.java

@@ -0,0 +1,163 @@
package com.ai.ipu.cache.config;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.ai.ipu.common.xml.Dom4jHelper;
/**
 * ipu-cache.xml配置文件解析
 *
 * @author huangbo@asiainfo.com
 */
public class IpuCacheConfig {
    private static final String CACHE_GONFIG_FILE = "ipu-cache.xml";
    private static final String ROOT_PATH = "caches";
    private static final String CONFIG_PATH = "cache";
    private static final String CONFIG_PATH_ARRT = CONFIG_PATH + Dom4jHelper.SUFFIX_ATTR;
    
    private static final String SERVERS_PATH = "servers";
    private static final String CONFIG_ATTR = "config_attr";
    private static final String SERVER_ATTR = "server_attr";
    
    private static final String CACHE_NAME = "cache_name";
    private static final String CACHE_TYPE = "cache_type";
    private static final String CACHE_SERVER = "cache_server";
    private static final String CACHE_ATTR = "cache_attr";
    /*属性*/
    private static final String ATTR_NAME = "name";
    private static final String ATTR_VALUE = "value";
    private static final String ATTR_TYPE = "type";
    
    private static IpuCacheConfig config;
    private Map<String, Object> cachesMap;
    
    @SuppressWarnings("unchecked")
    private IpuCacheConfig() throws Exception {
        Dom4jHelper dh = new Dom4jHelper(getClass().getClassLoader().getResourceAsStream(CACHE_GONFIG_FILE));
        Map<String, ?> originData = dh.getAll();
        List<Map<String, Object>> configs = (List<Map<String, Object>>) originData.get(ROOT_PATH);
        cachesMap = new HashMap<String, Object>();
        Map<String, Object> cacheMap;
        List<Map<String, String>> cacheServer;
        Map<String, String> configAttr;
        /*循环缓存实例*/
        for (Map<String, Object> config : configs) {
            cacheMap = new HashMap<String, Object>();
            cacheServer = new ArrayList<Map<String, String>>();
            configAttr = new HashMap<String, String>();
            
            Map<String, String> cacheAttrMap = (Map<String, String>) config.get(CONFIG_PATH_ARRT);
            List<Map<String, Object>> cacheList = (List<Map<String, Object>>)config.get(CONFIG_PATH);
            
            for(Map<String, Object> map : cacheList){
                if(map.get(CONFIG_ATTR)!=null){
                    /*解析缓存实例的属性*/
                    Map<String, String> configValue = (Map<String, String>)map.get(CONFIG_ATTR);
                    configAttr.put(configValue.get(ATTR_NAME), configValue.get(ATTR_VALUE));
                }else if(map.get(SERVERS_PATH)!=null){
                    /*解析缓存实例的服务列表*/
                    List<Map<String, Object>> serverList = (List<Map<String, Object>>)map.get(SERVERS_PATH);
                    for(Map<String, Object> server : serverList){
                        cacheServer.add((Map<String, String>)server.get(SERVER_ATTR));
                    }
                }
            }
            
            cacheMap.put(CACHE_NAME, cacheAttrMap.get(ATTR_NAME));
            cacheMap.put(CACHE_TYPE, cacheAttrMap.get(ATTR_TYPE));
            cacheMap.put(CACHE_ATTR, configAttr);
            cacheMap.put(CACHE_SERVER, cacheServer);
            cachesMap.put(cacheAttrMap.get(ATTR_NAME), cacheMap);
        }
    }
    /**
     * 获取实例
     * @return 返回的config实例
     * @throws Exception
     */
    protected static IpuCacheConfig getInstance() throws Exception {
        if (config == null) {
            config = new IpuCacheConfig();
        }
        return config;
    }
    /**
     * 获取cache map
     * @return 返回cache map 配置关系
     */
    public Map<String, Object> getCacheMap() {
        return cachesMap;
    }
    /**
     * 获取缓存的entity
     * @param cacheName
     * @return 返回缓存的entity
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static Map<String, Object> getCacheEntity(String cacheName) throws Exception {
        // TODO Auto-generated method stub
        return (Map<String, Object>)getInstance().getCacheMap().get(cacheName);
    }
    /**
     * 获取缓存的server
     * @param cacheName
     * @return 返回cache server
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static List<Map<String,String>> getCacheServers(String cacheName) throws Exception {
        // TODO Auto-generated method stub
        return (List<Map<String, String>>) getCacheEntity(cacheName).get(CACHE_SERVER);
    }
    /**
     * 获取缓存的属性
     * @param cacheName
     * @param name
     * @return 返回缓存的属性
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static String getCacheAttr(String cacheName, String name) throws Exception {
        // TODO Auto-generated method stub
        return ((Map<String, String>)getCacheEntity(cacheName).get(CACHE_ATTR)).get(name);
    }
    /**
     * 获取缓存的属性，不存在则使用默认值
     * @param cacheName
     * @param name
     * @param defaultValue
     * @return 缓存的属性
     * @throws Exception
     */
    public static String getCacheDefaultAttr(String cacheName, String name, String defaultValue) throws Exception {
        // TODO Auto-generated method stub
        String value = getCacheAttr(cacheName, name);
        return value == null ? defaultValue : value;
    }
    /**
     * 获取缓存类型
     * @param cacheName
     * @return 缓存的类型
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static String getCacheType(String cacheName) throws Exception {
        // TODO Auto-generated method stub
    	Object cache = getInstance().getCacheMap().get(cacheName);
    	if(cache==null){
    		return null;
    	}
        return (String)((Map<String, Object>)cache).get(CACHE_TYPE);
    }
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/jvm/JCache.java

@@ -0,0 +1,66 @@
package com.ai.ipu.cache.jvm;
import java.util.HashMap;
import com.ai.ipu.cache.ICache;
/**
 * JVM缓存
 */
public class JCache implements ICache{
    private HashMap cacheMap; //缓存
    public JCache(){
        cacheMap = new HashMap();
    }
    
    /**
     * 在jvm缓存中存放一个K-V键值对
     * @param key  key值
     * @param value value值
     * @return 
     * @exception Exception
     */
    public boolean put(Object key, Object value) throws Exception {    
        return cacheMap.put(key, value) != null;
    }
    /**
     * 在jvm缓存中得到key的value值
     * @param key  key值
     * @return Object value值
     * @exception Exception
     */
    public Object get(Object key) throws Exception {
        return cacheMap.get(key);
    }
    /**
     * 在jvm缓存中移除key
     * @param key  key值
     * @return boolean
     * @exception Exception
     */
    public boolean remove(Object key) throws Exception {
        Object value = cacheMap.remove(key);
        return value!=null;
    }
    /**
     * 清除jvm缓存所有值
     * @exception Exception
     */
    public void clear() throws Exception {
        cacheMap.clear();
    }
    @Override
    public boolean keyExists(String cacheKey) {
        return cacheMap.containsKey(cacheKey);
    }
    @Override
    public boolean put(Object key, Object value, int secondTimeout) throws Exception {
        return false;
    }
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/mem/IMemCache.java

@@ -0,0 +1,38 @@
package com.ai.ipu.cache.mem;
import com.ai.ipu.cache.ICache;
/**
 * MemCache接口
 */
public interface IMemCache extends ICache {
	/**
	 * 在缓存中存放一个K-V键值对，同名键会被覆盖。设置多少秒后超时
	 * @return 是否put成功
	 */
	public boolean put(Object key, Object value, int secondTimeout) throws Exception;
	
	/**
	 * 递增计数器（线程安全），步长为1。
     * @return 增加之后的值
	 */
	public long incr(String cacheKey);
	
	/**
	 * 递增计数器（线程安全），步长为inc。
     * @return 增加之后的值
	 */
	public long incr(String cacheKey, int inc);
	
	/**
	 * 递减计数器（线程安全）， 步长为1。
     * @return 减少之后的值
	 */
	public long decr(String cacheKey);
	
	/**
	 * 递减计数器（线程安全）， 步长为inc。
     * @return 减少之后的值
	 */
	public long decr(String cacheKey, int inc);
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/mem/impl/MemCache.java

@@ -0,0 +1,95 @@
package com.ai.ipu.cache.mem.impl;
import java.util.Map;
import com.ai.ipu.basic.doc.NonJavaDoc;
import com.ai.ipu.cache.mem.IMemCache;
/**
 * MemCache 实现
 */
@NonJavaDoc
public class MemCache implements IMemCache{
	/**
	 * 存
	 */
	public boolean put(Object key, Object value) throws Exception {
		// TODO Auto-generated method stub
		return false;
	}
	/**
	 * 取
	 */
	public Object get(Object key) throws Exception {
		// TODO Auto-generated method stub
		return null;
	}
	/**
	 * 移除
	 */
	public boolean remove(Object key) throws Exception {
		// TODO Auto-generated method stub
		return false;
	}
	/**
	 * 清除
	 */
	public void clear() throws Exception {
		// TODO Auto-generated method stub
		
	}
	/**
	 * key是否存在
	 */
	public boolean keyExists(String cacheKey) {
		// TODO Auto-generated method stub
		return false;
	}
	/**
	 * 在缓存中存放一个K-V键值对，同名键会被覆盖。设置多少秒后超时
	 */
	public boolean put(Object key, Object value, int secondTimeout)
			throws Exception {
		// TODO Auto-generated method stub
		return false;
	}
	/**
	 * 递增计数器（线程安全），步长为1。
	 */
	public long incr(String cacheKey) {
		// TODO Auto-generated method stub
		return 0;
	}
	/**
	 * 递增计数器（线程安全），步长为inc。
	 */
	public long incr(String cacheKey, int inc) {
		// TODO Auto-generated method stub
		return 0;
	}
	/**
	 * 递减计数器（线程安全）， 步长为1。
	 */
	public long decr(String cacheKey) {
		// TODO Auto-generated method stub
		return 0;
	}
	/**
	 * 递减计数器（线程安全）， 步长为inc。
	 */
	public long decr(String cacheKey, int inc) {
		// TODO Auto-generated method stub
		return 0;
	}
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/mem/impl/WadeMemCache.java

@@ -0,0 +1,111 @@
package com.ai.ipu.cache.mem.impl;
import com.ai.ipu.cache.mem.IMemCache;
/**
 * wade MemCache实现
 */
public class WadeMemCache implements IMemCache{
	private com.ailk.cache.memcache.interfaces.IMemCache memCache;
	/**
	 * 构造器
	 * @param memCache 代理的对象
	 */
	public WadeMemCache(com.ailk.cache.memcache.interfaces.IMemCache memCache){
		this.memCache = memCache;
	}
	/**
	 * 存储数据
     * @return 是否存储成功
	 */
	public boolean put(Object key, Object value) throws Exception {
		// TODO Auto-generated method stub
		return memCache.set((String) key, value);
	}
	/**
	 * 取
     * @return 对应的缓存结果
	 */
	public Object get(Object key) throws Exception {
		// TODO Auto-generated method stub
		return memCache.get((String) key);
	}
	/**
	 * 移除
     * @return 是否移除成功
	 */
	public boolean remove(Object key) throws Exception {
		// TODO Auto-generated method stub
		return memCache.delete((String) key);
	}
	/**
	 * 清除
	 */
	public void clear() throws Exception {
		// TODO Auto-generated method stub
		if(memCache!=null){
			((MemCache)memCache).clear();
		}
	}
	/**
	 * key是否存在
     * @return key是否存在
	 */
	public boolean keyExists(String cacheKey) {
		// TODO Auto-generated method stub
		return memCache.keyExists(cacheKey);
	}
	/**
	 * 在缓存中存放一个K-V键值对，同名键会被覆盖。设置多少秒后超时
     * @return 是否put成功
	 */
	public boolean put(Object key, Object value, int secondTimeout)
			throws Exception {
		// TODO Auto-generated method stub
		return memCache.set((String)key, value, secondTimeout);
	}
	/**
	 * 递增计数器（线程安全），步长为1。
	 * @return 增加的数值
	 */
	public long incr(String cacheKey) {
		// TODO Auto-generated method stub
		return memCache.incr(cacheKey);
	}
	/**
	 * 递增计数器（线程安全），步长为inc。
     * @return 增加的数值
	 */
	public long incr(String cacheKey, int inc) {
		// TODO Auto-generated method stub
		return memCache.incr(cacheKey, inc);
	}
	/**
	 * 递减计数器（线程安全）， 步长为1。
     * @return 减少之后的数值
	 */
	public long decr(String cacheKey) {
		// TODO Auto-generated method stub
		return memCache.decr(cacheKey);
	}
	/**
	 * 递减计数器（线程安全）， 步长为inc。
     * @return 减少之后的数值
	 */
	public long decr(String cacheKey, int inc) {
		// TODO Auto-generated method stub
		return memCache.decr(cacheKey, inc);
	}
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/redis/IRedisCache.java

@@ -0,0 +1,140 @@
package com.ai.ipu.cache.redis;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.ai.ipu.cache.ICache;
import com.ai.ipu.cache.redis.listener.AbstractPubSubListener;
/**
 * redis缓存接口
 */
public interface IRedisCache extends ICache{
    /**
     *  自增
     * @param key
     * @return 自增之后的值
     */
    public Long incr(String key);
    /**
     * 自定义步长自增
     * @param key
     * @param step
     * @return 增长之后的值
     */
    public Long incrBy(String key, long step);
    /**
     * 设置失效时间
     * @param key
     * @param timeoutSeconds
     * @return 过期失效时间
     */
    public Long expire(String key, int timeoutSeconds);
    /**
     * 设置失效时间点
     * @param key
     * @param millisSeconds
     * @return 过期失效时间
     */
    public Long expireAt(String key, long millisSeconds);
    /**
     * 设置数据
     * @param key 键
     * @param value 值
     * @param timeoutSeconds 过期时间
     * @return 是否存储成功
     * @throws Exception
     */
    public boolean put(Object key, Object value, int timeoutSeconds) throws Exception;
    /**
     * 设置map
     * @param key 键
     * @param map 映射
     * @return 是否存储成功
     */
    public boolean putMap(String key, Map<String,String> map);
    /**
     * 设置单个key value
     * @param key 键
     * @param element 映射的key
     * @param value 值
     * @return 是否存储成功
     */
    public boolean putMapElement(String key, String element, String value);
    /**
     * 获取map的长度
     * @param key 键
     * @return 映射的长度
     */
    public long getMapLens(String key);
    /**
     * 获取map中所有的key
     * @param key 键
     * @return 对应映射的键集
     */
    public Set<String> getMapKeys(String key);
    /**
     * 获取map中所有的value
     * @param key 键
     * @return 对应映射的值集
     */
    public List<String> getMapVals(String key);
    /**
     * 获取map中的value
     * @param key 键
     * @param fields 映射的keys
     * @return 值集
     */
    public List<String> takeMapVals(String key, String... fields);
    /**
     * 删除map中的value
     * @param key 键
     * @param elements 映射的keys
     * @return 是否删除成功
     */
    public boolean delMapElement(String key, String... elements);
    /**
     * 判断map中的element是否存在
     * @param key 键
     * @param element 映射的key
     * @return 是否存在
     */
    public boolean mapElementExist(String key, String element);
    
    /**
     * 进行资源回收
     * @throws Exception
     */
    public void close() throws Exception;
    
    /**
     * publish消息，仅支持发布字符串或字节型数组
     * 
     * @param channel
     * @param message
     * @return -1：非字符串或字节型数组，发布失败；-2：channel为空，发布失败；-3：message为空，发布失败
     * >=0 接收消息的订阅者数量
     * @throws Exception
     */
    public Long publish(Object channel, Object message) throws Exception;
    
    /**
     * @param listener
     * @param channels
     * @throws Exception
     */
    public void subscribe(AbstractPubSubListener listener, String... channels) throws Exception;
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/redis/RedisCacheFactory.java

@@ -0,0 +1,182 @@
package com.ai.ipu.cache.redis;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.ReentrantLock;
import org.jsoup.helper.StringUtil;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import com.ai.ipu.cache.config.IpuCacheConfig;
import com.ai.ipu.cache.util.IpuCacheConstant;
/**
 * redis缓存工厂类
 */
public class RedisCacheFactory {
    private static JedisPool pool;
    private static final int DEFAULT_POOL_SIZE = 8;
    private static final int DEFAULT_MAX_IDLE = 8;
    private static final int DEFAULT_MIN_IDLE = 1;
    private static final int DEFAULT_SO_TIMEOUT = 5000;
    private static final int DEFAULT_CONN_TIMEOUT = 5000;
    private static final int DEFAULT_MAX_ATTEMPTS = 3;
    protected static ReentrantLock reLock = new ReentrantLock();
    
    private RedisCacheFactory() {
    }
    /**
     * 获取redis 集群管理类
     * @param cacheName 相应的配置项的名称
     * @return redis集群管理类
     * @throws Exception
     */
    public static JedisCluster getJedisCluster(String cacheName) throws Exception{
        String clientType = IpuCacheConfig.getCacheDefaultAttr(cacheName, 
                IpuCacheConstant.Redis.CLIENT_TYPE, IpuCacheConstant.ClientType.JEDIS_CLUSTER_CLIENT);
        //异常："JedisCluster连接池中没有可用的连接，请确认缓存地址是否配置正确、缓存是否开启！"
        if(!IpuCacheConstant.ClientType.JEDIS_CLUSTER_CLIENT.equals(clientType)){
            return null;
        }else{
            return createJedisCluster(cacheName);
        }
    }
    public static JedisCluster createJedisCluster(String cacheName) throws Exception {
        List<Map<String,String>> clusterList = IpuCacheConfig.getCacheServers(cacheName);
        if (null == clusterList || clusterList.isEmpty())
            throw new IllegalArgumentException("请确认server是否配置正确");
        
        Set<HostAndPort> nodes = new HashSet<HostAndPort>();
        Map<String, String> server; 
        for (int i = 0; i < clusterList.size(); i++) {
            server = clusterList.get(i);
            nodes.add(new HostAndPort(server.get(IpuCacheConstant.Redis.IP), 
                    Integer.parseInt(server.get(IpuCacheConstant.Redis.PORT))));
        }
        
        
        JedisPoolConfig config = createPool(cacheName);
        /*设置其他参数*/
        int soTimeout   = DEFAULT_SO_TIMEOUT;
        int connTimeout = DEFAULT_CONN_TIMEOUT;
        int maxAttempts = DEFAULT_MAX_ATTEMPTS;
        String strSoTimeout = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.SO_TIMEOUT);
        String strConnTimeout = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.CONN_TIMEOUT);
        String strMaxAttempts = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.MAX_ATTEMPS);
        if (!StringUtil.isBlank(strSoTimeout)){
            soTimeout = Integer.parseInt(strSoTimeout);
        }
        if (!StringUtil.isBlank(strConnTimeout)){
            connTimeout = Integer.parseInt(strConnTimeout);
        }
        if (!StringUtil.isBlank(strMaxAttempts)){
            maxAttempts = Integer.parseInt(strMaxAttempts);
        }
        
        JedisCluster jedisCluster;
        String auth = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.AUTH);
        if (StringUtil.isBlank(auth)){
            jedisCluster = new JedisCluster(nodes, connTimeout, maxAttempts, config);
        }else{
            jedisCluster = new JedisCluster(nodes, connTimeout, soTimeout, maxAttempts, auth,  config);
        }
        return jedisCluster;
    }
    
    public static Jedis getJedis(String cacheName) throws Exception{
        String clientType = IpuCacheConfig.getCacheDefaultAttr(cacheName, 
                IpuCacheConstant.Redis.CLIENT_TYPE, IpuCacheConstant.ClientType.JEDIS_CLIENT);
        //异常："Jedis连接池中没有可用的连接，请确认缓存地址是否配置正确、缓存是否开启！"
        if(!IpuCacheConstant.ClientType.JEDIS_CLIENT.equals(clientType)){
            return null;
        }else{
        	assert ! reLock.isHeldByCurrentThread();  
            reLock.lock();
            try {
                JedisPool pool = getJedisPool(cacheName);
                return pool.getResource();
            }finally {
            	reLock.unlock(); 
            }
        }
    }
    
    public static JedisPool getJedisPool(String cacheName) throws Exception{
        if(pool==null){
            pool = createJedisPool(cacheName);
        }
        return pool;
    }
    private static JedisPool createJedisPool(String cacheName) throws Exception {
        List<Map<String,String>> clusterList = IpuCacheConfig.getCacheServers(cacheName);
        if (null == clusterList || clusterList.isEmpty())
            throw new IllegalArgumentException("请确认server是否配置正确");
        //只取第一个redis地址
        Map<String, String> server = clusterList.get(0);        
        
        JedisPoolConfig config = createPool(cacheName);
        /*设置其他参数*/
        int connTimeout = DEFAULT_CONN_TIMEOUT;
        String strConnTimeout = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.CONN_TIMEOUT);
        if (!StringUtil.isBlank(strConnTimeout)){
            connTimeout = Integer.parseInt(strConnTimeout);
        }
        
        String host = server.get(IpuCacheConstant.Redis.IP);
        int port = Integer.parseInt(server.get(IpuCacheConstant.Redis.PORT));
        String auth = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.AUTH);
        if (StringUtil.isBlank(auth)){
            pool = new JedisPool(config, host, port, connTimeout);
        }else{
            pool = new JedisPool(config, host, port, connTimeout, auth);
        }
        return pool;
    }
    
    private static JedisPoolConfig createPool(String cacheName) throws Exception {
        JedisPoolConfig config = new JedisPoolConfig();
        /*连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true*/
        config.setBlockWhenExhausted(false);
        /*默认值设置*/
        int poolSize = DEFAULT_POOL_SIZE;
        int maxIdle  = DEFAULT_MAX_IDLE;
        int minIdle  = DEFAULT_MIN_IDLE;
        
        String strPoolSize = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.POOL_SIZE);
        String strMaxIdle = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.MAX_IDLE);
        String strMinIdle = IpuCacheConfig.getCacheAttr(cacheName, IpuCacheConstant.Redis.MIN_IDLE);        
        
        /*设置JedisPoolConfig参数*/
        if(!StringUtil.isBlank(strPoolSize)){
            poolSize = Integer.parseInt(strPoolSize);
        }
        if (!StringUtil.isBlank(strMaxIdle)){
            maxIdle = Integer.parseInt(strMaxIdle);
        }
        if (!StringUtil.isBlank(strMinIdle)){
            minIdle = Integer.parseInt(strMinIdle);
        }
        //最大连接数, 应用自己评估，不要超过ApsaraDB for Redis每个实例最大的连接数
        config.setMaxTotal(poolSize);
        
        //最大空闲连接数, 应用自己评估，不要超过ApsaraDB for Redis每个实例最大的连接数
        config.setMaxIdle(maxIdle);
        config.setMinIdle(minIdle);
        config.setTestOnBorrow(false);
        config.setTestOnReturn(false);
        config.setTestWhileIdle(true);
        
        return config;
    }
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/redis/impl/JedisCache.java

@@ -0,0 +1,305 @@
package com.ai.ipu.cache.redis.impl;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import redis.clients.jedis.Jedis;
import com.ai.ipu.basic.string.StringUtil;
import com.ai.ipu.basic.util.serial.DefaultSerializable;
import com.ai.ipu.basic.util.serial.ISerializable;
import com.ai.ipu.cache.redis.IRedisCache;
import com.ai.ipu.cache.redis.listener.AbstractPubSubListener;
import com.ailk.org.apache.commons.lang3.ArrayUtils;
/**
 * redis缓存的实现
 */
public class JedisCache implements IRedisCache {
    private Jedis redisCache;
    /**
     * 对象序列化与反序列化接口。
     */
    private static final ISerializable SERIALIZER = new DefaultSerializable();
    
    public JedisCache(Jedis jedis)
    {
        this.redisCache = jedis;
    }
    /**
     * 存
     */
    @Override
    public boolean put(Object key, Object value) throws Exception {
        String result = "";
        if (key instanceof String)
            result = redisCache.set(key.toString().getBytes(), SERIALIZER.encode(value));
        else if (key instanceof byte[])
            result = redisCache.set((byte[])key, (byte[])value);
        
        if ("OK".equalsIgnoreCase(result))
            return true;
        else
            return false;
    }
    /**
     * 取
     */
    @Override
    public Object get(Object key) throws Exception {
        // TODO Auto-generated method stub        
        if (key instanceof String)
        {
            if (StringUtil.isEmpty((String)key))
                return null;
            return SERIALIZER.decode(redisCache.get(key.toString().getBytes()));
        }
        else if (key instanceof byte[])
            return redisCache.get((byte[])key);
        return null;
    }
    /**
     * 移除
     */
    @Override
    public boolean remove(Object key) throws Exception {
        long result = -1;
        if (key instanceof String)
            result = redisCache.del((String)key);
        else if (key instanceof byte[])
            result = redisCache.del((byte[])key);
        return result == 1?true:false;
    }
    /**
     * 清除
     */
    @Override
    public void clear() throws Exception {
        redisCache.flushDB();
    }
    /**
     * key是否存在
     */
    @Override
    public boolean keyExists(String cacheKey) {
        return redisCache.exists(cacheKey.toString());
    }
    /**
     *  自增
     * @param key
     * @return
     */
    @Override
    public Long incr(String key) {
        return redisCache.incr(key);
    }
    /**
     * 自定义步长自增
     * @param key
     * @param step
     * @return
     */
    @Override
    public Long incrBy(String key, long step) {
        return redisCache.incrBy(key, step);
    }
    /**
     * 设置失效时间
     * @param key
     * @param timeoutSeconds
     * @return
     */
    @Override
    public Long expire(String key, int timeoutSeconds) {
        return redisCache.expire(key, timeoutSeconds);
    }
    /**
     * 设置失效时间点
     * @param key
     * @param millisSeconds
     * @return
     */
    @Override
    public Long expireAt(String key, long millisSeconds) {
        return redisCache.expireAt(key, millisSeconds);
    }
    /**
     * 设置数据
     * @param key
     * @param value
     * @param timeoutSeconds
     * @return
     * @throws Exception
     */
    @Override
    public boolean put(Object key, Object value, int timeoutSeconds) throws Exception {
        String result = "";
        if (key instanceof String)
            result = redisCache.setex(key.toString().getBytes(), timeoutSeconds, SERIALIZER.encode(value));
        else if (key instanceof byte[])
            result = redisCache.setex((byte[])key, timeoutSeconds, (byte[])value);
        
        if ("OK".equalsIgnoreCase(result))
            return true;
        else
            return false;
    }
    /**
     * 设置map
     * @param key
     * @param map
     * @return
     */
    @Override
    public boolean putMap(String key, Map<String, String> map) {
        String result = redisCache.hmset(key, map);
        if ("OK".equalsIgnoreCase(result))
            return true;
        else
            return false;
    }
    /**
     * 获取map的长度
     * @param key
     * @return
     */
    @Override
    public long getMapLens(String key) {
        // TODO Auto-generated method stub
        return redisCache.hlen(key);
    }
    /**
     * 获取map中所有的key
     * @param key
     * @return
     */
    @Override
    public Set<String> getMapKeys(String key) {
        Set<String> result = new TreeSet<String>(new MyComparator());
        result.addAll(redisCache.hkeys(key));
        return result;
    }
    /**
     * 获取map中所有的value
     * @param key
     * @return
     */
    @Override
    public List<String> getMapVals(String key) {
        return redisCache.hvals(key);
    }
    /**
     * 获取map中的value
     * @param key
     * @param fields
     * @return
     */
    @Override
    public List<String> takeMapVals(String key, String... fields) {
        if (keyExists(key))
            return redisCache.hmget(key, fields);
        else
            return new ArrayList<String>();
    }
    /**
     * 删除map中的value
     * @param key
     * @param elements
     * @return
     */
    @Override
    public boolean delMapElement(String key, String... elements) {
        long result = redisCache.hdel(key, elements);
        return result == 1?true:false;
    }
    /**
     * 设置单个key value
     * @param key
     * @param element
     * @param value
     * @return
     */
    @Override
    public boolean putMapElement(String key, String element, String value) {
        long result = redisCache.hset(key, element, value);
        return result == 1?true:false;
    }
    /**
     * 判断map中的element是否存在
     * @param key
     * @param element
     * @return
     */
    @Override
    public boolean mapElementExist(String key, String element) {
        return redisCache.hexists(key, element);
    }
    /**
     * 自定义比较器
     */
    class MyComparator implements Comparator<String>{  
          
        @Override  
        public int compare(String o1, String o2) {                
            return o2.compareTo(o1);//降序排列  
        }  
          
    }
    @Override
    public void close() throws Exception {
        redisCache.close();
    }
    @Override
    public Long publish(Object channel, Object message) throws Exception {
        if (channel instanceof String)
        {
            if (StringUtil.isEmpty((String)channel))
                return -2l;
            if (StringUtil.isEmpty((String)message))
                return -3l;
            return redisCache.publish((String)channel, (String)message);
        }
        else if (channel instanceof byte[])
        {
            if (!ArrayUtils.isEmpty((byte[]) channel))
                if (!ArrayUtils.isEmpty((byte[]) message))
                    return redisCache.publish((byte[])channel, (byte[])message);
                else
                    return -3l;
            else
                return -2l;
        }
        return -1l;
        
    }
    
    @Override
    public void subscribe(AbstractPubSubListener listener, String... channels) throws Exception{
        redisCache.subscribe(listener, channels);
    }
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/redis/impl/JedisClusterCache.java

@@ -0,0 +1,300 @@
package com.ai.ipu.cache.redis.impl;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import redis.clients.jedis.JedisCluster;
import com.ai.ipu.basic.string.StringUtil;
import com.ai.ipu.basic.util.serial.DefaultSerializable;
import com.ai.ipu.basic.util.serial.ISerializable;
import com.ai.ipu.cache.redis.IRedisCache;
import com.ai.ipu.cache.redis.listener.AbstractPubSubListener;
import com.ailk.org.apache.commons.lang3.ArrayUtils;
/**
 * redis缓存的实现
 */
public class JedisClusterCache implements IRedisCache {
    private JedisCluster redisCache;
    /**
     * 对象序列化与反序列化接口。
     */
    private static final ISerializable SERIALIZER = new DefaultSerializable();
    
    public JedisClusterCache(JedisCluster jedisCluster)
    {
        this.redisCache = jedisCluster;
    }
    /**
     * 存
     */
    @Override
    public boolean put(Object key, Object value) throws Exception {
        String result = "";
        if (key instanceof String)
            result = redisCache.set(key.toString().getBytes(), SERIALIZER.encode(value));
        else if (key instanceof byte[])
            result = redisCache.set((byte[])key, (byte[])value);
        
        return "OK".equalsIgnoreCase(result);
    }
    /**
     * 取
     */
    @Override
    public Object get(Object key) throws Exception {
        if (key instanceof String)
        {
            if (StringUtil.isEmpty((String)key))
                return null;
            return SERIALIZER.decode(redisCache.get(key.toString().getBytes()));
        }
        else if (key instanceof byte[])
            return redisCache.get((byte[])key);
        return null;
    }
    /**
     * 移除
     */
    @Override
    public boolean remove(Object key) throws Exception {
        long result = -1;
        if (key instanceof String)
            result = redisCache.del((String)key);
        else if (key instanceof byte[])
            result = redisCache.del((byte[])key);
        return result == 1?true:false;
    }
    /**
     * 清除
     */
    @Override
    public void clear() throws Exception {
        //集群不支持clear
        throw new Exception("集群不支持clear");
    }
    /**
     * key是否存在
     */
    @Override
    public boolean keyExists(String cacheKey) {
        return redisCache.exists(cacheKey);
    }
    /**
     *  自增
     * @param key
     * @return
     */
    @Override
    public Long incr(String key) {
        return redisCache.incr(key);
    }
    /**
     * 自定义步长自增
     * @param key
     * @param step
     * @return
     */
    @Override
    public Long incrBy(String key, long step) {
        return redisCache.incrBy(key, step);
    }
    /**
     * 设置失效时间
     * @param key
     * @param timeoutSeconds
     * @return
     */
    @Override
    public Long expire(String key, int timeoutSeconds) {
        return redisCache.expire(key, timeoutSeconds);
    }
    /**
     * 设置失效时间点
     * @param key
     * @param millisSeconds
     * @return
     */
    @Override
    public Long expireAt(String key, long millisSeconds) {
        return redisCache.expireAt(key, millisSeconds);
    }
    /**
     * 设置数据
     * @param key
     * @param value
     * @param timeoutSeconds
     * @return
     * @throws Exception
     */
    @Override
    public boolean put(Object key, Object value, int timeoutSeconds) throws Exception {
        String result = "";
        if (key instanceof String)
            result = redisCache.setex(key.toString().getBytes(), timeoutSeconds, SERIALIZER.encode(value));
        else if (key instanceof byte[])
            result = redisCache.setex((byte[])key, timeoutSeconds, (byte[])value);
        
        return "OK".equalsIgnoreCase(result);
    }
    /**
     * 设置map
     * @param key
     * @param map
     * @return
     */
    @Override
    public boolean putMap(String key, Map<String, String> map) {
        String result = redisCache.hmset(key, map);
        return "OK".equalsIgnoreCase(result);
    }
    /**
     * 获取map的长度
     * @param key
     * @return
     */
    @Override
    public long getMapLens(String key) {
        return redisCache.hlen(key);
    }
    /**
     * 获取map中所有的key
     * @param key
     * @return
     */
    @Override
    public Set<String> getMapKeys(String key) {
        Set<String> result = new TreeSet<String>(new MyComparator());
        result.addAll(redisCache.hkeys(key));
        return result;
    }
    /**
     * 获取map中所有的value
     * @param key
     * @return
     */
    @Override
    public List<String> getMapVals(String key) {
        return redisCache.hvals(key);
    }
    /**
     * 获取map中的value
     * @param key
     * @param fields
     * @return
     */
    @Override
    public List<String> takeMapVals(String key, String... fields) {
        if (keyExists(key))
            return redisCache.hmget(key, fields);
        else
            return new ArrayList<String>();
    }
    /**
     * 删除map中的value
     * @param key
     * @param elements
     * @return
     */
    @Override
    public boolean delMapElement(String key, String... elements) {
        long result = redisCache.hdel(key, elements);
        return result == 1;
    }
    /**
     * 设置单个key value
     * @param key
     * @param element
     * @param value
     * @return
     */
    @Override
    public boolean putMapElement(String key, String element, String value) {
        long result = redisCache.hset(key, element, value);
        return result == 1?true:false;
    }
    /**
     * 判断map中的element是否存在
     * @param key
     * @param element
     * @return
     */
    @Override
    public boolean mapElementExist(String key, String element) {
        return redisCache.hexists(key, element);
    }
    /**
     * 自定义比较器
     */
    class MyComparator implements Comparator<String>{  
          
        @Override  
        public int compare(String o1, String o2) {                
            return o2.compareTo(o1);//降序排列  
        }  
          
    }
    /* (non-Javadoc)
     * 集群单例模式不需要close
     * @see com.ai.ipu.cache.redis.IRedisCache#close()
     */
    @Override
    public void close() throws Exception {
        //redisCache.close();
    }
    @Override
    public Long publish(Object channel, Object message) throws Exception {
        if (channel instanceof String)
        {
            if (StringUtil.isEmpty((String)channel))
                return -2l;
            if (StringUtil.isEmpty((String)message))
                return -3l;
            return redisCache.publish((String)channel, (String)message);
        }
        else if (channel instanceof byte[])
        {
        	if (!ArrayUtils.isEmpty((byte[]) channel))
                if (!ArrayUtils.isEmpty((byte[]) message))
                    return redisCache.publish((byte[])channel, (byte[])message);
                else
                    return -3l;
            else
                return -2l;
        }
        return -1l;
        
    }
    
    @Override
    public void subscribe(AbstractPubSubListener listener, String... channels) throws Exception{
        redisCache.subscribe(listener, channels);
    }
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/redis/listener/AbstractPubSubListener.java

@@ -0,0 +1,15 @@
package com.ai.ipu.cache.redis.listener;
import redis.clients.jedis.JedisPubSub;
public abstract class AbstractPubSubListener extends JedisPubSub {
	// 取得订阅的消息后的处理  
    public abstract void onMessage(String channel, String message);
    // 初始化订阅时候的处理  
    public abstract void onSubscribe(String channel, int subscribedChannels);
    // 取消订阅时候的处理  
    public abstract void onUnsubscribe(String channel, int subscribedChannels);
}

ipu-redis-example/src/main/java/com/ai/ipu/cache/util/IpuCacheConstant.java

@@ -0,0 +1,33 @@
package com.ai.ipu.cache.util;
/**
 * ipu-cache常量工具类
 *
 * @author huangbo@asiainfo.com
 */
public class IpuCacheConstant {
    
    private IpuCacheConstant() {}
    public static class Redis{
        public static final String CLIENT_TYPE = "clientType";
        public static final String AUTH = "auth";
        public static final String POOL_SIZE = "poolSize";
        public static final String MAX_IDLE = "maxIdle";
        public static final String MIN_IDLE = "minIdle";
        public static final String SO_TIMEOUT = "soTimeout";
        public static final String CONN_TIMEOUT = "connTimeout";
        public static final String MAX_ATTEMPS = "maxAttempts";        
        public static final String IP = "ip";
        public static final String PORT = "port";
        
        private Redis() {}
    }
    
    public static class ClientType{
        public static final String JEDIS_CLIENT = "Jedis";
        public static final String JEDIS_CLUSTER_CLIENT = "JedisCluster";
        
        private ClientType() {}
    }
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/CacheFactoryTest.java

@@ -0,0 +1,67 @@
package com.ai.ipu.cache;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.cache.CacheFactory.CacheType;
import junit.framework.TestCase;
public class CacheFactoryTest extends TestCase{
    private static final transient ILogger LOGGER = IpuLoggerFactory.createLogger(CacheFactoryTest.class);
    private static final String STR_VALUE = "12345";
    private static final String STR_KEY = "key";
    private static final String CACHE_NAME = "data";
    private static final String CLUSTER_CACHE_NAME = "ssn";
    
    public void testGetCache() throws Exception {
        ICache cache = CacheFactory.getCache(CACHE_NAME);
        LOGGER.debug((String)cache.get(STR_KEY));
        cache.put(STR_KEY, STR_VALUE);
        LOGGER.debug((String)cache.get(STR_KEY));
        assertEquals(STR_VALUE, cache.get(STR_KEY));
        cache.remove(STR_KEY);
        
        cache = CacheFactory.getCache(CacheType.redis, CACHE_NAME);
        LOGGER.debug((String)cache.get(STR_KEY));
        cache.put(STR_KEY, STR_VALUE);
        LOGGER.debug((String)cache.get(STR_KEY));
        assertEquals(STR_VALUE, cache.get(STR_KEY));
        cache.remove(STR_KEY);
        
        CacheFactory.close(CACHE_NAME, cache);
        
        cache = CacheFactory.getCache(CacheType.redis, CACHE_NAME);
        LOGGER.debug((String)cache.get(STR_KEY));
        cache.put(STR_KEY, STR_VALUE);
        LOGGER.debug((String)cache.get(STR_KEY));
        assertEquals(STR_VALUE, cache.get(STR_KEY));
        cache.remove(STR_KEY);
        CacheFactory.close(CACHE_NAME, cache);
    }
    
    public void testAuthFailed() {
        try {
            CacheFactory.getCache(CACHE_NAME);
            assertFalse("校验成功", true);
        } catch (Exception e) {
            LOGGER.debug(e.getMessage());
            assertEquals("NOAUTH Authentication required.", e.getMessage());;
        }
    }
    
    public void testGetClusterCache() throws Exception {
        ICache cache = CacheFactory.getCache(CLUSTER_CACHE_NAME);
        LOGGER.debug((String)cache.get(STR_KEY));
        cache.put(STR_KEY, STR_VALUE);
        LOGGER.debug((String)cache.get(STR_KEY));
        assertEquals(STR_VALUE, cache.get(STR_KEY));
        cache.remove(STR_KEY);
        
        cache = CacheFactory.getCache(CacheType.redis, CLUSTER_CACHE_NAME);
        LOGGER.debug((String)cache.get(STR_KEY));
        cache.put(STR_KEY, STR_VALUE);
        LOGGER.debug((String)cache.get(STR_KEY));
        assertEquals(STR_VALUE, cache.get(STR_KEY));
        
    }
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/config/IpuCacheConfigTest.java

@@ -0,0 +1,46 @@
package com.ai.ipu.cache.config;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
public class IpuCacheConfigTest extends TestCase{
    @Override
    protected void setUp() throws Exception {
        // TODO Auto-generated method stub
        super.setUp();
    }
    
    public void testGetCacheEntity() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(IpuCacheConfig.getCacheEntity("ssn"));
        System.out.println(IpuCacheConfig.getCacheEntity("data"));
        assertTrue("执行成功", true);
    }
    
    public void testGetCacheServers() throws Exception {
        // TODO Auto-generated method stub
        List<Map<String,String>> ssnServers = IpuCacheConfig.getCacheServers("ssn");
        List<Map<String,String>> dataServers = IpuCacheConfig.getCacheServers("data");
        assertEquals(6, ssnServers.size());
        assertEquals(6, dataServers.size());
    }
    
    public void testGetCacheAttr() throws Exception {
        // TODO Auto-generated method stub
        assertEquals("JedisCluster" , IpuCacheConfig.getCacheAttr("ssn", "client"));
    }
    
    public void testGetCacheDefaultAttr() throws Exception {
        // TODO Auto-generated method stub
        assertEquals("Jedis" , IpuCacheConfig.getCacheDefaultAttr("data", "client", "Jedis"));
    }
    
    public void testGetCacheType() throws Exception {
        // TODO Auto-generated method stub
        assertEquals("redis" , IpuCacheConfig.getCacheType("ssn"));
    }
    
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/mem/MemcacheTest.java

@@ -0,0 +1,24 @@
package com.ai.ipu.cache.mem;
import junit.framework.TestCase;
import com.ai.ipu.cache.CacheFactory;
import com.ai.ipu.cache.CacheFactory.CacheType;
import com.ai.ipu.cache.mem.IMemCache;
public class MemcacheTest extends TestCase{
	
	/**
	 * 测试使用memcache的超时方式
	 * @throws Exception
	 */
	public void testSecondTimeout() throws Exception {
		// TODO Auto-generated method stub
		IMemCache cache = (IMemCache) CacheFactory.getCache(CacheType.wadeMem, "wade_cache");
		cache.put("wade_cache_key", "会超时的记录", 10);
		Thread.sleep(5000);
		System.out.println("5秒打印记录"+cache.get("wade_cache_key"));
		Thread.sleep(6000);
		System.out.println("11秒打印记录"+cache.get("wade_cache_key"));
	}
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/redis/JedisCacheTest.java

@@ -0,0 +1,69 @@
package com.ai.ipu.cache.redis;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.cache.CacheFactory;
import com.ai.ipu.cache.CacheFactory.CacheType;
import com.ai.ipu.cache.config.IpuCacheConfig;
import com.ai.ipu.cache.util.IpuCacheConstant;
import junit.framework.TestCase;
public class JedisCacheTest extends TestCase{
	private static final transient ILogger LOGGER = IpuLoggerFactory.createLogger(JedisCacheTest.class);
    private static final String STR_MESSAGE = "this is a test message";
    private static final String STR_VAL = "this is a test";
    private static final String STR_KEY = "key";
    private static final String CACHE_NAME = "data";
    private static final String STR_CHANNEL = "test";
    private static final long SECOND_TO_MS = 1000l;
    private static final int SLEEP_SECONDS = 3600;
    
    public void testPublish() throws Exception{
        IRedisCache cache = (IRedisCache)CacheFactory.getCache(CacheType.redis, CACHE_NAME);
        cache.publish(STR_CHANNEL, STR_MESSAGE);
    }
    
    public void testSubscribe()  throws Exception{
        IRedisCache cache = (IRedisCache)CacheFactory.getCache(CacheType.redis, CACHE_NAME);
        cache.subscribe(new PubSubListenerTest(), STR_CHANNEL);
        
        try{
            Thread.sleep(SLEEP_SECONDS * SECOND_TO_MS);
        }catch (Exception e)
        {
            
        }
        CacheFactory.close(CACHE_NAME, cache);
        
    }
    
    public void testPut() throws Exception{
        IRedisCache cache = null;
        try{
        	cache = (IRedisCache)CacheFactory.getCache(CacheType.redis, CACHE_NAME);
	        cache.put(STR_KEY, STR_VAL);
	        LOGGER.debug(STR_KEY+"="+cache.get(STR_KEY));
	        try{
	            Thread.sleep(10*SECOND_TO_MS);
	        }catch (Exception e)
	        {
	            ;
	        }
	        LOGGER.debug("after 10 seconds,"+STR_KEY+"="+cache.get(STR_KEY));
        }catch (Exception e)
        {
        	;
        }finally {
        	if (cache != null && IpuCacheConstant.ClientType.JEDIS_CLIENT.equalsIgnoreCase(IpuCacheConfig.getCacheDefaultAttr(CACHE_NAME,
                    IpuCacheConstant.Redis.CLIENT_TYPE, IpuCacheConstant.ClientType.JEDIS_CLIENT)))
        		cache.close();
        }
        
    }
    
    public void testClear() throws Exception{
        IRedisCache cache = (IRedisCache)CacheFactory.getCache(CacheType.redis, CACHE_NAME);
        cache.clear();
    }
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/redis/PubSubListenerTest.java

@@ -0,0 +1,41 @@
package com.ai.ipu.cache.redis;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.cache.redis.listener.AbstractPubSubListener;
public class PubSubListenerTest extends AbstractPubSubListener {
    private static final transient ILogger LOGGER = IpuLoggerFactory.createLogger(PubSubListenerTest.class);
    
    @Override
    public void onMessage(String channel, String message) {
        LOGGER.debug(String.format("receive redis published message, channel %s, message %s", channel, message));
    }
    @Override
    public void onSubscribe(String channel, int subscribedChannels) {
        LOGGER.debug(String.format("subscribe redis channel success, channel %s, subscribedChannels %d", 
                channel, subscribedChannels));
    }
    @Override
    public void onUnsubscribe(String channel, int subscribedChannels) {
        LOGGER.debug(String.format("unsubscribe redis channel, channel %s, subscribedChannels %d", 
                channel, subscribedChannels));
    }
    public void onPSubscribe(String pattern, int subscribedChannels) {  
        LOGGER.debug(pattern + "=" + subscribedChannels);  
    }  
    public void onPUnsubscribe(String pattern, int subscribedChannels) {  
        LOGGER.debug(pattern + "=" + subscribedChannels);  
    }  
    public void onPMessage(String pattern, String channel, String message) {  
        LOGGER.debug(pattern + "=" + channel + "=" + message);  
    }  
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/redis/RedisCacheTest.java

@@ -0,0 +1,85 @@
package com.ai.ipu.cache.redis;
import junit.framework.TestCase;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.cache.CacheFactory;
import com.ai.ipu.cache.ICache;
import com.ai.ipu.cache.redis.context.IpuContextData;
import com.ai.ipu.cache.redis.context.IpuContextData2;
import com.alibaba.fastjson.JSON;
public class RedisCacheTest extends TestCase{
	private static final transient ILogger LOGGER = IpuLoggerFactory.createLogger(RedisCacheTest.class);
    private String cacheSingleName;
    private String cacheClusterName;
    private String cacheKey = "KEY";
    private String cacheContent = "CONTENT";
    private String strValue = "123456";
    private int intValue = 123456;
    
    @Override
    protected void setUp() throws Exception {
        // TODO Auto-generated method stub
        super.setUp();
        cacheSingleName = "single";
        cacheClusterName = "ssn";
    }
    public void testRedisSingle() throws Exception {
        // TODO Auto-generated method stub
        ICache cache = CacheFactory.getCache(cacheSingleName);
        cache.put(cacheKey, intValue);
//        LOGGER.debug(Integer.toString((Integer)cache.get(cacheKey)));
        System.out.println("cacheKey"+Integer.toString((Integer)cache.get(cacheKey)));
        System.out.println("cacheKey"+intValue);
        assertEquals(intValue, cache.get(cacheKey));
//        System.out.println();
    }
    
    public void testRedisCluster() throws Exception {
        // TODO Auto-generated method stub
        ICache cache = CacheFactory.getCache(cacheClusterName);
        cache.put(cacheKey, intValue);
        LOGGER.debug(Integer.toString((Integer)cache.get(cacheKey)));
        System.out.println(Integer.toString((Integer)cache.get(cacheKey)));
        System.out.println("cacheKey"+intValue);
        assertEquals(intValue, cache.get(cacheKey));
    }
    
    public void testObjectCache() throws Exception {
        // TODO Auto-generated method stub
        ICache cache = CacheFactory.getCache(cacheSingleName);
        IpuContextData contextData = new IpuContextData();
        contextData.put(cacheKey, strValue);
        cache.put(cacheContent, contextData);
        contextData = (IpuContextData) cache.get(cacheContent);
        System.out.println("strValue"+strValue);
        //cache.get(cacheKey) 对应的是存放缓存的hash值,其他取到的均为值等于123456的值
        System.out.println("cache中获取key值"+cache.get(cacheKey));
        System.out.println("contextData类中获取“KEY”的值"+contextData.getData().get("KEY"));
        assertEquals(strValue,contextData.get(cacheKey));
        System.out.println("=================");
        System.out.println(contextData.get("KEY"));
        assertEquals(contextData.getData().get("KEY"),strValue);
        System.out.println("++++++++++++++++");
        assertEquals(strValue, cache.get(cacheKey));
        System.out.println("-------------------");
    }
    
    public void testObjectJsonCache() throws Exception {
        // TODO Auto-generated method stub
        ICache cache = CacheFactory.getCache(cacheSingleName);
        IpuContextData contextData = new IpuContextData();
        contextData.put(cacheKey, strValue);
        cache.put(cacheContent, JSON.toJSONString((contextData)));
        String strContextData = cache.get(cacheContent).toString();
//        LOGGER.debug("strContextData===" + strContextData);
        System.out.println("strContextData===" + strContextData);
        IpuContextData2 contextData2 = JSON.parseObject(strContextData, IpuContextData2.class);
        System.out.println("contextData2.isDirty()===" + contextData2.isDirty());
//        LOGGER.debug("contextData2.isDirty()===" + contextData2.isDirty());
        assertEquals(strValue, contextData2.get(cacheKey));
    }
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/redis/RedisClusterTest.java

@@ -0,0 +1,111 @@
package com.ai.ipu.cache.redis;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import junit.framework.TestCase;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.cache.CacheFactory;
import com.ai.ipu.cache.CacheFactory.CacheType;
import com.ai.ipu.cache.ICache;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2017年11月6日下午4:43:03
 * @desc Jedis原始包集群操作使用范例
 */
public class RedisClusterTest extends TestCase{
	private static final transient ILogger LOGGER = IpuLoggerFactory.createLogger(RedisClusterTest.class);
    private String[] hosts = {
                             "121.42.183.206",
                             "121.42.183.206",
                             "121.42.183.206",
                             "121.42.183.206",
                             "121.42.183.206",
                             "121.42.183.206"
                             };
    private int[] ports = {7101,7102,7103,7104,7105,7106};
    
    @Override
    protected void setUp() throws Exception {
        // TODO Auto-generated method stub
        super.setUp();
    }
    
    public void testCluster() throws Exception{
        JedisCluster jedisCluster = RedisCacheFactory.getJedisCluster("data");
        try {
            long start = System.currentTimeMillis();
            for (int i = 0; i < 100; i++) {
                @SuppressWarnings("unused")
                String result = jedisCluster.set("x" + i, "n" + i);
            }
            long end = System.currentTimeMillis();
            LOGGER.debug("普通同步调用方式耗时: " + ((end - start) / 1000.0) + "秒");
            jedisCluster.close();
        }catch (IOException e) {
        	LOGGER.error("IOException", e);
        }
    }
    
    public void testClusterWithAuth() throws Exception{
        JedisCluster jedisCluster = RedisCacheFactory.getJedisCluster("ssn");
        
        try {
            long start = System.currentTimeMillis();
            for (int i = 0; i < 100; i++) {
                jedisCluster.set("d" + i, "d" + i);
            }
            long end = System.currentTimeMillis();
            LOGGER.debug("普通同步调用方式耗时: " + ((end - start) / 1000.0) + "秒");
            jedisCluster.close();
        }catch (IOException e) {
        	LOGGER.error("IOException", e);
        }
    }
    
    public void testClusterPipelineWithAuth(){
        //GenericObjectPoolConfig的使用
        JedisPoolConfig config = new JedisPoolConfig();
        Set<HostAndPort> nodes = new HashSet<HostAndPort>();
        for(int i=0,len=hosts.length;i<len;i++){
            nodes.add(new HostAndPort(hosts[i], ports[i]));
        }
        JedisCluster jedisCluster = new JedisCluster(nodes, 5000, 5000, 3, "ipu",  config);
        try {
            long start = System.currentTimeMillis();
            for (int i = 0; i < 100; i++) {
                jedisCluster.set("b" + i, "b" + i);
            }
            long end = System.currentTimeMillis();
            LOGGER.debug("普通同步调用方式耗时: " + ((end - start) / 1000.0) + "秒");
            jedisCluster.close();
        }catch (IOException e) {
        	LOGGER.error("IOException", e);
        }
    }
    
    
    public void testCacheFactory()
    {
        try {
			ICache cache = CacheFactory.getCache(CacheType.redis, "jedisCluster");
			boolean result = cache.put("a", "a");
			
			LOGGER.debug(Boolean.toString(result));
			LOGGER.debug((String)cache.get("a"));
			LOGGER.debug(Boolean.toString(cache.remove("a")));
			LOGGER.debug(Boolean.toString(cache.remove("1")));
			
		} catch (Exception e) {
			LOGGER.error("IOException", e);
		}
    }
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/redis/RedisTest.java

@@ -0,0 +1,225 @@
package com.ai.ipu.cache.redis;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import junit.framework.TestCase;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.Transaction;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2018年11月6日下午4:43:44
 * @desc Jedis原始包单服务操作使用范例
 */
public class RedisTest extends TestCase {
	private static final transient ILogger LOGGER = IpuLoggerFactory.createLogger(RedisTest.class);
	private Jedis jedis;
	private ShardedJedis shardedJedis;
	private String host;
	private int port;
	
	@Override
	protected void setUp() throws Exception {
		// TODO Auto-generated method stub
		super.setUp();
		host = "47.105.160.21";
		port = 7001;
	}
	
	/**
	 * 一、普通同步调用方式
	 */
	public void testNormal() {
		jedis = new Jedis(host, port);
		jedis.auth("ipu@321");
		long start = System.currentTimeMillis();
		List<Object> results = new ArrayList<Object>();
		for (int i = 0; i < 100; i++) {
			String result = jedis.set("n" + i, "n" + i);
			results.add(result);
		}
		LOGGER.debug("results.size()==="+results.size());
		long end = System.currentTimeMillis();
		LOGGER.debug("普通同步调用方式耗时: " + ((end - start) / 1000.0) + "秒");
		jedis.disconnect();
	}
	
	/**
	 * 二、事物调用方式
	 * discard()取消事务
	 */
	public void testTrans() { 
		jedis = new Jedis(host, port);
	    jedis.auth("Ipu@321!");
	    long start = System.currentTimeMillis(); 
	    Transaction tx = jedis.multi(); 
	    for (int i = 0; i < 10000; i++) { 
	        tx.set("t" + i, "t" + i); 
	    } 
	    List<Object> results = tx.exec();
	    LOGGER.debug("results.size()==="+results.size());
	    long end = System.currentTimeMillis(); 
	    LOGGER.debug("事物调用方式耗时: " + ((end - start)/1000.0) + " seconds");
	    jedis.disconnect(); 
	} 
	
	/**
	 * 三、管道调用方式
	 */
	public void testPipe() {
		// TODO Auto-generated method stub
		jedis = new Jedis(host, port);
	    jedis.auth("Ipu@321!");
	    Pipeline pipeline = jedis.pipelined(); 
	    long start = System.currentTimeMillis(); 
	    for (int i = 0; i < 10000; i++) { 
	        pipeline.set("p" + i, "p" + i); 
	    } 
	    List<Object> results = pipeline.syncAndReturnAll(); 
	    LOGGER.debug("results.size()==="+results.size());
	    long end = System.currentTimeMillis(); 
	    LOGGER.debug("管道调用方式耗时: " + ((end - start)/1000.0) + " seconds");
	    jedis.disconnect(); 
	}
	
	/**
	 * 四、管道事务调用方式
	 */
	public void testPipeTrans() {
		// TODO Auto-generated method stub
		jedis = new Jedis(host, port);
	    jedis.auth("ipu"); 
	    long start = System.currentTimeMillis(); 
	    Pipeline pipeline = jedis.pipelined(); 
	    pipeline.multi(); 
	    for (int i = 0; i < 10000; i++) { 
	        pipeline.set("" + i, "" + i); 
	    } 
	    pipeline.exec(); 
	    List<Object> results = pipeline.syncAndReturnAll();
	    LOGGER.debug("results.size()==="+results.size());
	    long end = System.currentTimeMillis(); 
	    LOGGER.debug("管道事务调用方式耗时: " + ((end - start)/1000.0) + " seconds"); 
	    jedis.disconnect(); 
	}
	
	/**
	 * 五、普通分布式调用方式
	 * 默认hash方式存储
	 */
	public void testShardNormal() {
		// TODO Auto-generated method stub
		List<JedisShardInfo> distribut = Arrays.asList( 
	            new JedisShardInfo(host,6379), 
	            new JedisShardInfo(host,6380)); 
	    shardedJedis = new ShardedJedis(distribut);
	    List<Object> results = new ArrayList<Object>();
	    long start = System.currentTimeMillis(); 
	    for (int i = 0; i < 100000; i++) { 
	        String result = shardedJedis.set("sn" + i, "n" + i);
	        results.add(result);
	    }
	    LOGGER.debug("results.size()==="+results.size());
	    long end = System.currentTimeMillis(); 
	    LOGGER.debug("普通分布式调用方式耗时: " + ((end - start)/1000.0) + " seconds"); 
	    shardedJedis.disconnect(); 
	}
	
	/**
	 * 六、管道分布式调用方式
	 */
    public void testShardPipe() {
        // TODO Auto-generated method stub
        List<JedisShardInfo> shards = Arrays.asList(new JedisShardInfo(host, 6379), 
                new JedisShardInfo(host, 6380));
        shardedJedis = new ShardedJedis(shards);
        ShardedJedisPipeline pipeline = shardedJedis.pipelined();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            pipeline.set("sp" + i, "p" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        LOGGER.debug("results.size()===" + results.size());
        long end = System.currentTimeMillis();
        LOGGER.debug("Pipelined@Sharing SET: " + ((end - start) / 1000.0) + " seconds");
        shardedJedis.disconnect();
    }
	
	/**
	 * 七、分布式连接池同步调用方式
	 */
	public void testShardPool() {
		// TODO Auto-generated method stub
		List<JedisShardInfo> shards = Arrays.asList(
				new JedisShardInfo(host, 6379), 
				new JedisShardInfo(host, 6380));
		ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
		shardedJedis = pool.getResource();
		List<Object> results = new ArrayList<Object>();
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			String result = shardedJedis.set("spn" + i, "n" + i);
			results.add(result);
		}
		
		LOGGER.debug("results.size()===" + results.size());
		long end = System.currentTimeMillis();
		pool.returnResource(shardedJedis);
		LOGGER.debug("Simple@Pool SET: " + ((end - start) / 1000.0) + " seconds");
		pool.destroy();
	}
	
	/**
	 * 八、分布式连接池异步调用方式
	 */
	public void testShardPipePool() {
		// TODO Auto-generated method stub
		List<JedisShardInfo> shards = Arrays.asList( 
	            new JedisShardInfo("localhost",6379), 
	            new JedisShardInfo("localhost",6380)); 
	    ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards); 
	    shardedJedis = pool.getResource(); 
	    ShardedJedisPipeline pipeline = shardedJedis.pipelined(); 
	    long start = System.currentTimeMillis(); 
	    for (int i = 0; i < 100000; i++) { 
	        pipeline.set("sppn" + i, "n" + i); 
	    } 
	    List<Object> results = pipeline.syncAndReturnAll();
	    LOGGER.debug("results.size()===" + results.size());
	    long end = System.currentTimeMillis(); 
	    pool.returnResource(shardedJedis); 
	    LOGGER.debug("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds"); 
	    pool.destroy(); 
	}
	
	public void testGet() {
        jedis = new Jedis(host, port);
        long start = System.currentTimeMillis();
        jedis.keys("*");
        String result = jedis.get("msg");
        LOGGER.debug("返回结果："+result);
        LOGGER.debug("普通同步调用方式耗时: " + (System.currentTimeMillis() - start) + "ms");
        jedis.disconnect();
    }
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/redis/context/IpuContextData.java

@@ -0,0 +1,53 @@
package com.ai.ipu.cache.redis.context;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2018年11月6日下午7:54:04
 * @desc 上下文数据对象设计
 * 1.不使用java对象：单点登录时，java对象的包路径需要一致。不太合理。
 * 2.不继承HashMap：继承的话，Json转换时会丢失私有属性dirty。dirty和xxxxDirty均被识别成dirty
 */
public class IpuContextData implements Serializable{
    private static final long serialVersionUID = 183972639715505942L;
    private Map<String, String> data;
    private boolean isDirty;
	public IpuContextData() {
	    data = new HashMap<String, String>();
	}
	
	public Map<String, String> getData() {
		// TODO Auto-generated method stub
		return data;
	}
	public void setData(Map<String, String> data) {
		// TODO Auto-generated method stub
		this.data = data;
		setDirty(true);
	}
	
	public void put(String key, String value){
	    data.put(key, value);
		setDirty(true);
	}
	
	public String get(String key){
		return data.get(key);
	}
	public boolean isDirty() {
		// TODO Auto-generated method stub
		return isDirty;
	}
	
	public void setDirty(boolean isDirty) {
		// TODO Auto-generated method stub
		this.isDirty = isDirty;
	}
}

ipu-redis-example/src/test/java/com/ai/ipu/cache/redis/context/IpuContextData2.java

@@ -0,0 +1,48 @@
package com.ai.ipu.cache.redis.context;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
 * 上下文数据，存储的时候会被序列化
 */
public class IpuContextData2 implements Serializable{
    private static final long serialVersionUID = 183972639715505942L;
    private Map<String, String> data;
    private boolean isDirty;
    public IpuContextData2() {
        data = new HashMap<String, String>();
    }
    
    public Map<String, String> getData() {
        // TODO Auto-generated method stub
        return data;
    }
    public void setData(Map<String, String> data) {
        // TODO Auto-generated method stub
        this.data = data;
        setDirty(true);
    }
    
    public void put(String key, String value){
        data.put(key, value);
        setDirty(true);
    }
    
    public String get(String key){
        return data.get(key);
    }
    public boolean isDirty() {
        // TODO Auto-generated method stub
        return isDirty;
    }
    
    public void setDirty(boolean isDirty) {
        // TODO Auto-generated method stub
        this.isDirty = isDirty;
    }
}

ipu-redis-example/src/test/reources/ipu-cache.xml

@@ -0,0 +1,47 @@
<?xml version = '1.0' encoding = 'UTF-8'?>
<caches>
	<!-- ====================redis缓存============================ -->
	<cache name="ssn" type="redis">
		<servers>
	        <!-- 如果不是cluster，则只使用第一个redis -->
	        <server ip="47.105.160.21" port="7001" />
	        <server ip="47.105.160.21" port="7002" />
	        <server ip="47.105.160.21" port="7003" />
	        <server ip="121.42.183.206" port="7104" />
	        <server ip="121.42.183.206" port="7105" />
	        <server ip="121.42.183.206" port="7106" />
	    </servers>
		<!-- 客户端类型:Jedis,JedisCluster -->
	    <config name="clientType" value="JedisCluster"/>
	    <!-- 访问redis的密码，可以为空 -->
	    <config name="auth" value="ipu@321"/>
	    <!-- redis池的可用连接实例的最大数目，缺省为8 -->
	    <config name="poolSize" value="10"/>
	    <!-- redis池最多有多少个状态为idle(空闲的)的jedis实例，缺省为8,空闲连接大于这个数会进行回收 -->
	    <config name="maxIdle"/>
	    <!-- 最小空闲数，空闲连接小于这个数会建立新的连接，缺省为0 -->
	    <config name="minIdle"/>
	    <!-- 等待Response超时时间,默认5000ms -->
	    <config name="soTimeout"/>
	    <!-- 连接Redis Server超时时间,默认5000ms -->
	    <config name="connTimeout"/>
	    <!-- 出现异常最大重试次数 -->
	    <config name="maxAttempts"/>
	</cache>
	
	<cache name="data" type="redis">
		<servers>
	        <!-- 如果不是cluster，则只使用第一个redis -->
	        <server ip="47.105.160.21" port="7001" />
	    </servers>
	    <config name="auth" value="ipu@321"/>
	</cache>
	<cache name="single" type="redis">
		<servers>
	        <!-- 如果不是cluster，则只使用第一个redis -->
	        <server ip="47.105.160.21" port="7101" />
	    </servers>
	    <config name="auth" value="ipu@321"/>
	</cache>
	<!-- ================================================ -->
</caches>

ipu-redis-example/src/test/reources/memcache.xml

@@ -0,0 +1,12 @@
<?xml version = '1.0' encoding = 'UTF-8'?>
<memcache>
	<default-datacenter>center1</default-datacenter>
	<datacenter name="center1">
		<cluster name="wade_cache">
			<heartbeat-second>5</heartbeat-second>
			<pool-size>2</pool-size>
			<address master="47.105.160.21:11211" />
		</cluster>
	</datacenter>
</memcache>