上篇文章 Redis叢集解決方案 已經已經介紹了Redis應用場景及效能、Redis單機部署以及叢集部署的操作，下面將講解如何使用JAVA客戶端呼叫搭建好的Redis叢集環境。

    先搭建一個Java工程JRedisUtils,匯入Redis3.0相應的jar,點選此處下載（commons-pool2-2.4.2.jar jedis-3.0.0.jar jedis-3.0.0-javadoc.jar jedis-3.0.0-sources.jar）

   現在直接貼上程式碼:

package com.jredis.util;

import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

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;


/**
 * Redis分散式呼叫API
 * @author pengtian
 * @Date 2016年11月17日18:10:52
 */
public class JRedisClient {
	
	
	
    private static String RESULT_OK = "OK";
	private static Set<HostAndPort> clusterNodes = null;
	private static JedisPoolConfig config = null;
	private static JedisCluster jedisCluster=null;
	
	private JRedisClient() {}  
    private static JRedisClient jredisClient=null;  
    //靜態工廠方法   
    public static synchronized  JRedisClient getInstance() {  
         if (jredisClient == null) {    
        	 jredisClient = new JRedisClient();  
        	 jredisClient.clusterInit();
         } else{
        	 System.out.println("JRedisClient已經實列化");
         }   
         return jredisClient;  
    }  
	
   /**
    * 獲取操作redis的客戶端
    * @return
    */
    public JedisCluster getJedisCluster(){
    	if(jedisCluster==null){
    		JRedisClient.getInstance();
    	}
    	return jedisCluster;
    }

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*//JRedisClient jRedisClient =new JRedisClient("192.168.113.134",7006);
		System.out.println("set===>"+jRedisClient.set("key3", "key3333333333333333333"));
		System.out.println("get===>"+jRedisClient.get("key3"));*/
		
		JRedisClient jredisClient =JRedisClient.getInstance();
		jredisClient =JRedisClient.getInstance();
		/*System.out.println(jredisClient.set("FP_100000","FP_100000000000000"));
		System.out.println(jredisClient.get("FP_100000"));
		List<String> list = new ArrayList<String>();
		list.add("LIST1");
		list.add("LIST2");
		list.add("LIST3");
		jredisClient.list("LIST", 3600, list);*/
		
	/*	System.out.println("===>"+jredisClient.lrange("LIST", 0, -1));
		System.out.println("===>"+jredisClient.lrange("LIST", 0, 1));
		List<String> listGet = jredisClient.lrange("LIST",0, 2);
		for(int i=0;i<listGet.size();i++){
			System.out.println("===>"+listGet.get(i).toString());
		}
		*/
		for(int i=1;i<=10;i++){
			jredisClient.set("kEY_"+i,1000,i+"");
		}
		
		for(int i=1;i<=10;i++){
			System.out.println(i+"==>"+jredisClient.get("kEY_"+i));
		}
		
		/*for(int i=1;i<=10000;i++){
			System.out.println(i+"==>"+jredisClient.del("kEY_"+i));
		}*/
		
		/*TreeSet<String> keys = jredisClient.keys("kEY_*"); 
		if(keys.size()>0){  
		   System.out.println("SIZE:"+keys.size());  
		   for(String str:keys){
			   System.out.println("==============>"+str);   
		   }
		} else{
			System.out.println("No keys");  
		}*/
		

	}
	
	
	



	/**
	 * 配置Redis分散式節點
	 */
	private void genClusterNode() {
	    clusterNodes = new HashSet<HostAndPort>();
	    clusterNodes.add(new HostAndPort("192.168.113.133", 7000));
	    clusterNodes.add(new HostAndPort("192.168.113.133", 7011));
	    clusterNodes.add(new HostAndPort("192.168.113.133", 7001));
	    clusterNodes.add(new HostAndPort("192.168.113.134", 7006));
	    clusterNodes.add(new HostAndPort("192.168.113.134", 7007));
	    clusterNodes.add(new HostAndPort("192.168.113.131", 7009));
	    clusterNodes.add(new HostAndPort("192.168.113.131", 7008));
	}
	
	/**
	 * 實列化JRedis 執行緒池相關配置
	 */
	private void genJedisConfig() {
		 config = new JedisPoolConfig();
		 //pool 最大執行緒數
	     config.setMaxTotal(100000);
	     // 控制一個pool最多有多少個狀態為idle(空閒的)的jedis例項。
	     config.setMaxIdle(100);
	     //表示當borrow(引入)一個jedis例項時，最大的等待時間，如果超過等待時間，則直接丟擲JedisConnectionException；
	     config.setMaxWaitMillis(180);
	     // 在borrow一個jedis例項時，是否提前進行validate操作；如果為true，則得到的jedis例項均是可用的；
	     config.setTestOnBorrow(true);
	}
	
    /**
     * JRedis分散式初始化
     */
	private void clusterInit() {
		if(jedisCluster == null){
			/*  配置Redis分散式節點 **/
		    genClusterNode();
		    /* 實列化JRedis 執行緒池相關配置 **/
		    genJedisConfig();
		    
		    jedisCluster = new JedisCluster(clusterNodes, 5000, config);
		}
	}
	
	
	/**
	 * 字串型別資料儲存
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean  set(String key, String value)
    {
		return this.set(key,0,value);
	}
	
	/**
	 * 字串資料型別儲存並設定有效期
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean  set(String key, int seconds,String value)
    {
		boolean isOk = false;
		String returnResult = "";
		if(seconds>0){
			returnResult= jedisCluster.setex(key, seconds, value);
		}else{
			returnResult = jedisCluster.set(key, value);
		}
		if(RESULT_OK.equals(returnResult)){
			isOk = true;
		}
		return isOk;
	}
    
	/**
	 * 獲取儲存的字串型別資料
	 * @param key
	 * @return
	 */
	public String get(String key) {
		return jedisCluster.get(key);
	}
	
	/**
	 * Map<String,String>型別資料儲存
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean hmset(String key, Map<String,String> hashMap){
		return this.hmset(key, 0, hashMap);
	}
	
	/**
	 * Map<String,String>型別資料儲存，並設定有效期
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean hmset(String key,int seconds, Map<String,String> hashMap){
		boolean isOk = false;
		String returnResult = "";
		returnResult = jedisCluster.hmset(key, hashMap);
		if(seconds>0){
		 this.expire(key, seconds);
		}
		if(RESULT_OK.equals(returnResult)){
			isOk = true;
		}
		return isOk;
	}
	/**
	 * 獲取Map中的指定KEY值
	 * @param key
	 * @param field
	 * @return String
	 */
	public String  hget(String key,String field){
		return jedisCluster.hget(key, field);
	}
	
	/**
	 * 獲取指定key中Map
	 * @param key
	 * @return Map
	 */
	public Map  hget(String key){
		return jedisCluster.hgetAll(key);
	}
	
	/**
	 * 計數遞增
	 * @param key
	 * @return
	 */
	public long incr(String key){
	
		return jedisCluster.incr(key);
	}
	
	/**
	 * 計數遞減
	 * @param key
	 * @return
	 */
	public long decr(String key){
		return 	jedisCluster.decr(key);
	}
	
	
	
	/**
	 * 設定KEY的有效期
	 * @param key
	 * @param seconds
	 * @return
	 */
	public long expire(String key,int seconds){
		return jedisCluster.expire(key, seconds);
	}
	
	/**
	 * 刪除指定KEY
	 * @param key
	 * @return
	 */
	public long del(String key){
		return jedisCluster.del(key);
	}
	
	/**
	 * 儲存List<String>資料
	 * @param key
	 * @param seconds
	 * @param list
	 */
	public long list(String key,List<String> list){
		return this.list(key, 0, list);
		
	}
	
	/**
	 * 儲存List<String>資料並設定有效期
	 * @param key
	 * @param seconds
	 * @param list
	 */
	public long list(String key,int seconds,List<String> list){
		long returnResult = 0;
		String[] strArray = null;
		if(list!=null&&!list.isEmpty()){
			strArray = new String[list.size()];
			for(int i=0;i<list.size();i++){
				strArray[i]=list.get(i).toString();
			}
		}
		returnResult = jedisCluster.lpush(key,strArray);
		if(seconds>0){
			 this.expire(key, seconds);
		}
		return returnResult;
	}
	
	/**
	 * 獲取List<String>
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public List<String> lrange(String key,long start,long end){
		return jedisCluster.lrange(key, start, end);
	}
	
	/**
	 * KEYS 獲取String資料型別的值
	 * @param pattern
	 * @return
	 */
    public TreeSet<String> keys(String pattern){  
        TreeSet<String> keys = new TreeSet<String>();  
        Map<String, JedisPool> clusterNodes = jedisCluster.getClusterNodes();  
        for(String k : clusterNodes.keySet()){  
            JedisPool jp = clusterNodes.get(k);  
            Jedis connection = jp.getResource();  
            try {  
                keys.addAll(connection.keys(pattern));  
            } catch(Exception e){  
            	e.printStackTrace();
            } finally{  
                connection.close();//用完一定要close這個連結！！！  
            }  
        }  
        return keys;  
    }  

	
	
 

}
 

JRedisClient已經實列化
1==>1
2==>2
3==>3
4==>4
5==>5
6==>6
7==>7
8==>8
9==>9
10==>10