徐小冠

Redis Jedis、jedisCluster的使用

1、Jedis客户端

https://redis.io/clients
2、Jedis源码包与使用介绍

https://github.com/xetorthio/jedis
3、项目中使用

通过maven引入Jedis的依赖包
复制代码

redis.clients jedis 2.9.0 jar compile

复制代码
4、Jedis的使用

创建Jedis对象，set方法存储key-value值，get方法获取key对应的值。主要是用于单个redis。

Jedis jedis = new Jedis(“192.168.56.180”, 6379);
jedis.set(“Jedis”, “Hello Work!”);
System.out.println(jedis.get(“Jedis”));
jedis.close();

这里是使用IDEA编辑器对Jedis类结构的一个关系图，从图中看出Jedis继承BinaryJedis，实现多个接口。

每一个接口都代表了一类Redis命令，例如JedisCommands中包含了SET GET等命令，MultiKeyCommands中包含了针对多个Key的MSET MGET等命令。
5、JedisCluster的使用

Jediscluster类图和jedis类图大致一样，不过jedisCluster有一些命令是不可用的。比如BinaryJedisCluster类被作废的命令。主要是用在集群中。

类图：

6、单个reids中API的测试
复制代码

package com.redis;

import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.SortingParams;

import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**

单机环境Redis操作：一台Redis服务器
*/
public class Standalone {
private static Jedis jedis;
static {
jedis = new Jedis(“192.168.56.180”, 6379);
jedis.auth(“123456”); // 之前我在redis配置中配置了权限密码，这里需要设置
}

/**
- 测试key - value 的数据
- @throws InterruptedException
  /
  @Test
  public void testKey() throws InterruptedException {
  System.out.println(“清空数据：”+jedis.flushDB());
  System.out.println(“判断某个键是否存在：”+jedis.exists(“username”));
  System.out.println(“新增<‘username’,‘wukong’>的键值对：”+jedis.set(“username”, “wukong”));
  System.out.println(“是否存在:”+jedis.exists(“name”));
  System.out.println(“新增<‘password’,‘password’>的键值对：”+jedis.set(“password”, “password”));
  Set keys = jedis.keys("");
  System.out.println(“系统中所有的键如下：”+keys);
  System.out.println(“删除键password:”+jedis.del(“password”));
  System.out.println(“判断键password是否存在：”+jedis.exists(“password”));
  System.out.println(“设置键username的过期时间为5s:”+jedis.expire(“username”, 5));
  TimeUnit.SECONDS.sleep(2);
  System.out.println(“查看键username的剩余生存时间：”+jedis.ttl(“username”));
  System.out.println(“移除键username的生存时间：”+jedis.persist(“username”));
  System.out.println(“查看键username的剩余生存时间：”+jedis.ttl(“username”));
  System.out.println(“查看键username所存储的值的类型：”+jedis.type(“username”));
  }
/***
- 字符串操作
- memcached和redis同样有append的操作，但是memcached有prepend的操作，redis中并没有。
- @throws InterruptedException
  */
  @Test
  public void testString() throws InterruptedException {
  jedis.flushDB();
  System.out.println("=增加数据=");
  System.out.println(jedis.set(“key1”,“value1”));
  System.out.println(jedis.set(“key2”,“value2”));
  System.out.println(jedis.set(“key3”, “value3”));
  System.out.println(“删除键key2:”+jedis.del(“key2”));
  System.out.println(“获取键key2:”+jedis.get(“key2”));
  System.out.println(“修改key1:”+jedis.set(“key1”, “value1Changed”));
  System.out.println(“获取key1的值：”+jedis.get(“key1”));
  System.out.println(“在key3后面加入值：”+jedis.append(“key3”, “End”));
  System.out.println(“key3的值：”+jedis.get(“key3”));
  System.out.println(“增加多个键值对：”+jedis.mset(“key01”,“value01”,“key02”,“value02”,“key03”,“value03”));
  System.out.println(“获取多个键值对：”+jedis.mget(“key01”,“key02”,“key03”));
  System.out.println(“获取多个键值对：”+jedis.mget(“key01”,“key02”,“key03”,“key04”));
  System.out.println(“删除多个键值对：”+jedis.del(new String[]{“key01”,“key02”}));
  System.out.println(“获取多个键值对：”+jedis.mget(“key01”,“key02”,“key03”));
  
  jedis.flushDB();
  System.out.println("=新增键值对防止覆盖原先值====");
  System.out.println(jedis.setnx(“key1”, “value1”));
  System.out.println(jedis.setnx(“key2”, “value2”));
  System.out.println(jedis.setnx(“key2”, “value2-new”));
  System.out.println(jedis.get(“key1”));
  System.out.println(jedis.get(“key2”));
  
  System.out.println("=新增键值对并设置有效时间===");
  System.out.println(jedis.setex(“key3”, 2, “value3”));
  System.out.println(jedis.get(“key3”));
  TimeUnit.SECONDS.sleep(3);
  System.out.println(jedis.get(“key3”));
  
  System.out.println("=获取原值，更新为新值");//GETSET is an atomic set this value and return the old value command.
  System.out.println(jedis.getSet(“key2”, “key2GetSet”));
  System.out.println(jedis.get(“key2”));
  
  System.out.println(“获得key2的值的字串：”+jedis.getrange(“key2”, 2, 4));
  }
/***
- 整数和浮点数
  */
  @Test
  public void testNumber() {
  jedis.flushDB();
  jedis.set(“key1”, “1”);
  jedis.set(“key2”, “2”);
  jedis.set(“key3”, “2.3”);
  System.out.println(“key1的值：”+jedis.get(“key1”));
  System.out.println(“key2的值：”+jedis.get(“key2”));
  System.out.println(“key1的值加1：”+jedis.incr(“key1”));
  System.out.println(“获取key1的值：”+jedis.get(“key1”));
  System.out.println(“key2的值减1：”+jedis.decr(“key2”));
  System.out.println(“获取key2的值：”+jedis.get(“key2”));
  System.out.println(“将key1的值加上整数5：”+jedis.incrBy(“key1”, 5));
  System.out.println(“获取key1的值：”+jedis.get(“key1”));
  System.out.println(“将key2的值减去整数5：”+jedis.decrBy(“key2”, 5));
  System.out.println(“获取key2的值：”+jedis.get(“key2”));
  }
/***
- 列表
  */
  @Test
  public void testList() {
  jedis.flushDB();
  System.out.println("=添加一个list=");
  jedis.lpush(“collections”, “ArrayList”, “Vector”, “Stack”, “HashMap”, “WeakHashMap”, “LinkedHashMap”);
  jedis.lpush(“collections”, “HashSet”);
  jedis.lpush(“collections”, “TreeSet”);
  jedis.lpush(“collections”, “TreeMap”);
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));//-1代表倒数第一个元素，-2代表倒数第二个元素
  System.out.println(“collections区间0-3的元素：”+jedis.lrange(“collections”,0,3));
  System.out.println("=");
  // 删除列表指定的值，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈
  System.out.println(“删除指定元素个数：”+jedis.lrem(“collections”, 2, “HashMap”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“删除下表0-3区间之外的元素：”+jedis.ltrim(“collections”, 0, 3));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“collections列表出栈（左端）：”+jedis.lpop(“collections”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“collections添加元素，从列表右端，与lpush相对应：”+jedis.rpush(“collections”, “EnumMap”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“collections列表出栈（右端）：”+jedis.rpop(“collections”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“修改collections指定下标1的内容：”+jedis.lset(“collections”, 1, “LinkedArrayList”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println("=");
  System.out.println(“collections的长度：”+jedis.llen(“collections”));
  System.out.println(“获取collections下标为2的元素：”+jedis.lindex(“collections”, 2));
  System.out.println("===============================");
  jedis.lpush(“sortedList”, “3”,“6”,“2”,“0”,“7”,“4”);
  System.out.println(“sortedList排序前：”+jedis.lrange(“sortedList”, 0, -1));
  System.out.println(jedis.sort(“sortedList”));
  System.out.println(“sortedList排序后：”+jedis.lrange(“sortedList”, 0, -1));
  }
/***
- set集合
  */
  @Test
  public void testSet() {
  jedis.flushDB();
  System.out.println(“向集合中添加元素”);
  System.out.println(jedis.sadd(“eleSet”, “e1”,“e2”,“e4”,“e3”,“e0”,“e8”,“e7”,“e5”));
  System.out.println(jedis.sadd(“eleSet”, “e6”));
  System.out.println(jedis.sadd(“eleSet”, “e6”));
  System.out.println(“eleSet的所有元素为：”+jedis.smembers(“eleSet”));
  System.out.println(“删除一个元素e0：”+jedis.srem(“eleSet”, “e0”));
  System.out.println(“eleSet的所有元素为：”+jedis.smembers(“eleSet”));
  System.out.println(“删除两个元素e7和e6：”+jedis.srem(“eleSet”, “e7”,“e6”));
  System.out.println(“eleSet的所有元素为：”+jedis.smembers(“eleSet”));
  System.out.println(“随机的移除集合中的一个元素：”+jedis.spop(“eleSet”));
  System.out.println(“随机的移除集合中的一个元素：”+jedis.spop(“eleSet”));
  System.out.println(“eleSet的所有元素为：”+jedis.smembers(“eleSet”));
  System.out.println(“eleSet中包含元素的个数：”+jedis.scard(“eleSet”));
  System.out.println(“e3是否在eleSet中：”+jedis.sismember(“eleSet”, “e3”));
  System.out.println(“e1是否在eleSet中：”+jedis.sismember(“eleSet”, “e1”));
  System.out.println(“e1是否在eleSet中：”+jedis.sismember(“eleSet”, “e5”));
  System.out.println("=============================");
  System.out.println(jedis.sadd(“eleSet1”, “e1”,“e2”,“e4”,“e3”,“e0”,“e8”,“e7”,“e5”));
  System.out.println(jedis.sadd(“eleSet2”, “e1”,“e2”,“e4”,“e3”,“e0”,“e8”));
  System.out.println(“将eleSet1中删除e1并存入eleSet3中：”+jedis.smove(“eleSet1”, “eleSet3”, “e1”));
  System.out.println(“将eleSet1中删除e2并存入eleSet3中：”+jedis.smove(“eleSet1”, “eleSet3”, “e2”));
  System.out.println(“eleSet1中的元素：”+jedis.smembers(“eleSet1”));
  System.out.println(“eleSet3中的元素：”+jedis.smembers(“eleSet3”));
  System.out.println("集合运算=");
  System.out.println(“eleSet1中的元素：”+jedis.smembers(“eleSet1”));
  System.out.println(“eleSet2中的元素：”+jedis.smembers(“eleSet2”));
  System.out.println(“eleSet1和eleSet2的交集:”+jedis.sinter(“eleSet1”,“eleSet2”));
  System.out.println(“eleSet1和eleSet2的并集:”+jedis.sunion(“eleSet1”,“eleSet2”));
  System.out.println(“eleSet1和eleSet2的差集:”+jedis.sdiff(“eleSet1”,“eleSet2”));//eleSet1中有，eleSet2中没有
  }
/***
- 散列
  */
  @Test
  public void testHash() {
  jedis.flushDB();
  Map map = new HashMap();
  map.put(“key1”,“value1”);
  map.put(“key2”,“value2”);
  map.put(“key3”,“value3”);
  map.put(“key4”,“value4”);
  jedis.hmset(“hash”,map);
  jedis.hset(“hash”, “key5”, “value5”);
  System.out.println(“散列hash的所有键值对为：”+jedis.hgetAll(“hash”));//return Map
  System.out.println(“散列hash的所有键为：”+jedis.hkeys(“hash”));//return Set
  System.out.println(“散列hash的所有值为：”+jedis.hvals(“hash”));//return List
  System.out.println(“将key6保存的值加上一个整数，如果key6不存在则添加key6：”+jedis.hincrBy(“hash”, “key6”, 6));
  System.out.println(“散列hash的所有键值对为：”+jedis.hgetAll(“hash”));
  System.out.println(“将key6保存的值加上一个整数，如果key6不存在则添加key6：”+jedis.hincrBy(“hash”, “key6”, 3));
  System.out.println(“散列hash的所有键值对为：”+jedis.hgetAll(“hash”));
  System.out.println(“删除一个或者多个键值对：”+jedis.hdel(“hash”, “key2”));
  System.out.println(“散列hash的所有键值对为：”+jedis.hgetAll(“hash”));
  System.out.println(“散列hash中键值对的个数：”+jedis.hlen(“hash”));
  System.out.println(“判断hash中是否存在key2：”+jedis.hexists(“hash”,“key2”));
  System.out.println(“判断hash中是否存在key3：”+jedis.hexists(“hash”,“key3”));
  System.out.println(“获取hash中的值：”+jedis.hmget(“hash”,“key3”));
  System.out.println(“获取hash中的值：”+jedis.hmget(“hash”,“key3”,“key4”));
  }
/**
- 有序集合
  */
  @Test
  public void testSortedSet() {
  jedis.flushDB();
  Map map = new HashMap();
  map.put(“key2”,1.2);
  map.put(“key3”,4.0);
  map.put(“key4”,5.0);
  map.put(“key5”,0.2);
  System.out.println(jedis.zadd(“zset”, 3,“key1”));
  System.out.println(jedis.zadd(“zset”,map));
  System.out.println(“zset中的所有元素：”+jedis.zrange(“zset”, 0, -1));
  System.out.println(“zset中的所有元素：”+jedis.zrangeWithScores(“zset”, 0, -1));
  System.out.println(“zset中的所有元素：”+jedis.zrangeByScore(“zset”, 0,100));
  System.out.println(“zset中的所有元素：”+jedis.zrangeByScoreWithScores(“zset”, 0,100));
  System.out.println(“zset中key2的分值：”+jedis.zscore(“zset”, “key2”));
  System.out.println(“zset中key2的排名：”+jedis.zrank(“zset”, “key2”));
  System.out.println(“删除zset中的元素key3：”+jedis.zrem(“zset”, “key3”));
  System.out.println(“zset中的所有元素：”+jedis.zrange(“zset”, 0, -1));
  System.out.println(“zset中元素的个数：”+jedis.zcard(“zset”));
  System.out.println(“zset中分值在1-4之间的元素的个数：”+jedis.zcount(“zset”, 1, 4));
  System.out.println(“key2的分值加上5：”+jedis.zincrby(“zset”, 5, “key2”));
  System.out.println(“key3的分值加上4：”+jedis.zincrby(“zset”, 4, “key3”));
  System.out.println(“zset中的所有元素：”+jedis.zrange(“zset”, 0, -1));
  }
/**
- 排序
  /
  @Test
  public void testSort()
  {
  jedis.flushDB();
  jedis.lpush(“collections”, “ArrayList”, “Vector”, “Stack”, “HashMap”, “WeakHashMap”, “LinkedHashMap”);
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  SortingParams sortingParameters = new SortingParams();
  System.out.println(jedis.sort(“collections”,sortingParameters.alpha()));
  System.out.println("=");
  jedis.lpush(“sortedList”, “3”,“6”,“2”,“0”,“7”,“4”);
  System.out.println(“sortedList排序前：”+jedis.lrange(“sortedList”, 0, -1));
  System.out.println(“升序：”+jedis.sort(“sortedList”, sortingParameters.asc()));
  System.out.println(“升序：”+jedis.sort(“sortedList”, sortingParameters.desc()));
  System.out.println("=");
  jedis.lpush(“userlist”, “33”);
  jedis.lpush(“userlist”, “22”);
  jedis.lpush(“userlist”, “55”);
  jedis.lpush(“userlist”, “11”);
  jedis.hset(“user:66”, “name”, “66”);
  jedis.hset(“user:55”, “name”, “55”);
  jedis.hset(“user:33”, “name”, “33”);
  jedis.hset(“user:22”, “name”, “79”);
  jedis.hset(“user:11”, “name”, “24”);
  jedis.hset(“user:11”, “add”, “beijing”);
  jedis.hset(“user:22”, “add”, “shanghai”);
  jedis.hset(“user:33”, “add”, “guangzhou”);
  jedis.hset(“user:55”, “add”, “chongqing”);
  jedis.hset(“user:66”, “add”, “xi’an”);
  sortingParameters = new SortingParams();
  sortingParameters.get("user:->name");
  sortingParameters.get(“user:*->add”);
  System.out.println(jedis.sort(“userlist”,sortingParameters));
  }
  }

复制代码
7、集群reids中API的测试
复制代码

package com.redis;

import org.junit.Test;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.SortingParams;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**

集群环境下Jedis操作
*/
public class Cluster {
private static JedisCluster jedis;
static {
// 添加集群的服务节点Set集合
Set hostAndPortsSet = new HashSet();
// 添加节点
hostAndPortsSet.add(new HostAndPort(“192.168.56.180”, 7777));
hostAndPortsSet.add(new HostAndPort(“192.168.56.180”, 8888));
hostAndPortsSet.add(new HostAndPort(“192.168.56.181”, 7777));
hostAndPortsSet.add(new HostAndPort(“192.168.56.181”, 8888));
hostAndPortsSet.add(new HostAndPort(“192.168.56.182”, 7777));
hostAndPortsSet.add(new HostAndPort(“192.168.56.182”, 8888));
```
 // Jedis连接池配置
 JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
 // 最大空闲连接数, 默认8个
 jedisPoolConfig.setMaxIdle(100);
 // 最大连接数, 默认8个
 jedisPoolConfig.setMaxTotal(500);
 //最小空闲连接数, 默认0
 jedisPoolConfig.setMinIdle(0);
 // 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
 jedisPoolConfig.setMaxWaitMillis(2000); // 设置2秒
 //对拿到的connection进行validateObject校验
 jedisPoolConfig.setTestOnBorrow(true);
 jedis = new JedisCluster(hostAndPortsSet, jedisPoolConfig);
```
}

/**
- 测试key:value数据
- 集群中flushDB、keys废弃
  /
  @Test
  public void testKey() throws InterruptedException {
  //System.out.println(“清空数据：”+jedis.flushDB());
  System.out.println(“判断某个键是否存在：”+jedis.exists(“username”));
  System.out.println(“新增<‘username’,‘wukong’>的键值对：”+jedis.set(“username”, “xiaohai”));
  System.out.println(“是否存在:”+jedis.exists(“username”));
  System.out.println(“新增<‘password’,‘password’>的键值对：”+jedis.set(“password”, “123456”));
  //Set keys = jedis.keys("");
  // System.out.println(“系统中所有的键如下：”+keys);
  System.out.println(“删除键password:”+jedis.del(“password”));
  System.out.println(“判断键password是否存在：”+jedis.exists(“password”));
  System.out.println(“设置键username的过期时间为10s:”+jedis.expire(“username”, 10));
  TimeUnit.SECONDS.sleep(2); // 线程睡眠2秒System.out.println(“查看键username的剩余生存时间：”+jedis.ttl(“username”));
  System.out.println(“查看键username的剩余生存时间：”+jedis.ttl(“username”));
  System.out.println(“移除键username的生存时间：”+jedis.persist(“username”));
  System.out.println(“查看键username的剩余生存时间：”+jedis.ttl(“username”));
  System.out.println(“查看键username所存储的值的类型：”+jedis.type(“username”));
  }
/***
- 字符串操作
- memcached和redis同样有append的操作，但是memcached有prepend的操作，redis中并没有。
- 集群中flushDB、keys、del(多个值)、mset(多个值)废弃
- @throws InterruptedException
  */
  @Test
  public void testString() throws InterruptedException {
  //jedis.flushDB();
  System.out.println("=增加数据=");
  System.out.println(jedis.set(“key1”,“value1”));
  System.out.println(jedis.set(“key2”,“value2”));
  System.out.println(jedis.set(“key3”, “value3”));
  System.out.println(“删除键key2:”+jedis.del(“key2”));
  System.out.println(“获取键key2:”+jedis.get(“key2”));
  System.out.println(“修改key1:”+jedis.set(“key1”, “value1Changed”));
  System.out.println(“获取key1的值：”+jedis.get(“key1”));
  System.out.println(“在key3后面加入值：”+jedis.append(“key3”, “End”));
  System.out.println(“key3的值：”+jedis.get(“key3”));
  //命令的时候才会去连接连接，集群中连接是对一个节点连接，不能判断多个key经过crc16算法所对应的槽在一个节点上，不支持多key获取、删除
  //System.out.println(“增加多个键值对：”+jedis.mset(“key01”,“value01”,“key02”,“value02”));
  //System.out.println(“获取多个键值对：”+jedis.mget(“key01”,“key02”,“key03”));
  //System.out.println(“获取多个键值对：”+jedis.mget(“key01”,“key02”,“key03”,“key04”));
  //System.out.println(“删除多个键值对：”+jedis.del(new String[]{“key01”,“key02”}));
  //System.out.println(“获取多个键值对：”+jedis.mget(“key01”,“key02”,“key03”));
  
  //jedis.flushDB();
  System.out.println("=新增键值对防止覆盖原先值====");
  System.out.println(jedis.setnx(“key1”, “value1”));
  System.out.println(jedis.setnx(“key2”, “value2”));
  System.out.println(jedis.setnx(“key2”, “value2-new”));
  System.out.println(jedis.get(“key1”));
  System.out.println(jedis.get(“key2”));
  
  System.out.println("=新增键值对并设置有效时间===");
  System.out.println(jedis.setex(“key3”, 2, “value3”));
  System.out.println(jedis.get(“key3”));
  TimeUnit.SECONDS.sleep(3);
  System.out.println(jedis.get(“key3”));
  
  System.out.println("=获取原值，更新为新值");//GETSET is an atomic set this value and return the old value command.
  System.out.println(jedis.getSet(“key2”, “key2GetSet”));
  System.out.println(jedis.get(“key2”));
  System.out.println(“获得key2的值的字串：”+jedis.getrange(“key2”, 2, 4)); // 相当截取字符串的第二个位置-第四个位置的字符串
  }
/***
- 整数和浮点数
  */
  @Test
  public void testNumber() {
  jedis.set(“key1”, “1”);
  jedis.set(“key2”, “2”);
  jedis.set(“key3”, “2.3”);
  System.out.println(“key1的值：”+jedis.get(“key1”));
  System.out.println(“key2的值：”+jedis.get(“key2”));
  System.out.println(“key1的值加1：”+jedis.incr(“key1”));
  System.out.println(“获取key1的值：”+jedis.get(“key1”));
  System.out.println(“key2的值减1：”+jedis.decr(“key2”));
  System.out.println(“获取key2的值：”+jedis.get(“key2”));
  System.out.println(“将key1的值加上整数5：”+jedis.incrBy(“key1”, 5));
  System.out.println(“获取key1的值：”+jedis.get(“key1”));
  System.out.println(“将key2的值减去整数5：”+jedis.decrBy(“key2”, 5));
  System.out.println(“获取key2的值：”+jedis.get(“key2”));
  System.out.println(“key3的值：”+jedis.get(“key3”));
  // 这里会报错，因为key3不是整数不能做计算:redis.clients.jedis.exceptions.JedisDataException: ERR value is not an integer or out of range
  // System.out.println(“key2的值减1：”+jedis.decr(“key3”));
  }
/***
- 列表
  */
  @Test
  public void testList() {
  System.out.println("=添加一个list=");
  jedis.lpush(“collections”, “ArrayList”, “Vector”, “Stack”, “HashMap”, “WeakHashMap”, “LinkedHashMap”);
  jedis.lpush(“collections”, “HashSet”); // 叠加
  jedis.lpush(“collections”, “TreeSet”); // 叠加
  jedis.lpush(“collections”, “TreeMap”); // 叠加
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));//-1代表倒数第一个元素，-2代表倒数第二个元素
  System.out.println(“collections区间0-3的元素：”+jedis.lrange(“collections”,0,3)); // 前面4个值
  System.out.println("=");
  // 删除列表指定的值，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈
  System.out.println(“删除指定元素个数：”+jedis.lrem(“collections”, 2, “HashMap”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“删除下表0-3区间之外的元素：”+jedis.ltrim(“collections”, 0, 3));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“collections列表出栈（左端）：”+jedis.lpop(“collections”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“collections添加元素，从列表右端，与lpush相对应：”+jedis.rpush(“collections”, “EnumMap”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“collections列表出栈（右端）：”+jedis.rpop(“collections”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println(“修改collections指定下标1的内容：”+jedis.lset(“collections”, 1, “LinkedArrayList”));
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  System.out.println("=");
  System.out.println(“collections的长度：”+jedis.llen(“collections”));
  System.out.println(“获取collections下标为2的元素：”+jedis.lindex(“collections”, 2));
  System.out.println("===============================");
  jedis.lpush(“sortedList”, “3”,“6”,“2”,“0”,“7”,“4”);
  System.out.println(“sortedList排序前：”+jedis.lrange(“sortedList”, 0, -1));
  System.out.println(jedis.sort(“sortedList”));
  System.out.println(“sortedList排序后：”+jedis.lrange(“sortedList”, 0, -1));
  }
/***
- set集合
  */
  @Test
  public void testSet() {
  System.out.println(“向集合中添加元素”);
  System.out.println(jedis.sadd(“eleSet”, “e1”,“e2”,“e4”,“e3”,“e0”,“e8”,“e7”,“e5”));
  System.out.println(jedis.sadd(“eleSet”, “e6”));
  System.out.println(jedis.sadd(“eleSet”, “e6”)); // 返回0，集合中已经存在
  System.out.println(“eleSet的所有元素为：”+jedis.smembers(“eleSet”));
  System.out.println(“删除一个元素e0：”+jedis.srem(“eleSet”, “e0”));
  System.out.println(“eleSet的所有元素为：”+jedis.smembers(“eleSet”));
  System.out.println(“删除两个元素e7和e6：”+jedis.srem(“eleSet”, “e7”,“e6”));
  System.out.println(“eleSet的所有元素为：”+jedis.smembers(“eleSet”));
  System.out.println(“随机的移除集合中的一个元素：”+jedis.spop(“eleSet”));
  System.out.println(“随机的移除集合中的一个元素：”+jedis.spop(“eleSet”));
  System.out.println(“eleSet的所有元素为：”+jedis.smembers(“eleSet”));
  System.out.println(“eleSet中包含元素的个数：”+jedis.scard(“eleSet”));
  System.out.println(“e3是否在eleSet中：”+jedis.sismember(“eleSet”, “e3”));
  System.out.println(“e1是否在eleSet中：”+jedis.sismember(“eleSet”, “e1”));
  System.out.println(“e5是否在eleSet中：”+jedis.sismember(“eleSet”, “e5”));
  
  // 集群下并存会报错：redis.clients.jedis.exceptions.JedisClusterException: No way to dispatch this command to Redis Cluster because keys have different slots.
  // Redis集群，从key1集合与key2集合并存、交集、差集，两个键经过crc16算法可能有不同的槽。
  /*System.out.println("=================================");
  System.out.println(jedis.sadd(“eleSet1”, “e1”,“e2”,“e4”,“e3”,“e0”,“e8”,“e7”,“e5”));
  System.out.println(jedis.sadd(“eleSet2”, “e1”,“e2”,“e4”,“e3”,“e0”,“e8”));
  System.out.println(“将eleSet1中删除e1并存入eleSet3中：”+jedis.smove(“eleSet1”, “eleSet3”, “e1”));
  System.out.println(“将eleSet1中删除e2并存入eleSet3中：”+jedis.smove(“eleSet1”, “eleSet3”, “e2”));
  System.out.println(“eleSet1中的元素：”+jedis.smembers(“eleSet1”));
  System.out.println(“eleSet3中的元素：”+jedis.smembers(“eleSet3”));*/
  
  /*System.out.println(“集合运算=====”);
  System.out.println(“eleSet1中的元素：”+jedis.smembers(“eleSet1”));
  System.out.println(“eleSet2中的元素：”+jedis.smembers(“eleSet2”));
  System.out.println(“eleSet1和eleSet2的交集:”+jedis.sinter(“eleSet1”,“eleSet2”));
  System.out.println(“eleSet1和eleSet2的并集:”+jedis.sunion(“eleSet1”,“eleSet2”));
  System.out.println(“eleSet1和eleSet2的差集:”+jedis.sdiff(“eleSet1”,“eleSet2”));*/
  jedis.del(“eleSet”);
  jedis.del(“eleSet1”);
  jedis.del(“eleSet2”);
  jedis.del(“eleSet3”);
  }
/***
- 散列
  */
  @Test
  public void testHash() {
  Map map = new HashMap();
  map.put(“key1”,“value1”);
  map.put(“key2”,“value2”);
  map.put(“key3”,“value3”);
  map.put(“key4”,“value4”);
  jedis.hmset(“hash”,map);
  jedis.hset(“hash”, “key5”, “value5”);
  System.out.println(“散列hash的所有键值对为：”+jedis.hgetAll(“hash”));//return Map
  System.out.println(“散列hash的所有键为：”+jedis.hkeys(“hash”));//return Set
  System.out.println(“散列hash的所有值为：”+jedis.hvals(“hash”));//return List
  System.out.println(“将key6保存的值加上一个整数，如果key6不存在则添加key6：”+jedis.hincrBy(“hash”, “key6”, 6));
  System.out.println(“散列hash的所有键值对为：”+jedis.hgetAll(“hash”));
  System.out.println(“将key6保存的值加上一个整数，如果key6不存在则添加key6：”+jedis.hincrBy(“hash”, “key6”, 3));
  System.out.println(“散列hash的所有键值对为：”+jedis.hgetAll(“hash”));
  System.out.println(“删除一个或者多个键值对：”+jedis.hdel(“hash”, “key2”));
  System.out.println(“散列hash的所有键值对为：”+jedis.hgetAll(“hash”));
  System.out.println(“散列hash中键值对的个数：”+jedis.hlen(“hash”));
  System.out.println(“判断hash中是否存在key2：”+jedis.hexists(“hash”,“key2”));
  System.out.println(“判断hash中是否存在key3：”+jedis.hexists(“hash”,“key3”));
  System.out.println(“获取hash中的值：”+jedis.hmget(“hash”,“key3”));
  System.out.println(“获取hash中的值：”+jedis.hmget(“hash”,“key3”,“key4”));
  }
/**
- 有序集合
  */
  @Test
  public void testSortedSet() {
  Map map = new HashMap();
  map.put(“key2”,1.2);
  map.put(“key3”,4.0);
  map.put(“key4”,5.0);
  map.put(“key5”,0.2);
  // 将一个或多个 member 元素及其 score 值加入到有序集 key 当中，如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值
  // score 值可以是整数值或双精度浮点数
  System.out.println(jedis.zadd(“zset”, 3,“key1”));
  System.out.println(jedis.zadd(“zset”,map));
  System.out.println(“zset中的所有元素：”+jedis.zrange(“zset”, 0, -1));
  System.out.println(“zset中的所有元素：”+jedis.zrangeWithScores(“zset”, 0, -1));
  System.out.println(“zset中的所有元素：”+jedis.zrangeByScore(“zset”, 0,100));
  System.out.println(“zset中的所有元素：”+jedis.zrangeByScoreWithScores(“zset”, 0,100));
  System.out.println(“zset中key2的分值：”+jedis.zscore(“zset”, “key2”));
  System.out.println(“zset中key2的排名：”+jedis.zrank(“zset”, “key2”));
  System.out.println(“删除zset中的元素key3：”+jedis.zrem(“zset”, “key3”));
  System.out.println(“zset中的所有元素：”+jedis.zrange(“zset”, 0, -1));
  System.out.println(“zset中元素的个数：”+jedis.zcard(“zset”));
  System.out.println(“zset中分值在1-4之间的元素的个数：”+jedis.zcount(“zset”, 1, 4));
  System.out.println(“key2的分值加上5：”+jedis.zincrby(“zset”, 5, “key2”));
  System.out.println(“key3的分值加上4：”+jedis.zincrby(“zset”, 4, “key3”));
  System.out.println(“zset中的所有元素：”+jedis.zrange(“zset”, 0, -1));
  }
/**
- 排序
  /
  @Test
  public void testSort() {
  jedis.lpush(“collections”, “ArrayList”, “Vector”, “Stack”, “HashMap”, “WeakHashMap”, “LinkedHashMap”);
  System.out.println(“collections的内容：”+jedis.lrange(“collections”, 0, -1));
  SortingParams sortingParameters = new SortingParams();
  // 当数据集中保存的是字符串值时，你可以用 ALPHA,默认是升序
  System.out.println(“alpha排序方式：” + jedis.sort(“collections”,sortingParameters.alpha()));
  System.out.println("=");
  jedis.lpush(“sortedList”, “3”,“6”,“2”,“0”,“7”,“4”);
  System.out.println(“sortedList排序前：”+jedis.lrange(“sortedList”, 0, -1));
  System.out.println(“升序：”+jedis.sort(“sortedList”, sortingParameters.asc()));
  System.out.println(“降序：”+jedis.sort(“sortedList”, sortingParameters.desc()));
  System.out.println("=");
  // 集群下不支持分割表排序
  /jedis.lpush(“userlist”, “33”);
  jedis.lpush(“userlist”, “22”);
  jedis.lpush(“userlist”, “55”);
  jedis.lpush(“userlist”, “11”);
  jedis.hset(“user:66”, “name”, “66”);
  jedis.hset(“user:55”, “name”, “55”);
  jedis.hset(“user:33”, “name”, “33”);
  jedis.hset(“user:22”, “name”, “79”);
  jedis.hset(“user:11”, “name”, “24”);
  jedis.hset(“user:11”, “add”, “beijing”);
  jedis.hset(“user:22”, “add”, “shanghai”);
  jedis.hset(“user:33”, “add”, “guangzhou”);
  jedis.hset(“user:55”, “add”, “chongqing”);
  jedis.hset(“user:66”, “add”, “xi’an”);
  sortingParameters = new SortingParams();
  // 符号 “->” 用于分割哈希表的键名(key name)和索引域(hash field)，格式为 “key->field”
  sortingParameters.get("user:->name");
  sortingParameters.get("user:->add");
  System.out.println(jedis.sort(“userlist”,sortingParameters));*/
  }
  }

你可能感兴趣的:(redis)

Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
华为云分布式缓存服务DCS 8月新特性发布华为云PaaS服务小智华为云分布式缓存
分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
Redis Key的过期策略 ArchManual 分布式架构分布式 Java 后端微服务架构 redis
Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
Redis:缓存击穿我的程序快快跑啊缓存 redis java
缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
Redis 有哪些危险命令？如何防范？花小疯 redis 缓存数据库危险命令大数据
Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理朱杰jjj 缓存分布式
分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商 weixin_34302561 数据库 devops 大数据
1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
华为云分布式缓存服务DCS与开源服务差异对比 hcinfo_18 redis使用华为云 Redis5.0 分布式缓存服务 Redis客户端
分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
关于Redis集群同步/持久化/淘汰机制的详解尾巴尖上的阳光大数据 redis 数据库
Redis是非常常用的KV数据库,使用内存以及HashMap进行存储的特点带来了高效的查询.本文将围绕Redis的常见开发使用场景,阐述在Redis集群中各个节点是如何进行数据同步,每个节点如何进行持久化以及在长期使用中如何对数据进行更新和淘汰.如果对Redis有更多的兴趣,可以查看我的技术博客:https://dingyuqi.com下面是Redis在开发过程中常用的几种使用场景.集群Redis
主流行架构 rainbowcheng 架构架构
nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
网上商城项目总结续猫只i java web 电子商城结构
前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
常用类库 Guava 简介豆瑞瑞 java
简介GoogleGuava是一个由Google开发的Java开源函数库。前身是GoogleCollectionsLibrary，提供了许多简化工具，如缓存、连接器、过滤器、关联数组等仓库代码GitCode-全球开发者的开源社区,开源代码托管平台参考https://github.com/google/guavahttps://github.com/google/guava/wikiRedisStre
2024Mysql And Redis基础与进阶操作系列（8）作者——LJS[含MySQL 创建、修改、跟新、重命名、删除视图等具体详步骤；注意点及常见报错问题所对应的解决方法] 肾透侧视攻城狮 MYSQL REDIS Advance operation redis mysql 数据库 linux sql bash adb
目录1MySQL视图1.概念2.作用3.特点4.具体如何操作实现MYSQL视图4.1创建视图语法示例查看表和视图查看视图的结构查看视图属性信息（比如：显示数据表的存储引擎、版本、数据行数和数据大小等）查看视图的详细定义信息4.2修改视图简介格式举例4.3更新视图简介下述结构中不可更新的视图补充说明举例更新视图视图包含聚合函数不可更新视图包含distinct不可更新视图包含goupby、having
自定义布隆过滤器解决缓存穿透暗金烂狗缓存
什么是缓存穿透以及常见解决方案缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库，导致数据库压力提高，造成宕机。缓存穿透就是指用户访问那些在数据库和Redis中都不存在的数据，例如我们知道id采用自增策略，那么就不可能出现负数id，而如果不法分子使用负数id进行查询，那么这些请求都会穿过Redis直接向数据库发送请求，从而导致数据库压力骤增，导致数
Redis 为什么这么快？小海海不怕困难 Redis redis
决定Redis请求效率的因素主要是三个方面，分别是网络、cpu、内存。在网络层面，Redis采用多路复用的设计，提升了并发处理的连接数，不过这个阶段，Server端的所有IO操作，都是由同一个主线程处理的这个时候IO的瓶颈就会影响到Redis端的整体处理性能。所以从Redis6.0开始，在多路复用及层面增加了多线程的处理，来优化IO处理的能力不过，具体的数据操作仍然是由主线程来处理的，所以我们可以
Redis 集群確定饿的猫 redis linux
目录Redis主从复制Redis主从复制简介Redis主从复制的作用Redis主从复制流程搭建Redis主从复制master节点slave节点验证哨兵故障转移机制部署哨兵Redis集群作用数据分区高可用Redis集群Redis高可用实现的方式有持久化、主从复制、哨兵、集群，与持久化不同，另外三种方式都是属于集群，之前已经分析了解过两种持久化模式了，现在了解另外几种方式Redis主从复制Redis主
Redisson分布式锁实现原理和使用牧竹子 springboot #redis Redisson redis
常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
分布式框架Celery七(Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警) yjjpp2301 Celery 分布式 django python 后端
Django中集成方式安装模块pipinstallDjango==3.2.22pipinstallcelerypipinstallredispipinstalleventlet#在windows环境下需要安装eventlet包-----------pipinstalldjango-celery-beatpipinstalldjango-celery-resultspipinstalldjango-
Redis的持久化和高可用性小辛学西嘎嘎 redis 数据库缓存
目录一、淘汰策略1、背景2、淘汰策略二、持久化1、背景2、fork进程写时复制机制3、Redis持久化方式1、aof2、rdb三、高可用1、主从复制2、Redis哨兵模式3、Rediscluster集群一、淘汰策略1、背景首先Redis是一个内存数据库，将所有数据存放在内存中，通过对K值进行hash后存储在散列表中。有一个小问题Redis数据库占96G，但为什么最终占满只有48G呢。因为中间有个过
【Redis】Redis缓存 1886i Java Redis 缓存 redis 数据库
目录一、缓存1、概念2、作用3、缺点二、缓存模型三、缓存的更新1、更新策略2、主动更新的三种模式1.cacheasidepattern2.read/writethroughpattern3.writebehindcachingpattern3、线程安全问题1.缓存删除还是更新缓存2.先删除缓存后操作数据库3.先操作数据库后删除缓存4.如何保证缓存与数据库操作同时成功或失败4、最佳选择一、缓存1、概
Windows系统下安装Redis bjzhang75 windows redis 数据库
文章目录1、下载Redis安装包2、解压压缩包3、运行Redis4、Redis连接检测5、Redis相关设置5.1设置环境变量PATH5.2Redis配置文件修改1、下载Redis安装包Windows版本的Redis可以在Github中下载：下载Redis2、解压压缩包将下载的压缩包解压到某个目录下，比如：C:\redis。3、运行Redis在cmd窗口中运行命令redis-serverredis
实现多级缓存的六种策略方法 Kixuan214 缓存 redis rabbitmq
保证多级缓存数据一致性是一个复杂的任务，尤其是在分布式和高并发环境中。以下是一些常见的方法和策略，可以帮助实现多级缓存的数据一致性1.缓存失效策略1.1主动失效在更新数据库时，主动使相关缓存失效。步骤：更新数据库删除或失效缓存publicclassCacheService{privateLocalCachelocalCache;privateRedisCacheredisCache;private
redis-shake v4全量增量同步redis数据 nangonghen redis redis 数据库缓存 redis-shake
1概述RedisShake是一个用于处理和迁移Redis数据的工具，github地址是https://github.com/tair-opensource/RedisShake。它提供以下特性：1）Redis兼容性：RedisShake兼容从2.8到7.2的Redis版本，并支持各种部署方式，包括单机，主从，哨兵和集群。2）云服务兼容性：RedisShake与主流云服务提供商提供的流行Redis-
redis,codis,云redis shuff1e
redis的分布式解决方式--codis（转）https://www.cnblogs.com/softidea/p/5365640.htmlhttps://help.aliyun.com/document_detail/57797.html?spm=5176.173352.925244.2.bF70Gb
Redis总结（八）redis单线程还是多线程问题卢小记
redis为什么可以支持高并发和它内部的工作模式有不可分割的关系：绝大部分请求是纯粹的内存操作（非常快速）采用单线程,避免了不必要的上下文切换和竞争条件非阻塞IO-IO多路复用Redis客户端对服务端的每次调用都经历了发送命令，执行命令，返回结果三个过程。其中执行命令阶段，由于Redis是单线程来处理命令的，所有到达服务端的命令都不会立刻执行，所有的命令都会进入一个队列中，然后逐个执行，并且多个客
Java 使用 Redis lly202406 开发语言
Java使用Redis1.引言Redis是一个开源的高性能键值对数据库。它支持多种类型的数据结构，如字符串、列表、集合、散列表等，适用于多种场景，如缓存、消息队列等。Java是一种广泛使用的编程语言，它在企业级应用中有着广泛的应用。在Java应用中，使用Redis可以提高数据访问速度，减轻数据库的压力。本文将介绍如何在Java应用中使用Redis。2.准备工作在开始使用Redis之前，需要确保已经
Redis数据结构—跳跃表 skiplist 马卫斌前端工程师 skiplist
跳跃表（Skiplist）是Redis中用于实现有序集合（SortedSet）的一种高效数据结构。以下是关于Redis中跳跃表（Skiplist）的关键特性和工作原理的概览：基本概念层级结构：跳跃表通过多层次的链表组成，每一层都是下一层的稀疏视图，顶层最快地遍历整个链表，而底层则是完全连通所有节点的传统链表结构。这样的设计使得查询操作能够快速跳过大量不需要检查的元素。有序集合：每个节点（或称为元素
Redis安装详解（单机安装，sentinel哨兵模式，Cluster模式） dream21st 中间件学习笔记 sentinel redis java
文章目录1Redis单机安装1.1windows中安装1.2linux中安装2Redis主从复制安装3Redis哨兵模式安装4Springboot项目操作RedisSentinel集群5官方cluster分区搭建5.1部署架构5.2RedisCluster的优势5.3集群搭建6Springboot项目操作Cluster集群1Redis单机安装Redis安装包可以从官网下载，也可以在redis的官方
Redis哨兵模式(Sentinel)详解水木渔樵 Redis redis
目录文章目录一、Sentinel1.何为Sentinel2.Sentinel启动流程当一个Sentinel启动时，它需要执行以下步骤：2.1初始化服务器2.2使用Sentinel专用代码2.3初始化Sentinel状态2.4初始化Sentinel状态的masters属性2.5创建连向主服务器的网络连接3.Sentinel获取主服务器信息4.Sentinel获取从服务器信息5.Sentinel与主从
Redis Sentinel（哨兵）详解 dlwlrma ⥳ Java八股框架 redis sentinel 数据库
目录一：什么是Sentinel（哨兵）二：Sentinel有什么用1.监控2.故障转移3通知4.配置提供三：Sentinel如何检测master节点宕机1.主观下线2.客观下线四：Sentinel是如何选举出新的master1.slave的优先级2.复制进度3.runid五：如何在sentinel集群中选择出Leader前言：有关Redis的基础知识可以参照我之前写的文章Redis必知必会的知识在
枚举的构造函数中抛出异常会怎样 bylijinnan java enum 单例
首先从使用enum实现单例说起。为什么要用enum来实现单例？这篇文章（ http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 1.enum单例简单、容易，只需几行代码： public enum Singleton { INSTANCE;
CMake 教程 aigo C++
转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/ CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。介绍：http://baike.baidu.com/view/1126160.htm 本文件不介绍CMake的基本语法，下面是篇不错的入门教程： http:
cvc-complex-type.2.3: Element 'beans' cannot have character Cb123456 spring Webgis
cvc-complex-type.2.3: Element 'beans' cannot have character Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
jquery实例:随页面滚动条滚动而自动加载内容 120153216 jquery
<script language="javascript"> $(function (){ var i = 4;$(window).bind("scroll", function (event){ //滚动条到网页头部的高度，兼容ie,ff,chrome var top = document.documentElement.s
将数据库中的数据转换成dbs文件何必如此 sql dbs
旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 1)数据库生成表结构信息：主要生成数据库配置文件(.conf文
在IBATIS中配置SQL语句的IN方式 357029540 ibatis
在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： <select id="getForms" param
Spring3 MVC 笔记（一） 7454103 spring mvc bean REST JSF
自从 MVC 这个概念提出来之后 struts1.X struts2.X jsf 。。。。。这个view 层的技术一个接一个！都用过！不敢说哪个绝对的强悍！要看业务，和整体的设计！最近公司要求开发个新系统！
Timer与Spring Quartz 定时执行程序 darkranger spring bean 工作 quartz
有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date;
大端小端转换，le32_to_cpu 和cpu_to_le32 aijuans C语言相关
大端小端转换，le32_to_cpu 和cpu_to_le32 字节序 http://oss.org.cn/kernel-book/ldd3/ch11s04.html 小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
Nginx负载均衡配置实例详解 avords
[导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡
乱说的 houxinyou 框架敏捷开发软件测试
从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白. 不过感觉和程序开发语言差不多，瀑布就是顺序，敏捷就是循环. 瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。也可以把软件开发理
欣赏的价值——一个小故事 bijian1013 有效辅导欣赏欣赏的价值
　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
包冲突问题的解决方法 bingyingao eclipse maven exclusions 包冲突
包冲突是开发过程中很常见的问题：其表现有： 1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就抛如下异常： java.lang.NoClassDefFoundError: Could not in
【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j bit1129 Stream
先来一段废话：实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
sudoku solver in Haskell bookjovi sudoku haskell
这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
java apache ftpClient bro_feng java
最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
读《研磨设计模式》-代码笔记-工厂方法模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 工厂方法模式：使一个类的实例化延迟到子类 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）： * 有很多不同的产品，它
面试记录语 chenyu19891124 招聘
或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
Fire Workflow 1.0正式版终于发布了 comsci 工作 workflow Google
Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 官方网站是 http://www.fireflow.org 经过大家努力,Fire Workflow 1.0正式版终于发布了正式版主要变化: 1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 2、增加IT
Python向脚本传参 daizj python 脚本传参
如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？需要模块：sys 参数个数：len(sys.argv) 脚本名： sys.argv[0] 参数1： sys.argv[1] 参数2： sys.argv[
管理用户分组的命令gpasswd dongwei_6688 passwd
NAME： gpasswd - administer the /etc/group file SYNOPSIS： gpasswd group gpasswd -a user group gpasswd -d user group gpasswd -R group gpasswd -r group gpasswd [-A user,...] [-M user,...] g
郝斌老师数据结构课程笔记 dcj3sjt126com 数据结构与算法
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
yii2 cgridview加上选择框进行操作 dcj3sjt126com GridView
页面代码 <?=Html::beginForm(['controller/bulk'],'post');?> <?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
linux mysql fypop linux
enquiry mysql version in centos linux yum list installed | grep mysql yum -y remove mysql-libs.x86_64 enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* install mysq
Scramble String hcx2013 String
Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. Below is one possible representation of s1 = "great":
跟我学Shiro目录贴 jinnianshilongnian 跟我学shiro
历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。 ----广告-----------------------------------------------------
nginx日志切割并使用flume-ng收集日志 liyonghui160com
nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
Oracle死锁解决方法 pda158 oracle
　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
java之List排序 shiguanghui list排序
在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
servlet单例多线程 utopialxw 单例多线程 servlet
转自http://www.cnblogs.com/yjhrem/articles/3160864.html 和 http://blog.chinaunix.net/uid-7374279-id-3687149.html Servlet 单例多线程 Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的