Redis笔记（2）——Jedis常用操作【Jedis直连与使用连接池】（未完善）

版权声明：本文为博主原创文章，未经博主允许不得转载。谢谢合作~ https://blog.csdn.net/qq_41042595/article/details/86530175

Redis安装、连接池和Jedis八种调用方式(事务、管道、分布式)介绍

jedis基础功能使用细则

使用Jedis直连

package qiu.ht.base;

import java.util.Set;

import redis.clients.jedis.Jedis;

public class Test_Jedis {
	
	//Jedis直连
	public static void main(String[] args) {
		/**
		 * 
		 * Jedis对象直连方式可以分为五个步骤：
			1、导入redis.clients.jedis.Jedis类(jedis-2.9.0.jar)
			2、新建Jedis对象，其构造方法 new Jedis(String host,int port) ，
				  host参数为Redis数据库ip地址，port为端口号。
			3、调用jedis.connect()方法连接Redis
			4、调用jedis内置方法操作数据并获得结果（Jedis API会在后面详细讲）
			5、调用jedis.disconnect()方法关闭连接
		 */
		
		Jedis jedis=new Jedis("127.0.0.1",6379);
                //设置密码可看这篇文章:https://blog.csdn.net/qq_41042595/article/details/86498790#t9
		jedis.auth("1234");
		//连接
		jedis.connect();
		//列出符合特定条件的key   其中pattern为匹配条件，填*则为列出所有
		Set<String> keyList=jedis.keys("*");
//		System.out.println("Hello World");
                //foreach,将keyList的值,赋值于key,并打印,之后,下个keyList值,赋值于key并打印,以此类推,到最后,打印完,自动出"for(){}"往下运行
		for(String key:keyList){
			System.out.println("Hello,World！key=="+key);
		}
		//关闭连接
		jedis.disconnect();
	}
}

使用JedisPool 

⒈

（有key-value时）

数据库db1里的key-value：

遍历查询key-value的代码：

package qiu.ht.base;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class Test_JedisPool {
	
	//Jedis使用连接池
	public static void main(String[] args) {
		/**
		 * Jedis连接池管理方式连接Redis可以分为以下几个步骤：
			1、导入包(jedis-2.9.0.jar和commons-pool2-2.4.2.jar)
			2、获得连接池配置对象JedisPoolConfig
			3、设置连接池信息（最大连接数、最大空闲连接数、最小空闲连接数等）
			4、获得连接池（new JedisPool(GenericObjectPoolConfig poolConfig,String host,int port)）  
			5、获得核心对象Jedis
			6、用Jedis操作Redis数据并取得结果
			7、关闭Jedis连接，关闭JedisPool连接池，释放资源
		 */
		
                //创建连接池配置对象
		JedisPoolConfig config=new JedisPoolConfig();
		config.setMaxTotal(25);//设置最大连接数
		config.setMaxIdle(20);
		config.setMinIdle(5);
		JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
                //获取核心对象
		Jedis jedis=pool.getResource();
		//验证redis密码，如果没有设置密码这段可以省略
		jedis.auth("1234");//登录
		jedis.select(1);//选择DB1数据库
		Set<String> keyList=jedis.keys("*");
		for(String key:keyList){
			//jedis.type(String key)返回给定key所储存的值的类型。 none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表) 
			System.out.println("Hello,World！key=="+key+",type="+jedis.type(key));
			if(jedis.type(key).equals("string")){
				System.out.println("String！value=         "+jedis.get(key));
			}else if(jedis.type(key).equals("hash")){
				System.out.println("Hash！value=         "+jedis.hgetAll(key));
				Map<String,String> map=jedis.hgetAll(key);
				Set<String> set=map.keySet();
				Iterator<String> iterator=set.iterator();
				while(iterator.hasNext()){
//					System.out.println(iterator+"=="+iterator.next());//打印语句里面不能使用hasNext(),否则导致死循环!!!
					String field=iterator.next();
					System.out.println(field+"==hash=="+map.get(field));
				}
			}else if(jedis.type(key).equals("list")){
                        //从此看出String key的length()数字不准确,List的llen()数字才准确,用于jedis.lrange()中,要记得"-1",虽然可以不用"-1",但是为了减少运行量,最好还是要"-1"
				System.out.println("List！value=         "+jedis.lrange(key, 0,key.length())+"           key.length==="+key.length()+"   List的length函数==="+jedis.llen(key));
				System.out.println("List！value=         "+jedis.lrange(key, 0,-1));
				//使用了key.length()函数,但是获取的stop的index有问题！！！
//				List<String> list=jedis.lrange(key, 0,key.length()-1);
				//下面这两个,才是stop的index正确获取方法
//				List<String> list=jedis.lrange(key, 0,-1);
                                //stop从0开始，List获取长度:llen()，Hash获取长度：hlen()
				List<String> list=jedis.lrange(key, 0,jedis.llen(key)-1);
				for(String keys:list){
					System.out.println("List_key="+keys);
				}
			}else if(jedis.type(key).equals("set")){
				System.out.println("Set！value=         "+jedis.smembers(key));
				Set<String> set=jedis.smembers(key);
				for(String sets:set){
					System.out.println("Set_value="+sets);
				}
			}else if(jedis.type(key).equals("zset")){
				System.out.println("Zset");
//		        }else{//zset类型
			}
		}
		
		//检查给定key是否存在 ，返回一个boolean
		if(jedis.exists("nihaonihao")){
			System.out.println("Hey              !!!!!                  "+jedis.get("nihaonihao"));
			//将key1改名为key2,当key1和key2相同或者key1不存在时,返回一个错误
//			jedis.rename("nihaonihao", "why2");
//			System.out.println("Hey              !!!!!        新名字的值          "+jedis.get("why2")+"        旧名字的值 "+jedis.get("nihaonihao"));
		}else{
			System.out.println("nihaonihao这个key   没有!!!!!!");
		}	
		jedis.close();
		pool.close();
	}

}

打印结果：

Hello,World！key==testHash,type=hash
Hash！value=         {field1=value1, field4=value44, field3=value3, field2=value1}
field1==hash==value1
field4==hash==value44
field3==hash==value3
field2==hash==value1
Hello,World！key==pushlist,type=list
List！value=         [1, 2, 3, 3, 4, 4, 5, 6, 7]              key.length===8   List的length函数===9
List！value=         [1, 2, 3, 3, 4, 4, 5, 6, 7]
List_key=1
List_key=2
List_key=3
List_key=3
List_key=4
List_key=4
List_key=5
List_key=6
List_key=7
Hello,World！key==hashwhat,type=list
List！value=         [water is flowing over a waterfall, commit a crime, miss her]              key.length===8   List的length函数===3
List！value=         [water is flowing over a waterfall, commit a crime, miss her]
List_key=water is flowing over a waterfall
List_key=commit a crime
List_key=miss her
Hello,World！key==settest,type=set
Set！value=         [want, something, with, my, do you like it?, to, I, do, it, my lover]
Set_value=want
Set_value=something
Set_value=with
Set_value=my
Set_value=do you like it?
Set_value=to
Set_value=I
Set_value=do
Set_value=it
Set_value=my lover
Hello,World！key==setwhat,type=set
Set！value=         [with whom did you see this movie?, do you like it?]
Set_value=with whom did you see this movie?
Set_value=do you like it?
Hello,World！key==testHash2,type=hash
Hash！value=         {field5=value5, field4=value4, field3=value3}
field5==hash==value5
field4==hash==value4
field3==hash==value3
nihaonihao这个key   没有!!!!!!

补充：（遍历所有Hash的key-value，可以不用Iterator迭代器）

Map<String,String> maphash=jedis.hgetAll("testHash2");
for(Map.Entry<String,String> map : maphash.entrySet()){
    System.out.println(map.getKey()+"==testHash所有=="+map.getValue());
}

 ⒉

（新增key-value时【连接Redis步骤在“⒈”中有讲，在此不重复了】） 

①

String类型的新增 的代码：

//Jedis使用连接池
public static void main(String[] args) {
			JedisPoolConfig config=new JedisPoolConfig();
			config.setMaxTotal(25);
			config.setMaxIdle(20);
			config.setMinIdle(5);
			JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
			Jedis jedis=pool.getResource();
			jedis.auth("1234");
			jedis.select(1);
			Set<String> keyList=jedis.keys("*");
			//返回key的个数
			System.out.println("key的个数==  "+jedis.dbSize());
			for(String key:keyList){
				System.out.println("Hello,World！key=="+key+",type="+jedis.type(key));
			}
			
			//字符串值value关联到key，如果key不存在则会新增一个key
			jedis.set("nihaonihao", "whywhy");
			System.out.println("Hey              !!!!!                  "+jedis.get("nihaonihao"));
			
//			//移出给定的一个或多个key，如果key不存在，则忽略该命令
//			jedis.del("nihaonihao");
//			//打印:无?????        null
//			System.out.println("无?????        "+jedis.get("nihaonihao"));
			
			//检查给定key是否存在 ，返回一个boolean
			if(jedis.exists("nihaonihao")){
				System.out.println("Hey              !!!!!                  "+jedis.get("nihaonihao"));
				//将key1改名为key2,当key1和key2相同或者key1不存在时,返回一个错误
//				jedis.rename("nihaonihao", "why2");
//				System.out.println("Hey              !!!!!        新名字的值          "+jedis.get("why2")+"        旧名字的值 "+jedis.get("nihaonihao"));
			}else{
				System.out.println("nihaonihao这个key   没有!!!!!!");
			}
}

打印结果： 

key的个数==  6
Hello,World！key==testHash,type=hash
Hello,World！key==pushlist,type=list
Hello,World！key==hashwhat,type=list
Hello,World！key==settest,type=set
Hello,World！key==setwhat,type=set
Hello,World！key==testHash2,type=hash
Hey              !!!!!                  whywhy
Hey              !!!!!                  whywhy

我放开“Rename”注释：

打印结果：

key的个数==  7
Hello,World！key==pushlist,type=list
Hello,World！key==settest,type=set
Hello,World！key==testHash2,type=hash
Hello,World！key==nihaonihao,type=string
Hello,World！key==testHash,type=hash
Hello,World！key==hashwhat,type=list
Hello,World！key==setwhat,type=set
Hey              !!!!!                  whywhy
Hey              !!!!!                  whywhy
Hey              !!!!!        新名字的值          whywhy        旧名字的值 null

 我再放开“Delete”注释（将“Rename”注释）：

打印结果：

Hello,World！key==testHash,type=hash
Hello,World！key==hashwhat,type=list
Hello,World！key==setwhat,type=set
Hello,World！key==why2,type=string
Hey              !!!!!                  whywhy
无?????        null
nihaonihao这个key   没有!!!!!!

若先“Delete”再“Rename”也是可以的，打印结果也一样，因为“Delete and Rename”都在"Set"后面，当然“Delete”与“Rename”同时放开注释，打印结果与“Delete”的结果一样，因为Delete了nihaonihao这个key，就不存在“nihaonihao”了，则进入if-else的else中：

“Expire”设置key的生存时间 的代码： 

JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(25);
config.setMaxIdle(20);
config.setMinIdle(5);
JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
Jedis jedis=pool.getResource();
jedis.auth("1234");
jedis.select(1);
Set<String> keyList=jedis.keys("*");
//返回key的个数
System.out.println("key的个数==  "+jedis.dbSize());
for(String key:keyList){
	System.out.println("Hello,World！key=="+key+",type="+jedis.type(key));
}
//设置key生存时间，当key过期时，它会被自动删除。 Time为秒数
jedis.expire("why2",1000);
System.out.println("why2_value="+jedis.get("why2")+"   ,   剩下时间(为-1说明过期)="+jedis.ttl("why2"));

打印结果：

key的个数==  7
Hello,World！key==pushlist,type=list
Hello,World！key==settest,type=set
Hello,World！key==testHash2,type=hash
Hello,World！key==testHash,type=hash
Hello,World！key==hashwhat,type=list
Hello,World！key==setwhat,type=set
Hello,World！key==why2,type=string
why2_value=whywhy   ,   剩下时间(为-1说明过期)=1000

注释“Expire”代码后，运行一次：（“TTL”查看key的生存时间的剩余时间，若为-1，说明key已过期）

打印结果：

key的个数==  7
Hello,World！key==pushlist,type=list
Hello,World！key==settest,type=set
Hello,World！key==testHash2,type=hash
Hello,World！key==testHash,type=hash
Hello,World！key==hashwhat,type=list
Hello,World！key==setwhat,type=set
Hello,World！key==why2,type=string
why2_value=whywhy   ,   剩下时间(为-1说明过期)=869

 “Persist”移出给定key的生存时间 的代码：

JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(25);
config.setMaxIdle(20);
config.setMinIdle(5);
JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
Jedis jedis=pool.getResource();
jedis.auth("1234");
jedis.select(1);
Set<String> keyList=jedis.keys("*");
//返回key的个数
System.out.println("key的个数==  "+jedis.dbSize());
for(String key:keyList){
	System.out.println("Hello,World！key=="+key+",type="+jedis.type(key));
}
//移出给定key的生存时间（设置这个key永不过期）
jedis.persist("why2"); 
System.out.println("why2_value="+jedis.get("why2")+"   ,   剩下时间（为-1说明已经移除了）="+jedis.ttl("why2"));

 打印结果：

key的个数==  7
Hello,World！key==pushlist,type=list
Hello,World！key==settest,type=set
Hello,World！key==testHash2,type=hash
Hello,World！key==testHash,type=hash
Hello,World！key==hashwhat,type=list
Hello,World！key==setwhat,type=set
Hello,World！key==why2,type=string
why2_value=whywhy   ,   剩下时间（为-1说明已经移除了）=-1

在确定“生存时间不为-1”时，persist移除key的生存时间，TTL会为-1，但对于key来说，是死而复生，从“易失”变“持续”，所以删除“持续”的key，要么手动“delete”，要么不理这个key！！！

注：TTL为“-1”，一： 是用于Expire（给key设置生存时间）后的TTL，说明，该key过期了，而且移除了（在控制台打印，最低值为“-1”）；二：是Persist后的TTL，说明，该key的生存时间被移除，key不会易失去，删除，只能手动移除了

 “Setex”函数的作用：（用于String类型的命令）

将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。如果 key 已经存在， SETEX 命令将覆写旧值。

这个命令类似于以下两个命令：

SET key value
EXPIRE key seconds  # 设置生存时间

不同之处是， SETEX 是一个原子性(atomic)操作，关联值和设置生存时间两个动作会在同一时间内完成，该命令在 Redis 用作缓存时，非常实用。

补充：（但Hash类型的key也可以使用这个（我已新增了个Hash类型的key“nihao”），不过后果就是：Hash类型的key变成String类型的key，这样做其实并没有意义）

其使用代码：

打印结果：

 ②

Hash类型的新增的代码：

package qiu.ht.base;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class Test_JedisPool {
	
	//Jedis使用连接池
	public static void main2(String[] args) {
		/**
		 * Jedis连接池管理方式连接Redis可以分为以下几个步骤：
			1、导入包(jedis-2.9.0.jar和commons-pool2-2.4.2.jar)
			2、获得连接池配置对象JedisPoolConfig
			3、设置连接池信息（最大连接数、最大空闲连接数、最小空闲连接数等）
			4、获得连接池（new JedisPool(GenericObjectPoolConfig poolConfig,String host,int port)）  
			5、获得核心对象Jedis
			6、用Jedis操作Redis数据并取得结果
			7、关闭Jedis连接，关闭JedisPool连接池，释放资源
		 */
		
                    //创建连接池配置对象
		JedisPoolConfig config=new JedisPoolConfig();
		config.setMaxTotal(25);//设置最大连接数
		config.setMaxIdle(20);
		config.setMinIdle(5);
		JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
                    //获取核心对象
		Jedis jedis=pool.getResource();
		//验证redis密码，如果没有设置密码这段可以省略
		jedis.auth("1234");//登录
		Set<String> keyList=jedis.keys("*");
//		System.out.println("Hello World");
		for(String key:keyList){
			//返回给定key所储存的值的类型。 none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表) 
			System.out.println("Hello,World！key=="+key+",type="+jedis.type(key));
			if(jedis.type(key).equals("string")){
				System.out.println("String！value=         "+jedis.get(key));
			}else if(jedis.type(key).equals("hash")){
				System.out.println("Hash！value=         "+jedis.hgetAll(key));
////				Set<String> set=jedis.hkeys(key);
//				List<String> list=jedis.hvals(key);
//				for(String lists:list){
//					System.out.println("Hash_value="+list);
//				}
				Map<String,String> map=jedis.hgetAll(key);
				Set<String> set=map.keySet();
//				for(String sets:set){
//					System.out.println("Hash_field="+sets);
//				}
				Iterator<String> iterator=set.iterator();
				while(iterator.hasNext()){
//					System.out.println(iterator+"=="+iterator.next());//打印语句里面不能使用hasNext(),否则导致死循环!!!
					String field=iterator.next();
					System.out.println(field+"==hash=="+map.get(field));
				}
			}else if(jedis.type(key).equals("list")){
				System.out.println("List！value=         "+jedis.lrange(key, 0,key.length())+"              key.length==="+key.length());
				System.out.println("List！value=         "+jedis.lrange(key, 0,-1));
				//这个使用了key.length()函数,但是获取的stop的index有问题！！！
//				List<String> list=jedis.lrange(key, 0,key.length()-1);
				//下面这两个,才是stop的index正确获取方法
//				List<String> list=jedis.lrange(key, 0,-1);//0表示第一个,-1表示最后一个
				List<String> list=jedis.lrange(key, 0,jedis.llen(key)-1);//通过llen方法返回list的长度
				for(String keys:list){
					System.out.println("List_key="+keys);
				}
			}else if(jedis.type(key).equals("set")){
				System.out.println("Set！value=         "+jedis.smembers(key));
				Set<String> set=jedis.smembers(key);
				for(String sets:set){
					System.out.println("Set_value="+sets);
				}
			}else if(jedis.type(key).equals("zset")){
				System.out.println("Zset");
//		}else{//zset类型
			}
		}
		
		//字符串值value关联到key，如果key不存在则会新增一个key
//		jedis.set("nihaonihao", "whywhy");
//		System.out.println("Hey              !!!!!                  "+jedis.get("nihaonihao"));
		
//		//移出给定的一个或多个key，如果key不存在，则忽略该命令
//		jedis.del("nihaonihao");
//		//打印:无?????        null
//		System.out.println("无?????        "+jedis.get("nihaonihao"));
		
		//检查给定key是否存在 ，返回一个boolean
		if(jedis.exists("nihaonihao")){
//			System.out.println("Hey              !!!!!                  "+jedis.get("nihaonihao"));
			//将key1改名为key2,当key1和key2相同或者key1不存在时,返回一个错误
			jedis.rename("nihaonihao", "why2");
			System.out.println("Hey              !!!!!        新名字的值          "+jedis.get("why2")+"        旧名字的值 "+jedis.get("nihaonihao"));
		}else{
			System.out.println("nihaonihao这个key   没有!!!!!!");
		}
		
		jedis.close();
		pool.close();
	}
	public static void main(String[] args) {
		JedisPoolConfig config=new JedisPoolConfig();
		config.setMaxTotal(25);
		config.setMaxIdle(20);
		config.setMinIdle(5);
		JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
		Jedis jedis=pool.getResource();
		jedis.auth("1234");
		jedis.select(1);//选择db1数据库
		Set<String> keyList=jedis.keys("*");
		//返回key的个数
		System.out.println("key的个数==  "+jedis.dbSize());
		for(String key:keyList){
			System.out.println("Hello,World！key=="+key+",type="+jedis.type(key));
		}
		
		//设置key生存时间，当key过期时，它会被自动删除。 Time为秒数
//		jedis.expire("why2", 60);
		//移出给定key的生存时间（设置这个key永不过期）
//		jedis.persist("why2"); 
//		System.out.println("why2_value="+jedis.get("why2")+"   ,   剩下时间="+jedis.ttl("why2"));
		//setex之后
//		jedis.persist("nihao_hash"); 
//		System.out.println("why2_value="+jedis.get("nihao_hash")+"   ,   剩下时间（为-1说明已经移除了）="+jedis.ttl("nihao_hash"));
		/**
		 * 打印语句会报异常:(因为nihao_hash的值不可获取了)
		 * Exception in thread "main" redis.clients.jedis.exceptions.JedisDataException: WRONGTYPE Operation against a key holding the wrong kind of value
				at redis.clients.jedis.Protocol.processError(Protocol.java:127)
		 */
		
		//将值value关联到key，并将key的生存时间设为seconds(秒)，不管原来nihao_hash是什么类型，运行setex之后，变String类型，值覆盖为“ni1 ni1”。
//		jedis.setex("nihao_hash",1000, "ni1 ni1");
//		Set<String> keyList2=jedis.keys("*");
//		for(String key:keyList2){
//			System.out.println("Hello,World！key=="+key+",type="+jedis.type(key));
//		}
		/**
		 * 这个setex之后,不再是hash类型了,否则会报错:
		 * 127.0.0.1:6379> hgetall nihao_hash
			1) "nihao"
			2) "hao"
			3) "OK"
			4) "K"
			5) "ni"
			6) "ni"
			7) "hao"
			8) "ni"
			127.0.0.1:6379> hgetall nihao_hash【开始使用setex函数】
			(error) WRONGTYPE Operation against a key holding the wrong kind of value【对持有错误类型值的键执行错误的操作】
			127.0.0.1:6379> exists nihao_hash
			(integer) 1
			127.0.0.1:6379>  hmset nihao_hash ni ni nihao hao  O OK K OK how ??
			(error) WRONGTYPE Operation against a key holding the wrong kind of value
			127.0.0.1:6379> hset nihao_hash ni ni
			(error) WRONGTYPE Operation against a key holding the wrong kind of value
			127.0.0.1:6379> get nihao_hash【setex之后hash类型变成string类型了，要用get才获取得了value】
			"ni1 ni1"
		 */
		
		//清空整个redis实例所有的key 
//		jedis.flushAll(); 
		//清空redis当前数据库所有的key 
//		jedis.flushDB(); 
		//flushDB之后没有任何个key了
//		Set<String> keyList2=jedis.keys("*");
//		for(String key:keyList2){
//			System.out.println("Hello,World！key=="+key+",type="+jedis.type(key));
//		}

		//------------------------------------------------------------------------Hash----------------
		
		//设置一张hash表的两种方式：
//		//1、分别给哈希表key中的域设置值，分别对key中的字段1、字段2设置值
//		jedis.hset("testHash" , "field1" , "value1");
//		jedis.hset("testHash" , "field2" , "value1");
//		//2、用一个JAVA中的HashMap直接存储为redis中的哈希表
//		Map map = new HashMap();
//		map.put("field11" , "value11");
//		map.put("field12" , "value11");
//		jedis.hmset("testHash2" , map);
		
		//返回哈希表key中给定字段field的值，返回对应值的类型
//		System.out.println("testHash的第二个field=="+jedis.hget("testHash" ,"field2")+",testHash2的第二个field=="+jedis.hget("testHash2" ,"field12"));
		//返回哈希表key中给定多个字段的值，返回一个List
//		List<String> listhash=jedis.hmget("testHash2" ,"field3","field4");
//		for(String key:listhash){
//			System.out.println("111111    testHash2的指定field的值,value=="+key);
//		}
		
		//返回哈希表key中的所有字段和值，返回一个Map<String,String>
//		Map<String,String> maphash=jedis.hgetAll("testHash2");
//		Set<String> set=maphash.keySet();
//		Iterator<String> iterator=set.iterator();
//		while(iterator.hasNext()){
//			String field=iterator.next();
//			System.out.println(field+"==testHash所有=="+maphash.get(field));
//		}
		
		//删除哈希表key中的一个或多个指定字段
//		jedis.hdel("testHash2","field12","field11");
		//查看哈希表key中，给定字段field是否存在。 
//		if(jedis.hexists("testHash2","field12")){
//			System.out.println("在testHash2这个key中存在field12域");
//		}else{
//			System.out.println("删除成功!!");
//		}
//		//返回哈希表key中的所有字段 
//		Set<String> sethash=jedis.hkeys("testHash2"); 
//		//返回哈希表key中的所有值 
//		List<String> listhash2=jedis.hvals("testHash2");
//
//		for(String key:sethash){
//			System.out.println("222222    testHash2的所有key,key=="+key);
//		}
//		for(String key:listhash2){
//			System.out.println("333333    testHash2的所有value,value=="+key);
//		}
		
		//---------------------------------------------------------------------List----------------------
		
		//将值value插入到列表key的表头。 
//		jedis.lpush("listpush" ,"what","how","1","0哈哈哈哈");
//		//返回列表key中指定区间内的元素,区间以偏移量start和stop指定. 下标(index)参数start和stop从0开始; 负数下标代表从后开始(-1表示列表的最后一个元素,-2表示列表的倒数第二个元素,以此类推)  返回一个List
//		//返回列表key的长度 , 返回一个Int     -----------jedis.llen(keyname);
//		List<String> listlist=jedis.lrange("listpush" , 0,jedis.llen("listpush")-1);
//		for(String key:listlist){
//			System.out.println("444444    listpush的所有value,value=="+key);
//		}
		
		//---------------------------------------------------------------------Set--------------------
		
//		//将member元素加入到集合key当中。
//		jedis.sadd("settest" , "I","want","to","do","something","it","with","my","my lover");
//		//返回集合key的元素的数量
//		System.out.println("移除前,,,,,,有多少value了?      "+jedis.scard("settest"));
//		//移除集合中的多个member元素。
////		jedis.srem("settest" , "it");
//		System.out.println("移除后,,,,,,有多少value了?      "+jedis.scard("settest"));
//		//判断元素是否是集合key的成员
//		if(jedis.sismember("settest" , "it")){
//			System.out.println("存在it");
//		}else{
//			System.out.println("移除it成功!!!!!!");
//		}
//		//返回集合key中的所有成员。返回一个set
//		Set<String> setset=jedis.smembers("settest");
//		for (String string : setset) {
//			System.out.println("settest中的所有value=="+string);
//		}
//		//返回一个集合的全部成员，该集合是所有给定集合的交集
//		Set<String> setset2=jedis.sinter("settest" , "setwhat");
//		for (String string : setset2) {
//			System.out.println("setwhat与settest中的相同的value=="+string);
//		}
//		//返回一个集合的全部成员，该集合是所有给定集合的并集
//		Set<String> setset3=jedis.sunion("settest" ,"setwhat");
//		for (String string : setset3) {
//			System.out.println("settest与setwhat的并集value=="+string);
//		}
//		//返回一个集合的全部成员，该集合是所有给定集合的差集
//		Set<String> setset4=jedis.sdiff("settest" , "setwhat");
//		for (String string : setset4) {
//			System.out.println("settest对于setwhat来说,差了什么(除了setwhat交集的值剩下的value),value=="+string);
//		}
//		Set<String> setset5=jedis.sdiff("setwhat","settest");
//		for (String string : setset5) {
//			System.out.println("setwhat差了settest的值是"+string);
//		}

		jedis.close();
		pool.close();
	}
	
}