JavaRedisJedis--学习笔记代码片断--序列化-tutoriel mysql-php.cn

Java Redis Jedis--学习笔记代码片断--序列化维基百科 : Redis是一个开源、支持网络、基于内存、键值对存储数据库，使用ANSI C编写。其开发由VMware主持。根据月度排行网站DB-Engines.com的数据显示，Redis是最流行的键值对存储数据库。http://zh.wikip

Java Redis Jedis--学习笔记代码片断--序列化

维基百科 : Redis是一个开源、支持网络、基于内存、键值对存储数据库，使用ANSI C编写。其开发由VMware主持。根据月度排行网站DB-Engines.com的数据显示，Redis是最流行的键值对存储数据库。http://zh.wikipedia.org/wiki/Redis

package com.jiangge.jrtest;

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;

public class JedisTest {
	
	public static void main(String[] args) {
		
		JedisTest jrd = new JedisTest();
		jrd.test();
	}
	
		public void test(){
			Jedis  jedis = new Jedis("localhost"); //连接redis  Jedis jedis = new Jedis("134.152.244.234",6379);  
//			redis.auth("redis"); //验证密码
			
//			jedis.flushAll(); //删除所有key
//			Set keys = jedis.keys("*");
//			System.out.println(keys);
			
			jedis.set("test", "helloword!");
			jedis.set("foo", "foovaluehehehehe!");
			String value = jedis.get("test");
			System.out.println(value);
			
			
			//列出所有的key，查找特定的key如：redis.keys("foo")
		    Set keys = jedis.keys("*");
			Iterator t1 = keys.iterator() ;
			while(t1.hasNext()){
				Object obj1 = t1.next();
				System.out.println(obj1);
			}
			
			//DEL 移除给定的一个或多个key。如果key不存在，则忽略该命令。
			Long delResult = jedis.del("name1");
			System.out.println("delResult ==>" + delResult);
			
			//TTL 返回给定key的剩余生存时间(time to live)(以秒为单位)
			Long ttlResult = jedis.ttl("foo");
			System.out.println("ttlResult ==>" + ttlResult);
			
			//PERSIST key 移除给定key的生存时间。
			Long persistResult = jedis.persist("foo");
			System.out.println("persistResult ==>" + persistResult);
			
			//EXISTS 检查给定key是否存在。	
			Boolean existsResult = jedis.exists("foo");
			System.out.println("existsResult ==>" + existsResult);
			
			//MOVE key db  将当前数据库(默认为0)的key移动到给定的数据库db当中。如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定key，或者key不存在于当前数据库，那么MOVE没有任何效果。
			jedis.move("foo", 1);//将foo这个key，移动到数据库1
			
			//RENAME key newkey  将key改名为newkey。当key和newkey相同或者key不存在时，返回一个错误。当newkey已经存在时，RENAME命令将覆盖旧值。
			jedis.rename("foo", "foonew");
			
			//TYPE key 返回key所储存的值的类型。
			System.out.println("key所储存的值的类型 ==>" + jedis.type("test"));//none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表)
		      
		    //EXPIRE key seconds 为给定key设置生存时间。当key过期时，它会被自动删除。
			jedis.expire("foo", 5);//5秒过期
			//EXPIREAT EXPIREAT的作用和EXPIRE一样，都用于为key设置生存时间。不同在于EXPIREAT命令接受的时间参数是UNIX时间戳(unix timestamp)。
		    
		    //一般SORT用法 最简单的SORT使用方法是SORT key。
			jedis.lpush("sort", "1");
			jedis.lpush("sort", "4");
			jedis.lpush("sort", "6");
			jedis.lpush("sort", "3");
			jedis.lpush("sort", "0");
			
			List list = jedis.sort("sort"); //默认是升序
			for(int i=0;i<list.size();i++){
				System.out.println(list.get(i));
			}

			
			//----------- STRING------------------// 
			//SET key value将字符串值value关联到key。
			jedis.set("name", "yixiaohan");
			jedis.set("id", "007");
			jedis.set("address", "beijing");
			
			//SETEX key seconds value将值value关联到key，并将key的生存时间设为seconds(以秒为单位)。
			jedis.setex("foo", 5, "haha");
			
			//MSET key value [key value ...]同时设置一个或多个key-value对。
			jedis.mset("kevin","111","keso","222");
			 
			//redis.flushAll();清空所有的key
			System.out.println("dbSize ==>" + jedis.dbSize());//dbSize是多少个key的个数
			
			//APPEND key value如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。
			System.out.println("append before==>" + jedis.get("foo"));
			jedis.append("foo", "00");//如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。
			System.out.println("append after==>" + jedis.get("foo"));
			
			//GET key 返回key所关联的字符串值
			String getResult = jedis.get("name");
			System.out.println("getResult==>" + getResult);
			
			//MGET key [key ...] 返回所有(一个或多个)给定key的值, 如果key不存在,则返回null
			List getList = jedis.mget("address","name", "myboss");
			for(int i=0; i<getList.size(); i++){
				System.out.println(getList.get(i));
			}
			
			
			//DECR key 将key中储存的数字值减一。
			//DECRBY key decrement 将key所储存的值减去减量decrement。
			//INCR key 将key中储存的数字值增一。
			//INCRBY key increment 将key所储存的值加上增量increment。
			
			
			System.out.println("\n" + "==============Hash 操作(key field value)================");
			//HSET key field value将哈希表key中的域field的值设为value。
			jedis.hset("website", "google", "www.google.cn");
			jedis.hset("website", "baidu", "www.baidu.com");
			jedis.hset("website", "sina", "www.sina.com");
			
			
			//HMSET key field value [field value ...] 同时将多个field - value(域-值)对设置到哈希表key中。
			Map<String,String> map = new HashMap<String,String>();
			map.put("cardid", "123456");
			map.put("username", "yixiaohan");
			jedis.hmset("hash", map);
			
			//HGET key field返回哈希表key中给定域field所对应的值。
			System.out.println("哈希表key中给定域field所对应的值==>" + jedis.hget("hash", "username"));
			
			//HMGET key field [field ...]返回哈希表key中，一个或多个给定域的值。
			List hlist = jedis.hmget("website","google","baidu","sina");
			for(int i=0;i<hlist.size();i++){
				System.out.println("hmget()返回哈希表key中，一个或多个给定域的值==> " + hlist.get(i));
			}
			
			//HGETALL key返回哈希表key中，所有的域和值。
			Map<String,String> allmap = jedis.hgetAll("hash");
			for(Map.Entry entry: allmap.entrySet()) {
			     System.out.print(entry.getKey() + ":" + entry.getValue() + "\t");
			}
			
			//HDEL key field [field ...]删除哈希表key中的一个或多个指定域。
			//HLEN key 返回哈希表key中域的数量。
			//HEXISTS key field查看哈希表key中，给定域field是否存在。
			//HINCRBY key field increment为哈希表key中的域field的值加上增量increment。
			//HKEYS key返回哈希表key中的所有域。
			//HVALS key返回哈希表key中的所有值。
			
			
			System.out.println("\n" + "==================== LIST 操作 ====================="); 
			//LPUSH key value [value ...]将值value插入到列表key的表头。//LPUSH puts the new value at the start of the list
			jedis.lpush("mylist", "abc");
			jedis.lpush("mylist", "xzc");
			jedis.lpush("mylist", "erf");
			jedis.lpush("mylist", "bnh");
			
			//LRANGE key start stop返回列表key中指定区间内的元素，区间以偏移量start和stop指定。下标(index)参数start和stop都以0为底，
			//也就是说，以0表示列表的第一个元素，以1表示列表的第二个元素，以此类推。
			//你也可以使用负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，以此类推。
			List listy = jedis.lrange("mylist", 0, -1);//LRANGE mylist 0 -1  ==> 其中 -1 返回所有的值.
			for(int i=0;i<listy.size();i++){
				System.out.println(listy.get(i));
			}
			
			System.out.println("列表key的长度==>" + jedis.llen("mylist"));
			//LLEN key返回列表key的长度。
			//LREM key count value根据参数count的值，移除列表中与参数value相等的元素。
			
			
			System.out.println("\n" + "===========  SET 操作 =====================");
			//SADD key member [member ...]将member元素加入到集合key当中。
			jedis.sadd("testSet", "s1");
			jedis.sadd("testSet", "s2");
			jedis.sadd("testSet", "s3");
			jedis.sadd("testSet", "s4");
			jedis.sadd("testSet", "s5");
			
			//SREM key member移除集合中的member元素。
			jedis.srem("testSet", "s5");
			
			//SMEMBERS key返回集合key中的所有成员。
			Set set = jedis.smembers("testSet");
			Iterator ite=set.iterator() ;
			while(ite.hasNext()){
				Object obj1=ite.next();
				System.out.println(obj1);
			}
			
			//SISMEMBER key member判断member元素是否是集合key的成员。是（true），否则（false）
			boolean isInSet = jedis.sismember("testSet", "s4");
			System.out.println("sismember()判断member元素是否是集合key的成员==>" + isInSet);
			
			//SCARD key返回集合key的基数(集合中元素的数量)。
			//SMOVE source destination member将member元素从source集合移动到destination集合。
			 
			//SINTER key [key ...]返回一个集合的全部成员，该集合是所有给定集合的交集。
			//SINTERSTORE destination key [key ...]此命令等同于SINTER，但它将结果保存到destination集合，而不是简单地返回结果集
			//SUNION key [key ...]返回一个集合的全部成员，该集合是所有给定集合的并集。
			//SUNIONSTORE destination key [key ...]此命令等同于SUNION，但它将结果保存到destination集合，而不是简单地返回结果集。
			//SDIFF key [key ...]返回一个集合的全部成员，该集合是所有给定集合的差集 。
			//SDIFFSTORE destination key [key ...]此命令等同于SDIFF，但它将结果保存到destination集合，而不是简单地返回结果集。
			
		}
		
	}

Copier après la connexion

=====================================================================================

序列化:

Person.java

package com.jiangge.jrtest;

import java.io.Serializable;

@SuppressWarnings("serial")
public class Person implements Serializable {
    private int id;
    private String name;

    public Person() {
    }

    public Person(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

Copier après la connexion

PersonRedisSerializeTest.java

package com.jiangge.jrtest;

import redis.clients.jedis.Jedis;

public class PersonRedisSerializeTest {
    
    public static void main(String[] args) {
    	PersonRedisSerializeTest test = new PersonRedisSerializeTest();
    	test.setObject(); //序列化
    	test.getObject(); //反序列化
    	
	}

    /**
     * 序列化写对象, 将Person对象写入Redis中
     * 
     * 我们到命令行窗口中读取该对象，看看有没有写入成功：
     *    redis 127.0.0.1:6379> get person:100
     *    "\xac\xed\x00\x05sr\x00\x19com.jiangge.jrtest.Person\xfa\x13\xad$\x8e$\xfc\x80\x
     *    02\x00\x02I\x00\x02idL\x00\x04namet\x00\x12Ljava/lang/String;xp\x00\x00\x00dt\x0
     *    0\tyixiaohan"
     * 可以取到序列化之后的值。
     */
    public void setObject() {
    	Jedis jedis=new Jedis("localhost"); 
        jedis.set("person:100".getBytes(), SerializeUtil.serialize(new Person(100, "yixiaohan")));
        jedis.set("person:101".getBytes(), SerializeUtil.serialize(new Person(101, "xiaowei")));
    }
    
    
    /** 反序列化取对象 */
    public void getObject() {
    	Jedis jedis=new Jedis("localhost"); 
        byte[] data100= jedis.get(("person:100").getBytes());
        Person person100 = (Person) SerializeUtil.unserialize(data100);
        System.out.println(String.format("person:100->id=%s,name=%s", person100.getId(), person100.getName()));
        
        byte[] data101= jedis.get(("person:101").getBytes());
        Person person101 = (Person) SerializeUtil.unserialize(data101);
        System.out.println(String.format("person:101->id=%s,name=%s", person101.getId(), person101.getName()));
    }
    
    
}

Copier après la connexion

SerializeUtil.java

package com.jiangge.jrtest;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {
    /**
     * 序列化
     * @param object
     */
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {
        	e.printStackTrace();
        }
        return null;
    }

    /**
     * 反序列化
     * @param bytes
     */
    public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
        	e.printStackTrace();
        }
        return null;
    }
}

Copier après la connexion

启动 redis server:

执行序列化代码后,在 redis client中查看结果:

IDE控制台输出结果:

=====================================================================================

Redis: key-value NoSQL Database
SET server:name "fido"
GET server:name
SET connections 10
INCR connections => 11
INCR connections => 12
DEL connections
INCR connections => 1

DEL to delete a given key and associated value
SET-if-not-exists (called SETNX on Redis)
INCR to atomically increment a number stored at a given key

an atomic operation 原子操作
an atomic operation concepts
h multi-threaded environments
所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）

a key should only exist for a certain length of time. This is accomplished with the EXPIRE and TTL commands.
key 存活于指定的时间,时间到则销亡
You can test how long a key will exist for with the TTL command
TTL命令: key 还将存活多长时间返回给定key的剩余生存时间(time to live)(以秒为单位)

complex data structures
数据结构:
list列表:相关命令, RPUSH, LPUSH, LLEN, LRANGE, LPOP, RPOP
RPUSH puts the new value at the end of the list.结尾
RPUSH friends "Alice"

LPUSH puts the new value at the start of the list.开头
LPUSH friends "Sam"

LRANGE gives a subset of the list,给定范围内的值.其中 -1 返回所有的值.
LRANGE friends 0 -1 => ["Sam","Alice","Bob"]
LRANGE friends 0 1 => ["Sam","Alice"]
LRANGE friends 1 2 => ["Alice","Bob"]

LLEN returns the current length of the list.返回当前列表的长度
LLEN friends => 3

LPOP removes the first element from the list and returns it.删除并返回列表中第一个值
LPOP friends => "Sam"

RPOP removes the last element from the list and returns it.删除并返回列表中最后一个值
RPOP friends => "Bob"

Note that the list now only has one element:
LLEN friends => 1
LRANGE friends 0 -1 => ["Alice"]

set集合:相关命令: SADD, SREM, SISMEMBER, SMEMBERS, SUNION
SADD adds the given value to the set.添加
SADD superpowers "flight"
SADD superpowers "x-ray vision"
SADD superpowers "reflexes"

SREM removes the given value from the set.删除
SREM superpowers "reflexes"

SISMEMBER tests if the given value is in the set.查看是否在集合中,也即查看是否是集合的成员
SISMEMBER superpowers "flight" => true,1
SISMEMBER superpowers "reflexes" => false,0

SMEMBERS returns a list of all the members of this set.返回集合中所有的成员,以列表的形式返回.
SMEMBERS superpowers => ["flight","x-ray vision"]

SUNION combines two or more sets and returns the list of all elements.将多个集合合并
SADD birdpowers "pecking"
SADD birdpowers "flight"
SUNION superpowers birdpowers => ["flight","x-ray vision","pecking"]

the sorted set有序集合. It is similar to a regular set, but now each value has an associated score标记.
This score is used to sort the elements in the set.
ZADD hackers 1940 "Alan Kay"
ZADD hackers 1906 "Grace Hopper"
ZADD hackers 1953 "Richard Stallman"
ZADD hackers 1965 "Yukihiro Matsumoto"
ZADD hackers 1916 "Claude Shannon"
ZADD hackers 1969 "Linus Torvalds"
ZADD hackers 1957 "Sophie Wilson"
ZADD hackers 1912 "Alan Turing"

In these examples, the scores are years of birth and the values are the names of famous hackers.
ZRANGE hackers 2 4 => ["Claude Shannon", "Alan Kay","Richard Stallman"]