Redis叢集架構環境搭建及jedis開發

阿新 • • 發佈：2018-12-24

1、下載redis

2、安裝redis

上傳安裝檔案到伺服器的/usr/local目錄下
解壓tar –zxvf redis-4.0.9.tar.gz
進入redis目錄，cd redis-4.0.9安裝：make && make install

3、redis叢集配置

1）在/usr/local建立redis_cluster資料夾

2）進入到redis_cluster建立 9000、9001、9002、9003、9004、9005六個資料夾

3）在redis-4.0.9目錄下找到redis.conf，複製redis.conf檔案到9000、9001、9002、9003、9004、9005

4）修改9000、9001、9002、9003、9004、9005目錄下的redis.conf配置（每個節點下的檔案都需要修改，可以使用vi命令去修改，也可以在本地改好，在上傳到伺服器）

port 9000 //埠9000、9001、9002、9003、9004、9005

bind 192.168.145.177 //預設ip為192.168.145.177需要改為其他節點機器可訪問的ip 否則建立叢集時無法訪問對應的埠，無法建立叢集

daemonize yes //redis後臺執行

pidfile /var/run/redis_9000.pid //pidfile檔案對應9000、9001、9002、9003、9004、9005

cluster-enabled yes //

開啟叢集把註釋#去掉

cluster-config-file nodes_7000.conf //叢集的配置 9000、9001、9002、9003、9004、9005

cluster-node-timeout 15000 //請求超時預設15秒，可自行設定

appendonly yes //aof日誌開啟有需要就開啟，它會每次寫操作都記錄一條日誌　

4、啟動redis

在/usr/local目錄下執行下面程式（redis-server這個命令在/usr/local/bin下面）

./bin/redis-server redis_cluster/9000/redis.conf

./bin/redis-server redis_cluster/9001/redis.conf

./bin/redis-server redis_cluster/9002/redis.conf

./bin/redis-server redis_cluster/9003/redis.conf

./bin/redis-server redis_cluster/9004/redis.conf

./bin/redis-server redis_cluster/9005/redis.conf

批量停止redis命令：pkill -9 redis

5、redis叢集

redis執行環境需要ruby，因此需先按照ruby執行環境。

5.1、安裝執行環境ruby

1）安裝ruby

命令：yum -y install ruby ruby-devel rubygems rpm-build

2）安裝rvm

命令：curl -L get.rvm.io | bash -s stable

第一次會失敗，彈出需要公鑰，然後

執行一下 gpg2 --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3

後面的這個串，每臺機器都不一樣，具體操作，看報錯的資訊。

再執行一次curl -L get.rvm.io | bash -s stable，即可安裝rvm成功。

3）source環境，讓rvm可用

source /usr/local/rvm/scripts/rvm

4）rvm list known檢視可用的ruby

[ruby-]1.8.6[-p420]

[ruby-]1.8.7[-head] # security released on head

[ruby-]1.9.1[-p431]

[ruby-]1.9.2[-p330]

[ruby-]1.9.3[-p551]

[ruby-]2.0.0[-p648]

[ruby-]2.1[.10]

[ruby-]2.2[.7]

[ruby-]2.3[.4]

[ruby-]2.4[.1]

5）rvm install 2.4.1 選最新的安裝

6）編譯環境

gem install redis

7）安裝rubygems

yum install -y rubygems

注意：如果yum用不了，需要先安裝yum

https://jingyan.baidu.com/article/ed2a5d1f5a9fbe09f6be17ea.html

5.2、建立叢集

命令：

/usr/local/redis-4.0.9/src/redis-trib.rb create --replicas 1 192.168.145.177:9000 192.168.145.177:9001 192.168.145.177:9002 192.168.145.177:9003 192.168.145.177:9004 192.168.145.177:9005

--replicas 1表示為叢集的master節點建立1個副本。那麼6個例項裡，有三個master，有三個是slave。

提示Can I set the above configuration? (type 'yes' to accept):

輸入yes

即可

5.2驗證叢集

在目錄/usr/local下，輸入

命令：./bin/redis-cli -h 192.168.145.177 -p 9000 -c

輸入：cluster info檢視叢集資訊

輸入：cluster nodes檢視叢集節點

測試：set test neusoft

get test

5.3驗證叢集容災情況

1）檢視redis程序：ps –ef|grep redis

2）關閉一臺主redis，殺掉9001程序：kill -9 12783

3）再次進入9000的redis例項，檢視現有的redis叢集節點情況。

./bin/redis-cli -h 192.168.145.177 -p 9000 –c

cluster nodes

可以看到9001已經fail了，現在少了一臺主redis。

4）啟動9001，檢測9001

/usr/local/redis-4.0.9/src/redis-trib.rb check 192.168.145.177:9001

檢視叢集節點資訊：

9001變成從redis，9004變為主redis

6、jedis開發

6.1、Maven依賴

<dependency>

    <groupId>redis.clients</groupId>

    <artifactId>jedis</artifactId>

    <version>2.8.2</version>

</dependency>

6.2、編碼

RedisCacheUtil（Redis快取操作類）

import org.apache.log4j.Logger;
import org.codehaus.jackson.type.TypeReference;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Redis快取操作類
 *
 * @author: alex
 * @time: 2018-06-04
 * @version: 1.0
 */
public class RedisCacheUtil {

    private static Logger log = Logger.getLogger(RedisCacheUtil.class);

    /**
     * 存放String型別的值
     *
     * @param key   key值
     * @param value value值
     * @throws Exception
     */
    public void setString(String key, String value) throws Exception {
        try {
            RedisConfigUtil.getJedisCluster().set(key, value);
        } catch (Exception e) {
            log.error(e);
            throw new Exception("儲存String物件的值出錯");
        }
    }

    /**
     * 獲取String型別的值
     *
     * @param key key值
     * @return 取得對應值
     * @throws Exception
     */
    public String getString(String key) throws Exception {
        String value = null;
        try {
            value = RedisConfigUtil.getJedisCluster().get(key);
        } catch (Exception e) {
            log.error(e);
            throw new Exception("獲取String物件的值出錯");
        }
        return value;
    }

    /**
     * 設定物件
     *
     * @param key    key值
     * @param object 物件
     * @throws Exception
     */
    public void setObject(String key, Object object) throws Exception {
        try {
            String json = JsonConvertUtil.objectConvertJSON(object);
            RedisConfigUtil.getJedisCluster().set(key, json);
        } catch (Exception e) {
            log.error(e);
            throw new Exception("儲存Object物件的值出錯");
        }
    }

    /**
     * 獲取物件
     *
     * @param key  key值
     * @param type 獲取物件的型別
     * @return 物件型別
     * @throws Exception
     */
    public Object getObject(String key, TypeReference<?> type) throws Exception {
        Object obj = null;
        try {
            if (RedisConfigUtil.getJedisCluster().exists(key)) {
                String json = RedisConfigUtil.getJedisCluster().get(key);
                obj = JsonConvertUtil.jsonConvertObject(json, type);
            }
        } catch (Exception e) {
            log.error(e);
            throw new Exception("獲取Object物件的值出錯");
        }
        return obj;
    }

    /**
     * 根據key、field取hash值，轉換為物件
     *
     * @param key
     * @param field
     * @return
     * @throws Exception
     */
    public Object hGet(String key, String field, TypeReference<?> type) throws Exception {
        try {
            if (RedisConfigUtil.getJedisCluster().exists(key)) {
                String json = RedisConfigUtil.getJedisCluster().hget(key, field);
                return JsonConvertUtil.jsonConvertObject(json, type);
            }
            return null;
        } catch (Exception e) {
            log.error(e);
            throw new Exception("獲取Hash時出錯");
        }
    }

    /**
     * 取key對應的所有hash，返回hashmap
     *
     * @param key
     * @return
     * @throws Exception
     */
    public Map hGetAll(String key) throws Exception {
        try {
            if (RedisConfigUtil.getJedisCluster().exists(key)) {
                return RedisConfigUtil.getJedisCluster().hgetAll(key);
            }
            return null;
        } catch (Exception e) {
            log.error(e);
            throw new Exception("獲取HashAll時出錯");
        }
    }

    /**
     * 存放到快取中，並設定失效時間
     *
     * @param key    key值
     * @param object 實體
     * @param min    失效時間
     * @throws Exception
     */
    public void setObjectByExpire(String key, Object object, int min) throws Exception {
        int seconds = min * 60;
        try {
            String json = JsonConvertUtil.objectConvertJSON(object);
            RedisConfigUtil.getJedisCluster().set(key, json);
            RedisConfigUtil.getJedisCluster().expire(key, seconds);
        } catch (Exception e) {
            log.error(e);
            throw new Exception("儲存Object物件的值並設定失效時間操作出錯");
        }
    }

    /**
     * 獲取快取資訊
     *
     * @param key  key值
     * @param type 實體型別
     * @return 獲取的物件
     * @throws Exception
     */
    public Object getExistObject(String key, TypeReference<?> type) throws Exception {
        try {
            if (RedisConfigUtil.getJedisCluster().exists(key)) {
                String json = RedisConfigUtil.getJedisCluster().get(key);
                return JsonConvertUtil.jsonConvertObject(json, type);
            }
            return null;
        } catch (Exception e) {
            log.error(e);
            throw new Exception("獲取Object物件的值並設定失效時間操作出錯");
        }
    }


    /**
     * 判斷快取中是否存在此key
     *
     * @param key key值
     * @return true存在，false不存在
     * @throws Exception
     */
    public boolean isExists(String key) throws Exception {
        boolean flag = false;
        try {
            flag = RedisConfigUtil.getJedisCluster().exists(key);
        } catch (Exception e) {
            log.error(e);
            throw new Exception("判斷快取中是否存在此key時出錯");
        }
        return flag;
    }

    /**
     * 根據key值刪除快取內容
     *
     * @param key key值
     * @throws Exception
     */
    public void deleteByKey(String key) throws Exception {
        try {
            if (RedisConfigUtil.getJedisCluster().exists(key)) {
                RedisConfigUtil.getJedisCluster().del(key);
            }
        } catch (Exception e) {
            log.error(e);
            throw new Exception("刪除此key時出錯");
        }
    }

    /**
     * 將相同key值放入到連結串列中
     *
     * @param key    key值
     * @param object 物件
     * @throws Exception
     */
    public void setList(String key, Object object) throws Exception {
        try {
            String json = JsonConvertUtil.objectConvertJSON(object);
            RedisConfigUtil.getJedisCluster().rpush(key, json);
        } catch (Exception e) {
            log.error(e);
            throw new Exception("儲存列表物件的值出錯");
        }
    }

    /**
     * 獲取列表物件
     *
     * @param key  key值
     * @param type 獲取物件的型別
     * @return 物件型別
     * @throws Exception
     */
    public List<Object> getList(String key, TypeReference<?> type) throws Exception {
        try {
            List<Object> list = new ArrayList<Object>();
            Long size = RedisConfigUtil.getJedisCluster().llen(key);
            List<String> bis = RedisConfigUtil.getJedisCluster().lrange(key, 0, size.intValue() - 1);
            for (String bi : bis) {
                Object obj = JsonConvertUtil.jsonConvertObject(bi, type);
                list.add(obj);
            }
            return list;
        } catch (Exception e) {
            log.error(e);
            throw new Exception("獲取列表物件出錯");
        }
    }

    /**
     * 儲存物件到set集合中，去掉重複資料
     *
     * @param key    key值
     * @param object 物件
     * @throws Exception
     */
    public void setSadd(String key, Object object) throws Exception {
        try {
            String json = JsonConvertUtil.objectConvertJSON(object);
            RedisConfigUtil.getJedisCluster().sadd(key, json);
        } catch (Exception e) {
            log.error(e);
            throw new Exception("儲存物件到set集合中出錯");
        }
    }

    /**
     * 獲取所有set集合中的物件
     *
     * @param key  key值
     * @param type 獲取物件的型別
     * @return 物件型別
     * @throws Exception
     */
    public List<Object> getSmembers(String key, TypeReference<?> type) throws Exception {
        try {
            List<Object> list = new ArrayList<Object>();
            java.util.Set<String> bis = RedisConfigUtil.getJedisCluster().smembers(key);
            for (String bi : bis) {
                Object obj = JsonConvertUtil.jsonConvertObject(bi, type);
                list.add(obj);
            }
            return list;
        } catch (Exception e) {
            log.error(e);
            throw new Exception("獲取所有set集合中的物件出錯");
        }
    }
}

RedisConfigUtil（Redis配置類）

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import java.util.LinkedHashSet;
import java.util.Set;

public class RedisConfigUtil {

    private static JedisCluster jedisCluster = null;

    private static Set<HostAndPort> nodes = null;

    private static JedisPoolConfig poolConfig = new JedisPoolConfig();

    static {
        nodes = new LinkedHashSet<HostAndPort>();
        nodes.add(new HostAndPort("192.168.145.177", 9000));
        nodes.add(new HostAndPort("192.168.145.177", 9001));
        nodes.add(new HostAndPort("192.168.145.177", 9002));
        nodes.add(new HostAndPort("192.168.145.177", 9003));
        nodes.add(new HostAndPort("192.168.145.177", 9004));
        nodes.add(new HostAndPort("192.168.145.177", 9005));
        // 最大連線數
        poolConfig.setMaxTotal(1);
        // 最大空閒數
        poolConfig.setMaxIdle(1);
        // 最大允許等待時間，如果超過這個時間還未獲取到連線，則會報JedisException異常：
        poolConfig.setMaxWaitMillis(60000);
    }

    public static JedisCluster getJedisCluster() {
        if(jedisCluster == null) {
            jedisCluster = new JedisCluster(nodes, poolConfig);
        }
        return jedisCluster;
    }
}

json轉換類JsonConvertUtil

import org.apache.log4j.Logger;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;

import java.io.IOException;

/**
 * JSON轉換
 * @author: alex
 * @time: 2018-06-04
 * @version: 1.0
 */
public class JsonConvertUtil {

    private static Logger log = Logger.getLogger(JsonConvertUtil.class);

    /**
     * 物件轉換為JSON
     * @param obj
     * @return
     */
    public static String objectConvertJSON(Object obj) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.writeValueAsString(obj);
        } catch (IOException e) {
            log.error("物件轉換為JSON出錯", e);
        }

        return null;
    }
    /**
     * 物件轉換為JSON
     * @param obj
     * @return
     */
    public static String toJSON(Object obj) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.writeValueAsString(obj);
        } catch (IOException e) {
            log.error("物件轉換為JSON出錯", e);
        }

        return null;
    }
    /**
     * json轉換為物件
     * @param json
     * @param
     * @return
     */
    public static Object jsonConvertObject(String json,TypeReference<?> type){
        Object obj = null;
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.readValue(json, type);
        } catch (IOException e) {
            log.error("JSON轉換為物件出錯", e);
        }

        return obj;
    }
    /**
     * json轉換為物件
     * @param json
     * @param
     * @return
     */
    public static Object jsonConvertObject(String json,Class<?> clazz){
        Object obj = null;
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            log.error("JSON轉換為物件出錯", e);
        }
        return obj;
    }
}

測試類：

import com.google.gson.reflect.TypeToken;
import org.codehaus.jackson.type.TypeReference;


public class RedisTest {

    public static void main(String[] args) {
        RedisCacheUtil redisUtil = new RedisCacheUtil();
        try {
//            redisUtil.setObject("test","alex");
//            redisUtil.getObject("test",  new TypeReference<String>() {});
            redisUtil.setString("test", "hello world!");
            System.out.println(redisUtil.getString("test"));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

6.3、執行報錯

No reachable node in cluster

原因：訪問不了redis叢集資訊。

解決辦法：

1）關閉防火牆：

systemctl stop firewalld

2）安裝iptables：

yum install -y iptables

yum install iptables-services

3）編輯可訪問埠：

vi /etc/sysconfig/iptables

增加的位置很重要，不能改變順序

-A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

-A INPUT -p icmp -j ACCEPT

-A INPUT -i lo -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 9000 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 9001 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 9002 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 9003 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 9004 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 9005 -j ACCEPT

-A INPUT -j REJECT --reject-with icmp-host-prohibited

-A FORWARD -j REJECT --reject-with icmp-host-prohibited

4）重啟

systemctl restart iptables.service

service iptables restart

7、參考文件

https://www.cnblogs.com/yingchen/p/6763524.html

https://www.cnblogs.com/kangoroo/p/7657616.html

https://blog.csdn.net/appleyk/article/details/78325499

https://blog.csdn.net/wojiushifeng1992/article/details/729040

Redis叢集架構環境搭建及jedis開發

1、下載redis 2、安裝redis 上傳安裝檔案到伺服器的/usr/local目錄下解壓tar –zxvf redis-4.0.9.tar.gz 進入redis目錄，cd redis-4.0.9安裝：make && make install

kafka使用筆記-基於SASL認證的kafka偽叢集windows環境搭建及測試

繼基於SASL認證的kafka偽叢集linux環境搭建及測試之後，由於環境的問題，需要在windows平臺搭建同樣的一個基於sasl認證的kakfa偽叢集環境。本次同樣使用的是 kafka_2.10-0.10.1.0.tgz 版本的kafka，整合zookeeper。只需要對此進行配

Redis學習系列二之.Net開發環境搭建及基礎資料結構String字串

一、簡介 Redis有5種基本資料結構,分別是string、list(列表)、hash(字典)、set(集合)、zset(有序集合),這是必須掌握的5種基本資料結構.注意Redis作為一個鍵值對快取系統,其所有的資料結構,都以唯一的key(字串)作為名稱,然後通過key來獲取對應的資料.

Redis叢集~windows下搭建Sentinel環境及它對主從模式的實際意義

回到目錄關於redis-sentinel出現的原因 Redis叢集的主從模式有個最大的弊端，就是當主master掛了之前，它的slave從伺服器無法提升為主，而在redis-sentinel出現之後，有效的解決了這個問題，它相當於是一個投票者或者哨兵，它時刻監視著redis叢集的各個伺服器，當主mas

NDK在windows下的開發環境搭建及開發過程

刷新 -1 ont static blog 簡單包名 mfp targe 在Android應用的開發project中。無論是遊戲還是普通應用。都時常會用到.so即動態鏈接庫，關於.so是什麽玩意兒，有什麽優點。這個大家能夠在網上查一下，本人不做過多解釋。.

Cordova 開發環境搭建及創建第一個app

maven 環境變量配置 src 搜索編譯 win 所有 log api 整理記錄使用cordova創建app應用程序並將其部署至Android系統移動設備上詳細過程，具體如下：一、前期安裝環境 1. 安裝JDK（java開發工具包） 2. 安裝gradle 3. 安裝

Linux鞏固記錄（1） J2EE開發環境搭建及網絡配置

version 環境 com sco 由於 lin spa node 開發環境由於要近期使用hadoop等進行相關任務執行，操作linux時候就多了以前只在linux上配置J2EE項目執行環境，無非配置下jdk，部署tomcat，再通過docker或者jenkins自動

Android開發之旅1：環境搭建及HelloWorld

lan 及其其它 ply 新項目 bsp 驗證 for 對話框 ——工欲善其事必先利其器引言本系列適合0基礎的人員，因為我就是從0開始的，此系列記錄我步入Android開發的一些經驗分享，望與君共勉！作為Android隊伍中的一個新人的

vuejs開發環境搭建及熱更新

輸入成功可用 app 熱更新 bpa bsp 保存 vue.js 推薦使用官方提供的命令行工具，可用於快速搭建大型單頁應用。只需一分鐘即可啟動帶熱重載、保存時靜態檢查以及可用於生產環境的構建配置項目。 1、安裝node https://nodejs.org/en/do

ROS開發環境搭建及入門

using nbsp cor bash body 開發環境 terminal evel new In new terminal: $ source /devel/setup.bash roscore is the first thing you should run w

智能合約開發環境搭建及Hello World合約

區塊鏈智能合約如果你對於以太坊智能合約開發還沒有概念（本文會假設你已經知道這些概念），建議先閱讀入門篇。就先學習任何編程語言一樣，入門的第一個程序都是Hello World。今天我們來一步一步從搭建以太坊智能合約開發環境開始，講解智能合約的Hello World如何編寫。開發環境搭建 Solid

Java配置----JDK開發環境搭建及環境變量配置

itl 屬性 ssp 出現 jdk1.8 width tools.jar 創建 pat 1、安裝JDK開發環境 2、配置環境變量：對於Java程序開發而言，主要會使用JDK的兩個命令：javac.exe、java.exe。路徑：C:\Java\jdk 1.7.0 _0

JDK開發環境搭建及環境變量配置

www img 代碼信息 cmd 需要系統 title oracl 1、安裝JDK開發環境下載網站：http://www.oracle.com/ 開始安裝JDK：修改安裝目錄如下：確定之後，單擊“下一步”。註：當提示安裝JRE時，可以選擇不要安裝。 2

spark JAVA 開發環境搭建及遠程調試

soft 匯總 bubuko tab 2.7 cati builder hadoop2.7 本地 spark JAVA 開發環境搭建及遠程調試以後要在項目中使用Spark 用戶昵稱文本做一下聚類分析，找出一些違規的昵稱信息。以前折騰過Hadoop，於是看了下Spark官網

spark JAVA 開發環境搭建及遠端除錯

spark JAVA 開發環境搭建及遠端除錯以後要在專案中使用Spark 使用者暱稱文字做一下聚類分析，找出一些違規的暱稱資訊。以前折騰過Hadoop，於是看了下Spark官網的文件以及 github 上官方提供的examples，看完了之後決定動手跑一個文字聚類的demo，於是有了下文。 1. 環境

kubernetes 環境搭建及基礎架構介紹及一個進銷存管理系統簡單搭建

kubernetes是一個全新的基於容器技術的分散式架構領先方案。它是谷歌十幾年來大規模應用容器技術的經驗積累和昇華的一個重要成果 kubernetes是一個完備的分散式系統支撐平臺。kubernetes具有完備的叢集管理能力，包括多層次的安全防護和准入機制，多租戶應用支撐能力，透明的服務註冊和

搭建redis叢集 Linux環境redis叢集搭建

Linux環境redis叢集搭建集群后tomcat context.xml的配置  <Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve"

Windows下JAVA開發環境搭建及環境變數配置

1、安裝JDK開發環境下載網站：http://www.oracle.com/ 開始安裝JDK：修改安裝目錄如下：確定之後，單擊“下一步”。注：當提示安裝JRE時，可以選擇不要安裝。 2、配置環境變數：對於Java程式開發而言，主要會

20181117--深入淺出區塊鏈智慧合約開發環境搭建及Hello World合約

安裝都完成了 geth --datadir “E:\blockchain\geth”testNet --dev console 啟動textNet eth.accouts 檢視以太坊的賬戶 eth.getBalance(eth.accounts[0]) 檢視賬戶餘額 person

Redis叢集架構搭建詳解

一、簡介這其實是一種分散式資料庫，就是通過分片的機制儲存資料，cluster中的每個節點僅僅儲存資料哭的一部分資料，本質上就是實現資料庫分片。這種叢集是一種去中心化的叢集，也就是說，叢集中的每個節點都可以是接入節點。這裡我簡單說一下這種去中心化的實現方式，比如有4個節點

Redis叢集架構環境搭建及jedis開發

1、下載redis

2、安裝redis

3、redis叢集配置

4、啟動redis

5、redis叢集

5.1、安裝執行環境ruby

5.2、建立叢集

5.2驗證叢集

5.3驗證叢集容災情況

6、jedis開發

6.1、Maven依賴

6.2、編碼

6.3、執行報錯

7、參考文件

相關推薦