1、配置redis集群

  1.     <?xml version="1.0" encoding="UTF-8"?>
  2.     <redisCluster>
  3.         <!--userRoute -->
  4.         <clusterGroup name="userRoute" selectdb="1">
  5.             <server host="10.177.129.16" port="6379"></server>
  6.             <server host="10.177.129.15" port="6379"></server>
  7.         </clusterGroup>
  8.         <!--sessionRoute -->
  9.         <clusterGroup name="sessionRoute" selectdb="2">
  10.             <server host="10.177.129.16" port="6379"></server>
  11.             <server host="10.177.129.15" port="6379"></server>
  12.         </clusterGroup>
  13.         <!--publicData -->
  14.         <clusterGroup name="publicData">
  15.             <server host="10.177.129.16" port="6379"></server>
  16.             <server host="10.177.129.15" port="6379"></server>
  17.         </clusterGroup>
  18.     </redisCluster>

2、创建redis连接属性实体类

  1.     package net.itxm.cms.syscore.pojo;
  2.     /**
  3.      * redis连接属性
  4.      *
  5.      */
  6.     public class RedisCluster
  7.     {
  8.         private String selectdb;
  9.         private String hostIp;
  10.         private String  port;
  11.         public String getSelectdb() {
  12.             return selectdb;
  13.         }
  14.         public void setSelectdb(String selectdb) {
  15.             this.selectdb = selectdb;
  16.         }
  17.         public String getHostIp() {
  18.             return hostIp;
  19.         }
  20.         public void setHostIp(String hostIp) {
  21.             this.hostIp = hostIp;
  22.         }
  23.         public String getPort() {
  24.             return port;
  25.         }
  26.         public void setPort(String port) {
  27.             this.port = port;
  28.         }
  29.     }

3、解析redis集群配置

  1.     package net.itxm.itreasury.test.jedis;
  2.     import java.io.IOException;
  3.     import java.util.ArrayList;
  4.     import java.util.HashMap;
  5.     import java.util.Iterator;
  6.     import java.util.List;
  7.     import java.util.Map;
  8.     import java.util.Set;
  9.     import org.dom4j.Document;
  10.     import org.dom4j.DocumentException;
  11.     import org.dom4j.Element;
  12.     import org.dom4j.io.SAXReader;
  13.     import org.springframework.core.io.ClassPathResource;
  14.     import org.springframework.core.io.Resource;
  15.     import org.springframework.core.io.support.EncodedResource;
  16.     /**
  17.      * 解析redis集群配置
  18.      *
  19.      */
  20.     public class RedisConfig {
  21.     public static Map<String,List<RedisCluster>> redisGroupMap = null;
  22.     //有参构造函数
  23.     public RedisConfig()
  24.     {
  25.     }
  26.     //获取所有clusterGroup组的键值对
  27.     public static Map<String,List<RedisCluster>> getRedisGroupMap(){
  28.         //读取xml文件
  29.         Document document=readXmlFile();
  30.         //获得clusterGroup节点的key 和 list
  31.         if(redisGroupMap == null)
  32.         {
  33.             redisGroupMap=getMapByItemsGroup(document);
  34.         }
  35.         return redisGroupMap;
  36.     }
  37.     //读取redisConfig配置文件
  38.     private static Document readXmlFile(){
  39.         //创建读入对象
  40.         SAXReader reader = new SAXReader();
  41.         //创建document实例
  42.         Document doc=null;
  43.         try {
  44.         //从类路径下加载文件redisConfig.xml
  45.         Resource resource = new ClassPathResource("redisClusterConfig.xml");
  46.         //指定文件资源对应的编码格式（UTF-8),这样才能正确读取文件的内容，而不会出现乱码
  47.         EncodedResource encodeResource = new EncodedResource(resource,"UTF-8");
  48.         doc = reader.read(encodeResource.getReader());
  49.         }
  50.         catch (IOException e) {
  51.             System.out.println("无法读取系统配置文件redisConfig.xml,可能该文件不存在");
  52.         } catch (DocumentException e) {
  53.             System.out.println("解析redisConfig.xml文件出现异常");
  54.         }
  55.         return doc;
  56.     }
  57.     //读取xml节点,返回节点为redisGroup的Map
  58.     private  static Map<String,List<RedisCluster>> getMapByItemsGroup(Document document){
  59.         Map<String,List<RedisCluster>> itemmap=new HashMap<String,List<RedisCluster>>();
  60.         try{
  61.             //获得根节点
  62.             Element root=document.getRootElement();
  63.             //获得根节点下所有子节点clusterGroup的list
  64.             List itemsList=root.selectNodes("./clusterGroup");
  65.             for(int i=0;i<itemsList.size();i++){
  66.             //获得节点Items
  67.             Element items=(Element)itemsList.get(i);
  68.             String groupName=items.attribute("name").getText();
  69.             String selectdb = items.attribute("selectdb")==null?"":items.attribute("selectdb").getText();
  70.     //      if(groupName!=null&&groupName.equals(this.getGroupName())){
  71.                  //获得clusterGroup下所有子节点service的list
  72.                  List itemList=items.elements();
  73.                  //获得service节点的值
  74.                  List<RedisCluster> redisClusterList = getItemList(itemList,selectdb);
  75.                  itemmap.put(groupName, redisClusterList);
  76.     //      }
  77.             }
  78.         }
  79.         catch(Exception e){
  80.         }
  81.         return itemmap;
  82.     }
  83.     //获得所有Item下节点的redis服务节点
  84.     private static List<RedisCluster> getItemList(List itemList,String selectdb){
  85.         List<RedisCluster> redisClusterList = new ArrayList<RedisCluster>();
  86.         for(int i=0;i<itemList.size();i++){
  87.             //获得节点server
  88.             Element item=(Element)itemList.get(i);
  89.             String hostIp =  item.attribute("host").getText();
  90.             String port = item.attribute("port").getText();
  91.             RedisCluster redisCluster =new RedisCluster();
  92.             redisCluster.setHostIp(hostIp);
  93.             redisCluster.setPort(port);
  94.             redisCluster.setSelectdb(selectdb);
  95.             redisClusterList.add(redisCluster);
  96.        }
  97.         return redisClusterList;
  98.     }
  99.     public static void main(String[] args) {
  100.         getRedisGroupMap();
  101.         //JedisUtil.insertPublicDataObject("user1", "张三", JedisUtil.ONLINE_USER);
  102.         //JedisUtil.insertPublicDataObject("user2", "李四", JedisUtil.ONLINE_USER);
  103.         //JedisUtil.insertPublicDataObject("user3", "王五", JedisUtil.ONLINE_USER);
  104.           Set s = JedisUtil.getAllSet(JedisUtil.ONLINE_USER);
  105.           Iterator it = s.iterator();
  106.           while (it.hasNext()) {
  107.            String key = (String) it.next();
  108.            String value = JedisUtil.getString(key,JedisUtil.ONLINE_USER);
  109.            System.out.println(key + value);
  110.           }
  111.         String test = JedisUtil.getString("user1",JedisUtil.ONLINE_USER);
  112.         System.out.println(test);
  113.     }
  114.     }

4、操作redis数据库的工具类

  1.     package net.itxm.cms.syscore.utils;
  2.     import java.lang.reflect.Type;
  3.     import java.util.List;
  4.     import java.util.Set;
  5.     import java.util.zip.CRC32;
  6.     import redis.clients.jedis.Jedis;
  7.     import redis.clients.jedis.exceptions.JedisConnectionException;
  8.     import com.google.gson.Gson;
  9.     import com.isoftstone.cms.syscore.pojo.RedisCluster;
  10.     public class JedisUtil {
  11.         // 数据库
  12.         public static final String STORE_LOGINUSER = "4";// 商户登陆用户
  13.         public static final String STORE_INFO = "5";// 商户状态 商户购买服务有效期
  14.         public static final String CHECK_CODE = "6";// 验证码
  15.         public static final String MENU = "7";// 全部菜单
  16.         public static final String SERVICE = "8";// 服务收费信息
  17.         public static final String STORE_LOGINKEY = "9";// 初始化登录公钥 私钥对
  18.         // 固定key
  19.         public static final String ALL_MENU_KEY = "ALL_MENU_KEY";
  20.         public static final String BUY_SERVICE_KEY = "BUY_SERVICE_KEY";// 服务收费购买key
  21.         public static final String ALL_SERVICE_KEY = "ALL_SERVICE_KEY";//所有服务
  22.         public static final String MENU_AUTHORITY = "MENU_AUTHORITY";// 菜单权限
  23.         public static final String STORE_MENU_KEY = "STORE_MENU_KEY";// 需要商户分配的业务菜单
  24.         public static final String STORE_SERVICE_KEY = "STORE_SERVICE_KEY";// 商户收费key
  25.         public static final String SYSTE_MENU_KEY = "SYSTE_MENU_KEY";// 系统管理菜单key
  26.         // jedis服务组业务类型
  27.         public static final String CONT_CLUSTERNAME_PUBLICDATA = "publicData";
  28.         public static final String CONT_CLUSTERNAME_SESSIONROUTE = "sessionRoute";
  29.         public static final String CONT_CLUSTERNAME_USERROUTE = "userRoute";
  30.         // 操作方式 0 插入 1获取 2 删除
  31.         public static final long INSERT_OPERATION = 0;
  32.         public static final long GET_OPERATION = 1;
  33.         public static final long DELETE_OPERATION = 2;
  34.         // 验证码过期秒数
  35.         public static final int CHECKCODE_EXPIRESECONDS = 5*60;
  36.         // session过期秒数
  37.         public static final int EXPIRESECONDS = 30 * 60;
  38.         private static void closeJedis(Jedis jedis) {
  39.             try {
  40.                 jedis.quit();
  41.             } catch (JedisConnectionException e) {
  42.                 e.printStackTrace();
  43.             }
  44.             jedis.disconnect();
  45.         }
  46.         /**
  47.          * 根据Key获取字符串
  48.          *
  49.          * @param key
  50.          * @param jedisGroup
  51.          */
  52.         public static String getString(String key, String selectdb) {
  53.             Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);
  54.             return jedis.get(key);
  55.         }
  56.         /**
  57.          * 获取所有数据set
  58.          * @param selectdb
  59.          * @return
  60.          */
  61.         public static Set getAllSet(String selectdb) {
  62.             Jedis jedis = getDataJedis(GET_OPERATION, selectdb);
  63.             return jedis.keys("*");
  64.         }
  65.         /**
  66.          * 默认取配置文件的第一个数据库
  67.          * @param operation
  68.          * @param selectdb
  69.          * @return
  70.          */
  71.         private static Jedis getDataJedis(long operation, String selectdb) {
  72.             if (RedisConfig.redisGroupMap == null) {
  73.                 RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();
  74.             }
  75.             List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(CONT_CLUSTERNAME_PUBLICDATA);
  76.             int clusterNo = 0;//默认存到第一个
  77.             RedisCluster cluster = clustersList.get(clusterNo);
  78.             Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));
  79.             jedis.select(Integer.valueOf(selectdb));
  80.             return jedis;
  81.         }
  82.         /**
  83.          * 删除数据
  84.          *
  85.          * @param key
  86.          * @param jedisGroup
  87.          */
  88.         public static void deleteObject(String key, String jedisGroup) {
  89.             Jedis jedis = getJedis(key, jedisGroup, DELETE_OPERATION);
  90.             jedis.del(key);
  91.             closeJedis(jedis);
  92.         }
  93.         /**
  94.          * 删除公共数据
  95.          *
  96.          * @param key
  97.          * @param objClass
  98.          * @param selectdb
  99.          */
  100.         public static void deletePublicDataObject(String key, String selectdb) {
  101.             Jedis jedis = getPublicDataJedis(key, DELETE_OPERATION, selectdb);
  102.             jedis.del(key);
  103.             closeJedis(jedis);
  104.         }
  105.         /**
  106.          * 获取jedis的库实例
  107.          *
  108.          * @param key
  109.          * @param jedisGroup
  110.          * @param operation
  111.          * @return
  112.          */
  113.         private static Jedis getJedis(String key, String jedisGroup, long operation) {
  114.             if (RedisConfig.redisGroupMap == null) {
  115.                 RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();
  116.             }
  117.             List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(jedisGroup);
  118.             int arrayLength = clustersList.size();
  119.             // 根据key值算出该信息应该存入到那个
  120.             int clusterNo = getRedisNo(key, arrayLength);
  121.             RedisCluster cluster = clustersList.get(clusterNo);
  122.             Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));
  123.             jedis.select(Integer.valueOf(cluster.getSelectdb()));
  124.             return jedis;
  125.         }
  126.         /**
  127.          * redis key值获取对象
  128.          *
  129.          * @param key
  130.          * @param objClass
  131.          * @param jedisGroup
  132.          * @return
  133.          */
  134.         public static Object getObject(String key, Class objClass, String jedisGroup) {
  135.             Jedis jedis = getJedis(key, jedisGroup, GET_OPERATION);
  136.             String sObj = jedis.get(key);
  137.             closeJedis(jedis);
  138.             Gson gson = new Gson();
  139.             return gson.fromJson(sObj, objClass);
  140.         }
  141.         /**
  142.          * 获取公共数据jedis的库实例
  143.          *
  144.          * @param key
  145.          * @param jedisGroup
  146.          * @param operation
  147.          * @return
  148.          */
  149.         private static Jedis getPublicDataJedis(String key, long operation, String selectdb) {
  150.             if (RedisConfig.redisGroupMap == null) {
  151.                 RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();
  152.             }
  153.             List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(CONT_CLUSTERNAME_PUBLICDATA);
  154.             int arrayLength = clustersList.size();
  155.             // 根据key值算出该信息应该存入到那个
  156.             int clusterNo = getRedisNo(key, arrayLength);
  157.             RedisClustercluster = clustersList.get(clusterNo);
  158.             Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));
  159.             jedis.select(Integer.valueOf(selectdb));
  160.             return jedis;
  161.         }
  162.         /**
  163.          * publicdata redis key值获取对象
  164.          *
  165.          * @param key
  166.          * @param objClass
  167.          * @param jedisGroup
  168.          * @return
  169.          */
  170.         public static Object getPublicDataObject(String key, Class objClass, String selectdb) {
  171.             Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);
  172.             String sObj = jedis.get(key);
  173.             closeJedis(jedis);
  174.             Gson gson = new Gson();
  175.             return gson.fromJson(sObj, objClass);
  176.         }
  177.         /**
  178.          * publicdata redis key值获取对象 List<Entity>
  179.          *
  180.          * @param key
  181.          * @param objClass
  182.          * @param jedisGroup
  183.          * @return
  184.          */
  185.         public static Object getPublicDataObjectByType(String key, Type type, String selectdb) {
  186.             Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);
  187.             String sObj = jedis.get(key);
  188.             closeJedis(jedis);
  189.             Gson gson = new Gson();
  190.             return gson.fromJson(sObj, type);
  191.         }
  192.         /**
  193.          * 获取redis服务器库编号
  194.          *
  195.          * @param hashKey
  196.          * @return
  197.          */
  198.         public static int getRedisNo(String key, int arraySize) {
  199.             long hashKey = hash(key);
  200.             int redisNo = (int) (hashKey % arraySize);
  201.             return redisNo;
  202.         }
  203.         /**
  204.          * 根据key值算出hash值
  205.          *
  206.          * @param k
  207.          * @return
  208.          */
  209.         public static long hash(String k) {
  210.             CRC32 crc32 = new CRC32();
  211.             crc32.update(k.getBytes());
  212.             return crc32.getValue();
  213.         }
  214.         /**
  215.          * redis 根据key值将对象插入到不同的库中
  216.          *
  217.          * @param key
  218.          * @param insertObj
  219.          * @param jedisGroup
  220.          */
  221.         public static void insertObject(String key, Object insertObj, String jedisGroup) {
  222.             Jedis jedis = getJedis(key, jedisGroup, INSERT_OPERATION);
  223.             Gson gson = new Gson();
  224.             jedis.set(key, gson.toJson(insertObj));
  225.             closeJedis(jedis);
  226.         }
  227.         /**
  228.          * redis 根据key值将对象插入到不同的库中
  229.          *
  230.          * @param key
  231.          * @param insertObj
  232.          * @param jedisGroup
  233.          * @param expire
  234.          */
  235.         public static void insertObject(String key, Object insertObj, String jedisGroup, int expireSeconds) {
  236.             Jedis jedis = getJedis(key, jedisGroup, INSERT_OPERATION);
  237.             Gson gson = new Gson();
  238.             jedis.setex(key, expireSeconds, gson.toJson(insertObj));
  239.             closeJedis(jedis);
  240.         }
  241.         /**
  242.          * publicdata redis 根据key值将对象插入到不同的库中
  243.          *
  244.          * @param key
  245.          * @param insertObj
  246.          * @param jedisGroup
  247.          */
  248.         public static void insertPublicDataObject(Stringkey, Object insertObj, String selectdb) {
  249.             Jedis jedis = getPublicDataJedis(key, INSERT_OPERATION, selectdb);
  250.             Gson gson = new Gson();
  251.             jedis.set(key, gson.toJson(insertObj));
  252.             closeJedis(jedis);
  253.         }
  254.         /**
  255.          * publicdata redis 根据key值将对象插入到不同的库中,
  256.          *
  257.          * @param key
  258.          * @param insertObj
  259.          * @param jedisGroup
  260.          * @param expireSeconds
  261.          */
  262.         public static void insertPublicDataObject(String key, Object insertObj, String selectdb, int expireSeconds) {
  263.             Jedis jedis = getPublicDataJedis(key, INSERT_OPERATION, selectdb);
  264.             Gson gson = new Gson();
  265.             jedis.setex(key, expireSeconds, gson.toJson(insertObj));
  266.             closeJedis(jedis);
  267.         }
  268.         /**
  269.          * 更新redis中key的超时时间
  270.          *
  271.          * @param key
  272.          * @param jedisGroup
  273.          * @param expireSeconds
  274.          */
  275.         public static void resetExpireSeconds(String key, String jedisGroup, int expireSeconds) {
  276.             Jedis jedis = getJedis(key, jedisGroup, GET_OPERATION);
  277.             jedis.expire(key, expireSeconds);
  278.             closeJedis(jedis);
  279.         }
  280.     }

5、所需jar包

Redis集群版在Java中的应用的更多相关文章

  1. springboot和Redis集群版的整合

    此篇接上一个文章springboot和Redis单机版的整合 https://www.cnblogs.com/lin530/p/12019023.html 下面接着介绍和Redis集群版的整合. 1. ...

  2. 快速搭建redis单机版和redis集群版

    单机版 第一步:需要安装redis所需的C语言环境,若虚拟机联网,则执行 yum install gcc-c++ 第二步:redis的源码包上传到linux系统 第三步:解压缩redis   tar ...

  3. Linux 安装Redis<集群版>(使用Mac远程访问)

    阅读本文需要先阅读安装Redis<准备> 一 架构细节 所有的redis节点彼此互联(PING-PONG机制) 内部使用二进制协议优化传输速度和带宽 节点的fail是通过集群中超过半数的节 ...

  4. redis集群搭建及java(jedis)链接

    1.创建一个redis-cluster 目录 mkdir -p /usr/local/redis-cluster 创建6台redis服务器(单机下学习) mkdir 7001.mkdir 7002.m ...

  5. Redis 集群版

    1.# yum install ruby -y 1.1 后面需要用到ruby脚本 2.# yum install rubygems -y 1.1 安装ruby包管理器 3.# gem install ...

  6. Java Spring mvc 操作 Redis 及 Redis 集群

    本文原创,转载请注明:http://www.cnblogs.com/fengzheng/p/5941953.html 关于 Redis 集群搭建可以参考我的另一篇文章 Redis集群搭建与简单使用 R ...

  7. redis整合Spring集群搭建及业务中的使用

    1.redis安装 Redis是c语言开发的. 安装redis需要c语言的编译环境.如果没有gcc需要在线安装.yum install gcc-c++ 安装步骤: 第一步:redis的源码包上传到li ...

  8. 使用jedis客户端连接redis,单机版和集群版

    单机版 1.入门实例 @Test public void testJedis(){ //创建一个jedis对象,需要指定服务的ip和端口号 Jedis jedis=new Jedis("19 ...

  9. （转）淘淘商城系列——使用Spring来管理Redis单机版和集群版

    http://blog.csdn.net/yerenyuan_pku/article/details/72863323 我们知道Jedis在处理Redis的单机版和集群版时是完全不同的,有可能在开发的 ...

随机推荐

  1. Android动画知识汇总

    Interpolator(插值器) Interpolatort通常在动画中使用,主要来改变动画变化率.常用的有下面几种Interpolator,下面图文解说下: AccelerateDecelerat ...

  2. Postgres快速创建大量测试数据

    DROP TABLE IF EXISTS color; CREATE TABLE color( cname ), remark ) ); ),) ,); 插入10000000数据之后,用时51秒 对于 ...

  3. xcode从8升级到9出现的问题

    为了使用iOS11,升级了xcode结果,TensorStorage.h里面报错,修改如下: https://stackoverflow.com/questions/46356153/xcode-9- ...

  4. linux进程cpu资源分配命令nice,renice,taskset

    进程cpu资源分配就是指进程的优先权(priority).优先权高的进程有优先执行权利.配置进程优先权对多任务环境的linux很有用,可以改善系统性能.还可以把进程运行到指定的CPU上,这样一来,把不 ...

  5. .net 定时启动任务

    .net winform程序,设置每天的零时启动,执行完后自动关闭. 系统计划启动: 如果要定时启动某个程序,可以通过“任务计划”来安排. 如果是XP系统,在开始 --> 所有程序 --> ...

  6. webpack2--webpack 4.X 快速创建demo

    准备工作 1.新建文件夹:webpack-demo(下面我们简称该文件夹为根目录),在根目录下面建两个文件夹,分别为src和dist. 1).src文件夹:用来存放我们编写的javascript代码, ...

  7. .net操作oracle，一定要用管理员身份运行 visual studio 啊，切记切记，免得报奇怪的错误。

    .net操作oracle,一定要用管理员身份运行 visual studio 啊,切记切记,免得报奇怪的错误.

  8. 内存映射文件（Memory-Mapped File）

    Java Memory-Mapped File所使用的内存分配在物理内存而不是JVM堆内存,且分配在OS内核. 1: 内存映射文件及其应用 - 实现一个简单的消息队列 / 计算机程序的思维逻辑 在一般 ...

  9. Patterns for Asynchronous MVVM Applications: Commands

    Stephen Cleary Download the Code Sample This is the second article in a series on combining async an ...

  10. python with 语句妙用

    class aa(): def bb(self): print("hhhh") return "hello world" def __enter__(self) ...