Redis入门之redis 连接以及 对字符的操作

package redis.clients.jedis.tests;

import java.text.ParseException;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.params.set.SetParams;

public class JedisAllMethodTest {
	static Jedis jedis = null;
	static HostAndPort hnp = new HostAndPort("10.0.50.11", Protocol.DEFAULT_PORT);
	
	/**
	 * 初始化连接
	 * @author jackson
	 * @date 2015-12-16 上午8:54:01
	 * @throws Exception
	 * @return void
	 */
	@BeforeClass  // junit 提供的@BeforeClass标签，    beforeClass 标签只执行一次
	  public static void setUp() throws Exception {
	   //连接jedis 的第一种方式
		jedis = new Jedis(hnp.getHost(), hnp.getPort(), 500);
	    jedis.connect();
	    jedis.auth("foobared");// redis auth 命令 验证 redis 密码，需要在redis.conf配置文件中，开启  requirepass foobared 参数，
	    jedis.configSet("timeout", "300");// redis config 命令
	    jedis.flushAll();// redis flushall 命令 清空所有key 及清空所有数据
		
	    //连接jedis的第二种方式
	    /* 使用 uri 连接数据库
 	    jedis = new Jedis(new URI("redis://:foobared@10.0.50.11:6379/4"), 15000,15000);// 4 表示连接的是 第5个数据库 url,超时时间,输入流超时时间
	    jedis.connect();
	    jedis.flushAll();// redis flushall 命令 清空所有key 及清空所有数据
	      */
	    
	    // 连接jedis的第三种方式
	    /*使用 jedisShardInfo 连接redis
		JedisShardInfo jedisShardInfo = new JedisShardInfo("redis://:foobared@10.0.50.11:6379/1");// /1 表示连接的是 第二个数据库 ；foobared 数据库的密码
		jedisShardInfo.setConnectionTimeout(150000);
		jedisShardInfo.setSoTimeout(150000);
		jedis = new Jedis(jedisShardInfo);
	    jedis.connect();
	    jedis.flushAll();// redis flushall 命令 清空所有key 及清空所有数据
	    */
	    
	  }

	/**
	 * 关闭连接
	 * @author jackson
	 * @date 2015-12-16 上午8:54:34
	 * @return void
	 */
	@AfterClass
	public static void tearDown() { // 当标签为 AfterClass BeforeClass 时方法 必须为static  为 before  after 时不需要
	    jedis.disconnect();// 最终调用的是  Connection 中的  disconnect  作用是关闭流，关闭socket
	 }
	/**
	 *   redis 中  对 字符串 和key的操作的演示
	 * @author jackson
	 * @date 2015-12-17 下午1:15:10
	 * @throws InterruptedException
	 * @throws ParseException
	 * @return void
	 */
	/**
	 * @author jackson
	 * @date 2015-12-17 下午1:48:00
	 * @throws InterruptedException
	 * @throws ParseException
	 * @return void
	 */
	@Test
	public void jedisStringKeyTest() throws InterruptedException, ParseException{
		System.out.println("===测试jedis BEGIN==="); // sotimeOut设置socket调用InputStream读数据的超时时间
		jedis.set("test", "test"); 
		System.out.println(jedis.get("test"));
		jedis.append("test", "test2");// 最终是将 字符串转换为字节数组通过流的形式写入
		System.out.println(jedis.get("test"));
		
		/*
		 * NX|XX, NX --有此参数时只能 set 不存在的key,如果给已经存在的key set 值则不生效， XX -- 此参数只能设置已经存在的key 的值，不存在的不生效
		 * EX|PX, key 的存在时间: EX = seconds; PX = milliseconds
		 * */
		// 验证  NX XX
		String status = jedis.set("test", "test234",SetParams.setParams().nx());// status 为null 则说明操作失败
		System.out.println("测试SetParams.setParams().nx()给已经存在的key set值  操作状态："+status + "操作值"+jedis.get("test")); // 输出值testtest2
		status = jedis.set("test1", "test2222",SetParams.setParams().nx());//status 为ok
		System.out.println("测试SetParams.setParams().nx()给不存在的key set值  操作状态 操作状态："+status + "操作值"+jedis.get("test1"));// 输出值为test2222
		
		status = jedis.set("test1", "test342222",SetParams.setParams().xx());// status 为ok
		System.out.println(" 测试SetParams.setParams().xx()给已经存在的key set值  操作状态 操作状态："+status + "操作值"+jedis.get("test1"));// 输出值为 test342222
		status = jedis.set("test21", "test34212222",SetParams.setParams().xx());// status 为null 
		System.out.println("测试SetParams.setParams().xx()给不存在的key set值  操作状态 操作状态 操作状态："+status + "操作值"+jedis.get("test21"));// 输出值为null
		
		// 验证 EX|PX
		status = jedis.set("testEX", "testEX",SetParams.setParams().ex(1));
		System.out.println("测试 ex  操作状态："+status+"操作值:"+jedis.get("testEX"));// 输出 testEX
		Thread.sleep(1002);
		System.out.println("测试ex 1 秒后自动销毁，输出null 操作状态："+status+"操作值:"+jedis.get("testEX"));// 1 秒后自动销毁，输出null
		
		status = jedis.set("testPX", "testEX",SetParams.setParams().px(100));
		System.out.println("测试 px  操作状态："+status+"操作值:"+jedis.get("testPX"));// 输出 testEX
		Thread.sleep(101);
		System.out.println("测试px 1 秒后自动销毁 操作状态："+status+"操作值:"+jedis.get("testPX"));// 1 秒后自动销毁，输出null
		
		
		 // Note: 因为SET 命令可以通过参数来实现和SETNX 、SETEX 和PSETEX 三个命令的效果，所以将来的Redis 版本可能会废弃并最终移除SETNX 、SETEX 和PSETEX 这三个命令
		//setNx 将key 的值设为value ，当且仅当key 不存在。若给定的key 已经存在，则SETNX 不做任何动作。 SETNX 是『SET if Not eXists』(如果不存在，则SET) 的简写
		 // 类似于 set(key,value,nx)  
		 // 当key 不存在时
		 long   n = jedis.setnx("key6", "value6");
		 System.out.println(n!=0?"set 成功"+jedis.get("key6"):"set 失败"); // set 成功返回 1  set失败返回 0 
		 // 当key 存在时
		 n = jedis.setnx("key6", "value6");
		 System.out.println(n!=0?"set 成功"+jedis.get("key6")+n:"set 失败"+jedis.get("key6")+n);
		 
		 // setex 类似于 执行 set(key,value) 在执行   EXPIRE  类似于  set(key,value,ex)  设置生存时间是 秒级的
		status =  jedis.setex("key7", 1, "value7");
		 System.out.println(status+jedis.get("key7"));
		 Thread.sleep(1000);
		 System.out.println(jedis.get("key7"));
		 jedis.psetex("key20", 10, "value20");// 设置毫秒级的生存时间,类似于  set(key,value,px)
		
		// exists  检查给定key(多个 key值) 是否存在。 返回值： 若 所有key都不存在，返回0 ，若存在 则返回 存在key的数量
		 System.out.println("===测试 exists 命令： ====");
		  n = jedis.exists("test1 test test2".split(" ")); // 
		 int count = "test1 test test2".split(" ").length - (int) n;
		 System.out.println( n != 0 ? "key 存在 个数为："+n+" 不存在个数为："+count:"key 不存在"+n);
		 
		 // exist 检查 单个 key 值是否存在   返回值： 如果key 值存在 返回 true ,如果不存在 在返回false
		
		 boolean exists =  jedis.exists("test");// 返回true
		 System.out.println(exists);
		 
		 // del 删除给定的一个或多个key 。不存在的key 会被忽略  返回值： 返回删除key 的数量，
		 System.out.println("===测试 del 命令：=== ");
		 n = jedis.del("test1 test test2".split(" "));
		 System.out.println("删除key 的数量为"+n);
		 System.out.println(jedis.get("test")+jedis.get("test1"));// 返回null  说明已经删除了
		 
		 jedis.set("testDel", "testDel");
		 n = jedis.del("testDel");
		 System.out.println("删除key 的数量为"+n);
		 
		 // type 命令
		 System.out.println("===测试 type 命令：=== ");
		 String type = jedis.type("test"); // test 不存在 返回none
		 System.out.println("存储类型为："+type);
		 jedis.set("testType", "testType");
		 type = jedis.type("testType"); // test 返回String
		 System.out.println("存储类型为："+type);
		 
		 jedis.flushAll();
		 // mset 命令 批量 插入   插入所有的值，如果key值已经存在，则进行覆盖   插入成功 返回ok 总是插入成功
		 System.out.println("===测试 mset 命令：=== ");
		 status = jedis.mset("fruit apple drink beer food cookies".split(" "));
		 System.out.println("OK".equals(status)?"批量插入成功":"批量插入失败");
		 
		 // msetnx 批量插入 不存在的key ,如果有已存在的key 则返回  0  插入失败
		 System.out.println("===测试 msetnx 命令：=== ");
		 n = jedis.msetnx("apple fruit beer drink cookies food fruit cookies".split(" "));// 返回 0 插入失败，插入的里面不能有 已经存在的key
		 System.out.println(n!=0?"批量插入成功"+n:"批量插入失败 "+n);
		 
		 n = jedis.msetnx("apple fruit beer drink cookies food".split(" "));// 返回 1 插入成功
		 System.out.println(n!=0?"批量插入成功"+n:"批量插入失败 "+n);
		 
		 // keys 命令  根据正则表达式 取得相匹配的  key
		 System.out.println("===测试 keys 命令：==== ");
		 Set<String> keySet = jedis.keys("*");
		 Iterator<String> it = keySet.iterator();
		 String s = "";
		 while(it.hasNext()){
			 s = s+ it.next()+" ";
			
		 }
		 System.out.println("正则所匹配的key:"+s);
		 
		 // randomKey 命令 从当前数据库中随机返回(不删除) 一个key 。
		 System.out.println("====测试 randomKey 命令：===");
		 int m = 0;
		 while(m < 4){
			 System.out.println(jedis.randomKey());
			 m++;
		 }
		 System.out.println("====测试 rename 命令：===");
//		 status = jedis.rename("apple", "apple");// 重命名 key 时，如果 oldKey 与 newkey 一样则返回一个错误，执行不通过
		 status = jedis.rename("apple", "appleRename");
		 System.out.println(jedis.get("fruit"));// apple
		 status = jedis.rename("appleRename", "fruit");// 如果 newKey 已经存在则覆盖
		 
		 System.out.println("OK".equals(status)?"更新key成功"+jedis.get("fruit"):"更新key失败");//fruit
		 
		 System.out.println("====测试 renamenx 命令：===");// 
		 n = jedis.renamenx("fruit", "apple");//新的key 只能是不存在的key 
		 System.out.println(n!= 0?"更新key成功":"更新失败");
//		 n = jedis.renamenx("fruit", "cookies");//新的key 存在 返回一个错误
//		 System.out.println(n!= 0?"更新key成功":"更新失败");
		 
		 //expire 设置生存时间
		 System.out.println("====测试 expire 命令：===");
		 n = jedis.expire("cookies", 1);// 设置生存时间 以秒 为单位
		 System.out.println(jedis.get("cookies"));
		 System.out.println("休眠1秒");
		 Thread.sleep(1000);
		 System.out.println(n!=0?"设置生存时间成功"+jedis.get("cookies"):"设置生存时间失败");
		 // 针对 cookies 进行更名操作，查看是否 还具有生存时间
		 jedis.flushAll();
		 jedis.mset("key1 value1 key2 value2 key3 value3 key4 value4 key5 value5".split(" "));
		 n = jedis.expire("key1", 2);
		 jedis.rename("key1", "key6");
		 System.out.println(jedis.get("key6"));
		 Thread.sleep(2000);
		 System.out.println(jedis.get("key6"));// 输出null  说明 rename 后 key6 继承了 key1的生存时间。
		 jedis.del("key6");// 删除key6  del 会删除生存时间
		 jedis.set("key6", "value1");
		 System.out.println(jedis.get("key6"));
		 Thread.sleep(2000);
		 System.out.println(jedis.get("key6"));
		 
		 
		 
		 jedis.flushAll();
		 jedis.mset("key1 value1 key2 value2 key3 value3 key4 value4 key5 value5".split(" "));

		 // ttl   查看剩余生存时间   expireAt EXPIREAT 的作用和EXPIRE 类似，都用于为key 设置生存时间。不同在于EXPIREAT 命令接受的时间参数是UNIX 时间戳(unix timestamp)。
//		 jedis.expireAt("key1",20149765902363l);
//		 n = jedis.ttl("key1");// 返回 key1上的 剩余时间
//		 System.out.println(n);// 如果不存在 返回 -1
		 
		 //move
		 System.out.println("测试 move命令");
		 // key1 不存在 1 中时 将 0 中的 key1 移动到 1 中
		 jedis.select(1);// 切换 DB 为 1
		 System.out.println(jedis.exists("key1")?"key1 存在 库 1 中":"key1 不存在 库 1 中");// 查询 DB1 中是否 包含 key1
		 jedis.select(0);//切换 到 0
		 n = jedis.move("key1", 1);
		 jedis.select(1);// 切换 DB 为 1
		 System.out.println(n+jedis.get("key1"));// 查询 DB1 中是否 包含 key1
		
		 // key2 不存在 1 库中时，将 1库中的key2 移动到 key1
		 jedis.select(1);// 切换 DB 为 1
		 System.out.println(jedis.exists("key2")?"key2 存在 库 1 中":"key2 不存在 库 1 中");// 查询 DB1 中是否 包含 key1
		 n = jedis.move("key2", 0);
		 System.out.println(n==0?"移动失败":"移动成功");// 查询 DB1 中是否 包含 key1
		 
		
		 // 当两个库中都存在 key1 时
		 jedis.select(0);
		 jedis.set("key1", "ivalue11");
		 jedis.select(1);// 切换 DB 为 1
		 System.out.println(jedis.exists("key1")?"key1 存在 库 1 中"+jedis.get("key1"):"key1 不存在 库 1 中");// 查询 DB1 中是否 包含 key1
		 n = jedis.move("key1", 0);
		 System.out.println("1 库中的 key1 value:"+jedis.get("key1"));
		 jedis.select(0);// 切换 DB 为 1
		 System.out.println(n==0?"移动失败 0库中的key1:"+jedis.get("key1"):"移动成功");// 查询 DB1 中是否 包含 key1
		 
		 //getset  返回 key 对应的旧值，set 新值  如果 key 在库中不存在 
		 jedis.flushAll();
		 jedis.mset("key1 value1 key2 value2 key3 value3 key4 value4 key5 value5".split(" "));
		 jedis.select(0);
		 String key1= jedis.getSet("key1", "value11");// 返回旧值  set 新值
		 System.out.println("key1 对应的旧值："+key1 + "key1 新值："+jedis.get("key1"));
		 
		 
		 // mget 返回所有(一个或多个) 给定key 的值。 如果给定的key 里面，有某个key 不存在或者 value 非String，，那么这个key 返回特殊值null  。因此，该命令永不失败
		 jedis.flushAll();
		 jedis.mset("key1 value1 key2 value2 key3 value3 key4 value4 key5 value5".split(" "));
		 List<String> list = jedis.mget("key1 key2 key3 key4 key5 key6".split(" "));
		 for(String value : list){
			 System.out.print(value+" ");
		 }
		 System.out.println();
		
		 //decr
//		 n = jedis.decr("key6"); // 由于value 不是数字 所有返回错误
		 // key 存在的情况
		 jedis.set("key8", "10");
		 n = jedis.decr("key8");// 返回值： 执行DECR 命令之后key 的值。 所以 n = 9
		 System.out.println("返回值： 执行DECR 命令之后key 的值。:"+ n+"  jedis.get :"+jedis.get("key8")+"  key8 的 type ："+jedis.type("key8"));
		 
		 //key 不存在的情况  先将 key 初始化为 0 在减去1
		 n = jedis.decr("key9");// 返回值： 执行DECR 命令之后key 的值。 所以 n = 9
		 System.out.println("返回值： 执行DECR 命令之后key 的值。:"+ n+"  jedis.get :"+jedis.get("key9")+"  key9 的 type： "+jedis.type("key9"));
		 
		
		 //decrby
		 jedis.set("key8", "10");
		 n = jedis.decrBy("key8",5);// 返回值： 执行decrby  在原原有的基础上减去 5  n = 5
		 System.out.println("返回值： 执行decrby命令之后key 的值。:"+ n+"jedis.get :"+jedis.get("key8")+"key8 的 type ："+jedis.type("key8"));
		 
		 //key 不存在的情况  先将 key 初始化为 0 在减去7
		 n = jedis.decrBy("key10",7);// 返回值： 执行DECRBy 命令之后key 的值。 所以 n = -7
		 System.out.println("返回值： 执行decrby命令之后key 的值。:"+ n+"  jedis.get :"+jedis.get("key10")+"  key10 的 type： "+jedis.type("key10"));
		 
		 // incr
		 jedis.set("key8", "10");
		 n = jedis.incr("key8");// 返回值： 执行DECR 命令之后key 的值。 所以 n = 11
		 System.out.println("返回值： 执行incr 命令之后key 的值。:"+ n+"  jedis.get :"+jedis.get("key8")+"  key8 的 type ："+jedis.type("key8"));
		 
		 //key 不存在的情况  先将 key 初始化为 0 在加1
		 n = jedis.incr("key12");//返回值： 执行incr 命令之后key 的值。 所以 n = 1
		 System.out.println("返回值： 执行incr 命令之后key 的值。:"+ n+"  jedis.get :"+jedis.get("key12")+"  key12 的 type： "+jedis.type("key12"));
		 
		 //incrby
		 jedis.set("key8", "10");
		 n = jedis.incrBy("key8",5);// 返回值： 执行decrby  在原原有的基础上加上 5  n = 15
		 System.out.println("返回值： 执行decrby命令之后key 的值。:"+ n+"jedis.get :"+jedis.get("key8")+"key8 的 type ："+jedis.type("key8"));
		 
		 //key 不存在的情况  先将 key 初始化为 0 在加7  int 类型
		 n = jedis.incrBy("key13",7);// 返回值： 执行incrBy命令之后key 的值。 所以 n = 7
		 System.out.println("返回值： 执行incrBy命令之后key 的值。:"+ n+"  jedis.get :"+jedis.get("key13")+"  key13 的 type： "+jedis.type("key13"));
		 
		// incrByFloat  输入的是 double 返回的 是double  上面的 incr  incrBy decr decrBy 都只能针对int 操作
		 double incrDouble = jedis.incrByFloat("key15",66666.3333);// 返回值： 执行incrBy命令之后key 的值。 所以 n = 7
		 System.out.println("返回值： 执行incrBy命令之后key 的值。:"+ incrDouble+"  jedis.get :"+jedis.get("key15")+"  key13 的 type： "+jedis.type("key15"));
		 
		//append
		 //key 存在的情况
		 n = jedis.append("key4", "Append");//返回值 是 追加字符串后的 key4 value 的changd :12 key4 的length: 12 key4 的value: value4Append
		 System.out.println("返回值 是 追加字符串后的 key4 value 的changd :"+ n +" key4 的length: "+jedis.get("key4").length() +" key4 的value: "+jedis.get("key4"));
		 // key 不存在的情况  单纯的 set  新值
		 n = jedis.append("key16", "key16Append");//返回值 是 追加字符串后的 key16 value 的changd :11 key16 的length: 11 key16 的value: key16Append
		 System.out.println("返回值 是 追加字符串后的 key16 value 的changd :"+ n +" key16 的length: "+jedis.get("key16").length() +" key16 的value: "+jedis.get("key16"));
	
		 // substr getrange 命令 目前没发现二者的区别，待以后研究
		 String subStr = jedis.substr("key4",0,3);
		 System.out.println("key4 返回的子字符串为： "+subStr );
		 subStr = jedis.substr("key4",-2,-1);
		 System.out.println("key4 返回的子字符串为： "+subStr );
		 subStr = jedis.getrange("key4",0,3);//在<= 2.0 的版本里，GETRANGE 被叫作SUBSTR
		 System.out.println("key4 返回的子字符串为： "+subStr );
		 subStr = jedis.getrange("key4",-2,-1);//在<= 2.0 的版本里，GETRANGE 被叫作SUBSTR
		 System.out.println("key4 返回的子字符串为： "+subStr );
		 // setrange
		 //设置的偏移量 4 小于原字符串的长度
		 n = jedis.setrange("key4", 4, "333");// 从第五位开始 替换 将原有的字符串 替换为333   返回值 n 是字符串的长度 12
		 System.out.println("key4 的value : "+jedis.get("key4")+"  返回字符串的长度： "+n); // key4 的value : valu333ppend  返回字符串的长度： 12
		 // 设置的偏移量大于 原字符串的长度
		 n = jedis.setrange("key4", 18, "222333");// 超出偏移量的地方用空格代替
		 System.out.println("key4 的value : "+jedis.get("key4")+"  返回字符串的长度： "+n); //  key4 的value : valu333ppend     222333  返回字符串的长度： 24
		 // 当key 为空时
		 n = jedis.setrange("key22", 18, "222333");//  key为空时，相当于set 新值，但是set为位置是从17位开始，前面的全部用个空格代替
		 System.out.println("key22 的value : "+jedis.get("key22")+"  返回字符串的长度： "+n); //  key22 的value :                222333  返回字符串的长度： 24
		
		 //strlen
		 n = jedis.strlen("key5");
		 System.out.println("key5 的value： "+jedis.get("key5")+"返回 key5的长度： "+n);
		
		 //bitcount  getbit  setbit bitop 这四个命令是针对字符串的二进制进行操作
		 
		 //• SCAN 命令用于迭代当前数据库中的数据库键。  hscan sscan zscan 在 集合 操作 list 操作中演示
		 ScanResult<String> scanResult =  jedis.scan("0"); // 最简单的迭代，迭代数据库中的所有key 初始游标为 0 ，返回结果是封装好了的 ScanResult对象 ， 包含游标和 key 结果集
		 scanResult.getCursor();// 返回的游标  继续用此 游标进行遍历，直到 返回 0 说明遍历完成。
		 scanResult.getResult();// 返回的结果集 里面包含返回的所有的key 
		 
		 // scan(curso,params) cursor 表示开始遍历的游标   params 是ScanParams 对象，此对象可以设置 每次返回的数量，以及遍历时的正则表达式
		 ScanParams scanParams = new ScanParams();
		 scanParams.count(100);// 表示一次返回的数量是100个 及 ScanResult.getResult 返回的list size 为 99
		 scanParams.match("*");// 表示遍历所有的值  也可以 如 ： *11* 搜索key 中包含11 的key 注意：需要注意的是，对元素的模式匹配工作是在命令从数据集中取出元素之后，向客户端返回元素之前的这段时间内进行的，所以如果被迭代的数据集中只有少量元素和模式相匹配，那么迭代命令或许会在多次执行中都不返回任何元素。
		 jedis.scan("0",scanParams);// 
	} 
}