package dao.redisUtil;

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

public class RedisConnectionPool {


    //Redis伺服器IP
private static String IP = "localhost";

    //Redis的埠號
private static int PORT = 6379;

    //訪問密碼
//    private static String AUTH = "admin";
 
    //可用連線例項的最大數目，預設值為8；
    //如果賦值為-1，則表示不限制；如果pool已經分配了maxActive個jedis例項，則此時pool的狀態為exhausted(耗盡)。
private static int MAX_ACTIVE = 1024;

    //控制一個pool最多有多少個狀態為idle(空閒的)的jedis例項，預設值也是8。
private static int MAX_IDLE = 200;

    //等待可用連線的最大時間，單位毫秒，預設值為-1，表示永不超時。如果超過等待時間，則直接丟擲JedisConnectionException；
private static int 
 
MAX_WAIT = 10000;

    private static int TIMEOUT = 10000;

    //在borrow一個jedis例項時，是否提前進行validate操作；如果為true，則得到的jedis例項均是可用的；
private static boolean TEST_ON_BORROW = true;

    private static JedisPool jedisPool = null;

    /**
     * 初始化Redis連線池
     */
static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxActive(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWait(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);

            jedisPool = new JedisPool(config, IP, PORT, TIMEOUT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 獲取Jedis例項
     * @return
*/
public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 釋放jedis資源
     * @param jedis
*/
public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }
}

package dao.redisUtil;

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

/**
 * @author Administrator
 * 序列化物件工具類
 */
public class SerializeUtil {
    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) {

        }
        return null;
    }

    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) {

        }
        return null;
    }
}

package dao.redisUtil;


import redis.clients.jedis.Jedis;

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

/**
 * 實現redis操作
 */
public class RedisOperation{
    //獲取redis操作例項
private Jedis jedis=RedisConnectionPool.getJedis();

    public String set(String key, HashMap<String,String> map) {
        return jedis.hmset(key,map);
    }

    public String set(byte[] key, HashMap<byte[], byte[]> map) {
        return jedis.hmset(key,map);
    }

    public String set(String key, List<String> list) {
        Long aLong=-1l;
        for (String value:list
             ) {
            aLong = jedis.lpush(key,value);
        }
        return aLong<=0?"error":"OK";
    }

    public String set(byte[] key, List<byte[]> list) {
        Long aLong=-1l;
        for (byte[] value:list
                ) {
            aLong=jedis.lpush(key,value);
        }
        return aLong<=0?"error":"OK";
    }

    public String set(String key, String value) {
        return jedis.set(key,value);
    }

    public String set(byte[] key, byte[] value) {
        return jedis.set(key, value);
    }

    public String set(String key, Set<String> set) {
        Long aLong=-1l;
        for (String value:set
             ) {
            aLong=jedis.sadd(key,value);
        }
        return aLong<=0?"error":"OK";
    }

    public String set(byte[] key, Set<byte[]> set) {
        Long aLong=-1l;
        for (byte[] value:set
                ) {
            aLong=jedis.sadd(key,value);
        }
        return aLong<=0?"error":"OK";
    }

    //redis寫入物件，用序列化物件的方式
public String set(String key, Object Obj) {
       return  jedis.set(key.getBytes(),SerializeUtil.serialize(Obj));
    }

    public Object get(String key) {
        Object object=null;
        //獲取value的型別
String type=jedis.type(key);
        //根據不同型別呼叫不同的獲取方法
if(type.toLowerCase().equals("map")){
            object=jedis.hgetAll(key);
        }else if(type.toLowerCase().equals("set")){
            object=jedis.smembers(key);
        }else if(type.toLowerCase().equals("list")){
            object=jedis.lrange(key,0,-1);
        }else if (type.toLowerCase().equals("string")){
            byte[] bytes=jedis.get(key.getBytes());
            object=SerializeUtil.unserialize(bytes);
            if(object==null){
                object=jedis.get(key);
            }
        }
        return object;
    }

    public Object get(byte[] key) {
        return null;
    }

    public Long delete(String key) {
        return jedis.del(key);
    }

    public String update(String key,Object value){
        //先刪除原有資料
Long along = jedis.del(key);
        if(along<0){
            return "error";
        }
        //再重新新增
if(value instanceof Map){
            set(key,(Map)value);
        }else if(value instanceof Set){
            set(key,(Set) value);
        }else if(value instanceof List){
            set(key,(List) value);
        }else if(value instanceof String){
            set(key,(String)value);
        }else {
            set(key,value);
        }
        return "OK";
    }
}