Redis集群版在Java中的應用

1、配置redis集群

    <?xml version="1.0" encoding="UTF-8"?>  
    <redisCluster>  
        <!--userRoute -->  
        <clusterGroup name="userRoute" selectdb="1">  
            <server host="10.177.129.16" port="6379"></server>  
            <server host="10.177.129.15" port="6379"></server>  
        </clusterGroup>  
        <!--sessionRoute -->  
        <clusterGroup name="sessionRoute" selectdb="2">  
            <server host="10.177.129.16" port="6379"></server>  
            <server host="10.177.129.15" port="6379"></server>  
        </clusterGroup>  
        <!--publicData -->  
        <clusterGroup name="publicData">  
            <server host="10.177.129.16" port="6379"></server>  
            <server host="10.177.129.15" port="6379"></server>  
        </clusterGroup>  
    </redisCluster>  

2、創建redis連接屬性實體類

    package net.itxm.cms.syscore.pojo;  
    /**
     * redis連接屬性
     *
     */  
    public class RedisCluster   
    {  
        private String selectdb;  
        private String hostIp;  
        private String  port;  
        public String getSelectdb() {  
            return selectdb;  
        }  
        public void setSelectdb(String selectdb) {  
            this.selectdb = selectdb;  
        }  
        public String getHostIp() {  
            return hostIp;  
        }  
        public void setHostIp(String hostIp) {  
            this.hostIp = hostIp;  
        }  
        public String getPort() {  
            return port;  
        }  
        public void setPort(String port) {  
            this.port = port;  
        }  
    }  

3、解析redis集群配置

    package net.itxm.itreasury.test.jedis;  
    import java.io.IOException;  
    import java.util.ArrayList;  
    import java.util.HashMap;  
    import java.util.Iterator;  
    import java.util.List;  
    import java.util.Map;  
    import java.util.Set;  
    import org.dom4j.Document;  
    import org.dom4j.DocumentException;  
    import org.dom4j.Element;  
    import org.dom4j.io.SAXReader;  
    import org.springframework.core.io.ClassPathResource;   
    import org.springframework.core.io.Resource;   
    import org.springframework.core.io.support.EncodedResource;  
    /**
     * 解析redis集群配置
     *
     */  
    public class RedisConfig {  
    public static Map<String,List<RedisCluster>> redisGroupMap = null;  
    //有參構造函數  
    public RedisConfig()  
    {  
    }  
    //獲取所有clusterGroup組的鍵值對  
    public static Map<String,List<RedisCluster>> getRedisGroupMap(){  
        //讀取xml文件  
        Document document=readXmlFile();  
        //獲得clusterGroup節點的key 和 list  
        if(redisGroupMap == null)  
        {  
            redisGroupMap=getMapByItemsGroup(document);  
        }  
        return redisGroupMap;  
    }  
    //讀取redisConfig配置文件  
    private static Document readXmlFile(){  
        //創建讀入對象  
        SAXReader reader = new SAXReader();  
        //創建document實例  
        Document doc=null;  
        try {  
        //從類路徑下加載文件redisConfig.xml    
        Resource resource = new ClassPathResource("redisClusterConfig.xml");   
        //指定文件資源對應的編碼格式（UTF-8),這樣才能正確讀取文件的內容，而不會出現亂碼  
        EncodedResource encodeResource = new EncodedResource(resource,"UTF-8");   
        doc = reader.read(encodeResource.getReader());  
        }   
        catch (IOException e) {  
            System.out.println("無法讀取系統配置文件redisConfig.xml,可能該文件不存在");  
        } catch (DocumentException e) {  
            System.out.println("解析redisConfig.xml文件出現異常");  
        }  
        return doc;  
    }  
    //讀取xml節點,返回節點為redisGroup的Map  
    private  static Map<String,List<RedisCluster>> getMapByItemsGroup(Document document){  
        Map<String,List<RedisCluster>> itemmap=new HashMap<String,List<RedisCluster>>();  
        try{  
            //獲得根節點  
            Element root=document.getRootElement();  
            //獲得根節點下所有子節點clusterGroup的list  
            List itemsList=root.selectNodes("./clusterGroup");  
            for(int i=0;i<itemsList.size();i++){  
            //獲得節點Items  
            Element items=(Element)itemsList.get(i);  
            String groupName=items.attribute("name").getText();  
            String selectdb = items.attribute("selectdb")==null?"":items.attribute("selectdb").getText();  
    //      if(groupName!=null&&groupName.equals(this.getGroupName())){  
                 //獲得clusterGroup下所有子節點service的list  
                 List itemList=items.elements();  
                 //獲得service節點的值  
                 List<RedisCluster> redisClusterList = getItemList(itemList,selectdb);  
                 itemmap.put(groupName, redisClusterList);  
    //      }  
            }  
        }  
        catch(Exception e){  
        }  
        return itemmap;  
    }  
    //獲得所有Item下節點的redis服務節點  
    private static List<RedisCluster> getItemList(List itemList,String selectdb){  
        List<RedisCluster> redisClusterList = new ArrayList<RedisCluster>();  
        for(int i=0;i<itemList.size();i++){  
            //獲得節點server  
            Element item=(Element)itemList.get(i);  
            String hostIp =  item.attribute("host").getText();  
            String port = item.attribute("port").getText();  
            RedisCluster redisCluster =new RedisCluster();  
            redisCluster.setHostIp(hostIp);  
            redisCluster.setPort(port);  
            redisCluster.setSelectdb(selectdb);  
            redisClusterList.add(redisCluster);  
       }  
        return redisClusterList;  
    }  
    public static void main(String[] args) {  
        getRedisGroupMap();  
        //JedisUtil.insertPublicDataObject("user1", "張三", JedisUtil.ONLINE_USER);  
        //JedisUtil.insertPublicDataObject("user2", "李四", JedisUtil.ONLINE_USER);  
        //JedisUtil.insertPublicDataObject("user3", "王五", JedisUtil.ONLINE_USER);  
          Set s = JedisUtil.getAllSet(JedisUtil.ONLINE_USER);  
          Iterator it = s.iterator();      
          while (it.hasNext()) {  
           String key = (String) it.next();  
           String value = JedisUtil.getString(key,JedisUtil.ONLINE_USER);  
           System.out.println(key + value);  
          }  
        String test = JedisUtil.getString("user1",JedisUtil.ONLINE_USER);  
        System.out.println(test);  
    }  
    }  

4、操作redis數據庫的工具類

    package net.itxm.cms.syscore.utils;  
    import java.lang.reflect.Type;  
    import java.util.List;  
    import java.util.Set;  
    import java.util.zip.CRC32;  
    import redis.clients.jedis.Jedis;  
    import redis.clients.jedis.exceptions.JedisConnectionException;  
    import com.google.gson.Gson;  
    import com.isoftstone.cms.syscore.pojo.RedisCluster;  
    public class JedisUtil {  
        // 數據庫  
        public static final String STORE_LOGINUSER = "4";// 商戶登陸用戶  
        public static final String STORE_INFO = "5";// 商戶狀態 商戶購買服務有效期  
        public static final String CHECK_CODE = "6";// 驗證碼  
        public static final String MENU = "7";// 全部菜單  
        public static final String SERVICE = "8";// 服務收費信息  
        public static final String STORE_LOGINKEY = "9";// 初始化登錄公鑰 私鑰對  
        // 固定key  
        public static final String ALL_MENU_KEY = "ALL_MENU_KEY";  
        public static final String BUY_SERVICE_KEY = "BUY_SERVICE_KEY";// 服務收費購買key  
        public static final String ALL_SERVICE_KEY = "ALL_SERVICE_KEY";//所有服務  
        public static final String MENU_AUTHORITY = "MENU_AUTHORITY";// 菜單權限  
        public static final String STORE_MENU_KEY = "STORE_MENU_KEY";// 需要商戶分配的業務菜單  
        public static final String STORE_SERVICE_KEY = "STORE_SERVICE_KEY";// 商戶收費key  
        public static final String SYSTE_MENU_KEY = "SYSTE_MENU_KEY";// 系統管理菜單key  
        // jedis服務組業務類型  
        public static final String CONT_CLUSTERNAME_PUBLICDATA = "publicData";  
        public static final String CONT_CLUSTERNAME_SESSIONROUTE = "sessionRoute";  
        public static final String CONT_CLUSTERNAME_USERROUTE = "userRoute";  
        // 操作方式 0 插入 1獲取 2 刪除  
        public static final long INSERT_OPERATION = 0;  
        public static final long GET_OPERATION = 1;  
        public static final long DELETE_OPERATION = 2;  
        // 驗證碼過期秒數  
        public static final int CHECKCODE_EXPIRESECONDS = 5*60;  
        // session過期秒數  
        public static final int EXPIRESECONDS = 30 * 60;  
        private static void closeJedis(Jedis jedis) {  
            try {  
                jedis.quit();  
            } catch (JedisConnectionException e) {  
                e.printStackTrace();  
            }  
            jedis.disconnect();  
        }  
        /**
         * 根據Key獲取字符串
         *
         * @param key
         * @param jedisGroup
         */  
        public static String getString(String key, String selectdb) {  
            Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);  
            return jedis.get(key);  
        }  
        /**
         * 獲取所有數據set
         * @param selectdb
         * @return
         */  
        public static Set getAllSet(String selectdb) {  
            Jedis jedis = getDataJedis(GET_OPERATION, selectdb);  
            return jedis.keys("*");  
        }  
        /**
         * 默認取配置文件的第一個數據庫
         * @param operation
         * @param selectdb
         * @return
         */  
        private static Jedis getDataJedis(long operation, String selectdb) {  
            if (RedisConfig.redisGroupMap == null) {  
                RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();  
            }  
            List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(CONT_CLUSTERNAME_PUBLICDATA);  
            int clusterNo = 0;//默認存到第一個  
            RedisCluster cluster = clustersList.get(clusterNo);  
            Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));  
            jedis.select(Integer.valueOf(selectdb));  
            return jedis;  
        }  
        /**
         * 刪除數據
         *
         * @param key
         * @param jedisGroup
         */  
        public static void deleteObject(String key, String jedisGroup) {  
            Jedis jedis = getJedis(key, jedisGroup, DELETE_OPERATION);  
            jedis.del(key);  
            closeJedis(jedis);  
        }  
        /**
         * 刪除公共數據
         *
         * @param key
         * @param objClass
         * @param selectdb
         */  
        public static void deletePublicDataObject(String key, String selectdb) {  
            Jedis jedis = getPublicDataJedis(key, DELETE_OPERATION, selectdb);  
            jedis.del(key);  
            closeJedis(jedis);  
        }  
        /**
         * 獲取jedis的庫實例
         *
         * @param key
         * @param jedisGroup
         * @param operation
         * @return
         */  
        private static Jedis getJedis(String key, String jedisGroup, long operation) {  
            if (RedisConfig.redisGroupMap == null) {  
                RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();  
            }  
            List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(jedisGroup);  
            int arrayLength = clustersList.size();  
            // 根據key值算出該信息應該存入到那個  
            int clusterNo = getRedisNo(key, arrayLength);  
            RedisCluster cluster = clustersList.get(clusterNo);  
            Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));  
            jedis.select(Integer.valueOf(cluster.getSelectdb()));  
            return jedis;  
        }  
        /**
         * redis key值獲取對象
         *
         * @param key
         * @param objClass
         * @param jedisGroup
         * @return
         */  
        public static Object getObject(String key, Class objClass, String jedisGroup) {  
            Jedis jedis = getJedis(key, jedisGroup, GET_OPERATION);  
            String sObj = jedis.get(key);  
            closeJedis(jedis);  
            Gson gson = new Gson();  
            return gson.fromJson(sObj, objClass);  
        }  
        /**
         * 獲取公共數據jedis的庫實例
         *
         * @param key
         * @param jedisGroup
         * @param operation
         * @return
         */  
        private static Jedis getPublicDataJedis(String key, long operation, String selectdb) {  
            if (RedisConfig.redisGroupMap == null) {  
                RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();  
            }  
            List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(CONT_CLUSTERNAME_PUBLICDATA);  
            int arrayLength = clustersList.size();  
            // 根據key值算出該信息應該存入到那個  
            int clusterNo = getRedisNo(key, arrayLength);  
            RedisCluster cluster = clustersList.get(clusterNo);  
            Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));  
            jedis.select(Integer.valueOf(selectdb));  
            return jedis;  
        }  
        /**
         * publicdata redis key值獲取對象
         *
         * @param key
         * @param objClass
         * @param jedisGroup
         * @return
         */  
        public static Object getPublicDataObject(String key, Class objClass, String selectdb) {  
            Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);  
            String sObj = jedis.get(key);  
            closeJedis(jedis);  
            Gson gson = new Gson();  
            return gson.fromJson(sObj, objClass);  
        }  
        /**
         * publicdata redis key值獲取對象 List<Entity>
         *
         * @param key
         * @param objClass
         * @param jedisGroup
         * @return
         */  
        public static Object getPublicDataObjectByType(String key, Type type, String selectdb) {  
            Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);  
            String sObj = jedis.get(key);  
            closeJedis(jedis);  
            Gson gson = new Gson();  
            return gson.fromJson(sObj, type);  
        }  
        /**
         * 獲取redis服務器庫編號
         *
         * @param hashKey
         * @return
         */  
        public static int getRedisNo(String key, int arraySize) {  
            long hashKey = hash(key);  
            int redisNo = (int) (hashKey % arraySize);  
            return redisNo;  
        }  
        /**
         * 根據key值算出hash值
         *
         * @param k
         * @return
         */  
        public static long hash(String k) {  
            CRC32 crc32 = new CRC32();  
            crc32.update(k.getBytes());  
            return crc32.getValue();  
        }  
        /**
         * redis 根據key值將對象插入到不同的庫中
         *
         * @param key
         * @param insertObj
         * @param jedisGroup
         */  
        public static void insertObject(String key, Object insertObj, String jedisGroup) {  
            Jedis jedis = getJedis(key, jedisGroup, INSERT_OPERATION);  
            Gson gson = new Gson();  
            jedis.set(key, gson.toJson(insertObj));  
            closeJedis(jedis);  
        }  
        /**
         * redis 根據key值將對象插入到不同的庫中
         *
         * @param key
         * @param insertObj
         * @param jedisGroup
         * @param expire
         */  
        public static void insertObject(String key, Object insertObj, String jedisGroup, int expireSeconds) {  
            Jedis jedis = getJedis(key, jedisGroup, INSERT_OPERATION);  
            Gson gson = new Gson();  
            jedis.setex(key, expireSeconds, gson.toJson(insertObj));  
            closeJedis(jedis);  
        }  
        /**
         * publicdata redis 根據key值將對象插入到不同的庫中
         *
         * @param key
         * @param insertObj
         * @param jedisGroup
         */  
        public static void insertPublicDataObject(String key, Object insertObj, String selectdb) {  
            Jedis jedis = getPublicDataJedis(key, INSERT_OPERATION, selectdb);  
            Gson gson = new Gson();  
            jedis.set(key, gson.toJson(insertObj));  
            closeJedis(jedis);  
        }  
        /**
         * publicdata redis 根據key值將對象插入到不同的庫中,
         *
         * @param key
         * @param insertObj
         * @param jedisGroup
         * @param expireSeconds
         */  
        public static void insertPublicDataObject(String key, Object insertObj, String selectdb, int expireSeconds) {  
            Jedis jedis = getPublicDataJedis(key, INSERT_OPERATION, selectdb);  
            Gson gson = new Gson();  
            jedis.setex(key, expireSeconds, gson.toJson(insertObj));  
            closeJedis(jedis);  
        }  
        /**
         * 更新redis中key的超時時間
         *
         * @param key
         * @param jedisGroup
         * @param expireSeconds
         */  
        public static void resetExpireSeconds(String key, String jedisGroup, int expireSeconds) {  
            Jedis jedis = getJedis(key, jedisGroup, GET_OPERATION);  
            jedis.expire(key, expireSeconds);  
            closeJedis(jedis);  
        }  
    }  

5、所需jar包