Redis的使用及Redis序列化

 Redis 是一个高性能的key-value数据库，数据缓存在内存中。包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。

 下面简单介绍redis如何使用：

package com.ixincheng;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.builder.ToStringBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.alibaba.fastjson.JSON;
import com.google.gson.JsonObject;
import com.ixincheng.common.utils.RedisUtils;
import com.ixincheng.modules.sys.entity.SysUserEntity;

import redis.clients.jedis.Jedis;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisUtils redisUtils;
    
    @Test
    public void contextLoads() {
        SysUserEntity user = new SysUserEntity();
        user.setEmail("123456@qq.com");
        redisUtils.set("user", user);

        System.out.println(ToStringBuilder.reflectionToString(redisUtils.get("user", SysUserEntity.class)));
    }
    
    
    public static void main(String[] args) {
    	//连接redis服务
		Jedis jedis = new Jedis("127.0.0.1", 6379);
		//简单的key-value 存储
		jedis.set("redis", "myredis");
		//之前已经设定了redis相应"myredis",此句运行便会使redis相应"myredisyourredis"
		jedis.append("redis", "yourredis");   
		jedis.append("content", "rabbit");
        System.out.println(jedis.get("redis"));
        //mset 是设置多个key-value值   參数（key1,value1,key2,value2,...,keyn,valuen）
        //mget 是获取多个key所相应的value值  參数（key1,key2,key3,...,keyn）  返回的是个list
        //命令 通过 mget name1 name2 name3
        jedis.mset("name1","yangw","name2","demon","name3","elena");
        System.out.println(jedis.mget("name1","name2","name3"));
        //map
        Map<String,String> user1 = new HashMap<String,String>(); 
        user1.put("name", "张三");
        user1.put("age","12");
        jedis.hmset("user1", user1);
        List<String> hmget = jedis.hmget("user1","name","age");
        //命令 通过 hmget user1 name age
        System.out.println(hmget);
        
        
        List<String> strList = new ArrayList<String>();
        strList.add("zhangsan");
        strList.add("wangwu");
        strList.add("lisi");
       
        byte[] serializeList = serializeList(strList);
        jedis.set("strList".getBytes(), serializeList);
        
        byte[] bs = jedis.get("strList".getBytes());
        
       List<String> unserializeList = (List<String>) unserializeList(bs);
       System.out.println(unserializeList);
        
        
	}
    
    
    /**
     * 单个序列化
     * @param object
     * @return
     */
    public static byte[] serialize(Object object) {
        if (object == null) {
            return null;
        }
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        byte[] bytes = null;
        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            bytes = baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(oos);
            close(baos);
        }
        return bytes;
    }

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

    /**
     * 序列化 list 集合
     * 
     * @param list
     * @return
     */
    public static byte[] serializeList(List<?> list) {
        if (list == null || list.size() == 0) {
            return null;
        }
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        byte[] bytes = null;
        try {
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            for (Object obj : list) {
                oos.writeObject(obj);
            }
            bytes = baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(oos);
            close(baos);
        }
        return bytes;
    }

    /**
     * 反序列化 list 集合
     * 
     * @param lb
     * @return
     */
    public static List<?> unserializeList(byte[] bytes) {
        if (bytes == null) {
            return null;
        }
        List<Object> list = new ArrayList<Object>();
        ByteArrayInputStream bais = null;
        ObjectInputStream ois = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ois = new ObjectInputStream(bais);
            while (bais.available() > 0) {
                Object obj = (Object) ois.readObject();
                if (obj == null) {
                    break;
                }
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(bais);
            close(ois);
        }
        return list;
    }

    /**
     * 关闭io流对象
     * 
     * @param closeable
     */
    public static void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}