redis儲存資料時都有key和value，key和value要麼是String型別的，要麼是byte[]型別的。在此都是講的String型別的，所用的jar主要有：

commons-pool-1.6.jar
jedis-2.1.0.jar

1.儲存資料之String

要把一個String儲存到redis中，用set(key,value)，獲取值用get(key)

2.儲存資料之List

要把一個List儲存到redis中，遍歷List<String>，逐個呼叫lpush(key,value)，獲取值用lrange(key,start,end)，start代表開始位置，end代表結束位置，如果為-1則代表到未尾。

這裡lpush的意思是從左邊儲存，也就是後來居上。

3.儲存資料之Set

要把一個Set儲存到redis中，遍歷Set<String>，逐個呼叫sadd(key,value)，獲取值用smembers(key)

4.保豐資料之SortedSet

SortedSet的意思是他的每一個元素是有順序的，順序根據其score來決定，如果socre一樣，則按value排序。儲存到redis的方法是，對每一個要儲存的元素，

呼叫zadd(key,score,value)，獲取值用zrange(key,satrt,end)，start代表開始位置，end代表結束位置，如果為-1則代表到未尾。

5.儲存資料之Hash

要把一個Hash儲存到redis中，遍歷Map<String,String>，逐個呼叫hset(key,hashKey,hashValue)，獲取所有值有hgetAll(key)

下面來說說怎麼儲存物件到redis中，我們知道，redis支援的value要麼是String型別，要麼是byte[]型別，那麼思路就是把我們想要儲存的物件序列化成String型別或byte[]型別，然後儲存之，取值時再反序列化成物件。

最後粘下我的測試程式碼：

package com.syz.jedis;

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

public class RedisClient {
    private static final int MAX_ACTIVE = 20;

    private static final int MAX_IDLE = 5;

    private static final int MAX_WAIT = 1000;

    private static final String HOST = "127.0.0.1";

    private static final int PORT = 6379;

    private static JedisPool jedisPool;

    private RedisClient() {
    }

    /**
     * 初始化非切片池
     */
    private static void initialPool() {
        // 池基本配置
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxActive(MAX_ACTIVE);
        config.setMaxIdle(MAX_IDLE);
        config.setMaxWait(MAX_WAIT);
        jedisPool = new JedisPool(config, HOST, PORT);
    }


    public static JedisPool getJedis() {
        if (jedisPool == null) {
            synchronized (RedisClient.class) {
                if (jedisPool == null) {
                    initialPool();
                }
            }
        }
        return jedisPool;
    }

}
 

package com.syz.jedis;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

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

public class RedisTest {
    public static void main(String[] args) {
        JedisPool jedisPool = RedisClient.getJedis();
        Jedis jedis = jedisPool.getResource();
        jedis.select(10);
        try {
            System.out.println("testString=================begin");
            testString(jedis);
            System.out.println("testString=================end");
            System.out.println("testList=================begin");
            testList(jedis);
            System.out.println("testList=================end");
            System.out.println("testSet=================begin");
            testSet(jedis);
            System.out.println("testSet=================end");
            System.out.println("testSortedSet=================begin");
            testSortedSet(jedis);
            System.out.println("testSortedSet=================end");
            System.out.println("testHash=================begin");
            testHash(jedis);
            System.out.println("testHash=================end");
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            jedisPool.returnResource(jedis);
        }
    }

    private static void testString(Jedis jedis) {
        String key = "test:string:a";
        // 為了保持多次測試結果一樣，每次開始時都刪除
        jedis.del(key);
        String value = "hello redis";
        jedis.set(key, value);
        String val = jedis.get(key);
        System.out.println(val);
        // 結果：hello redis
    }

    private static void testList(Jedis jedis) {
        String key = "test:list:a";
        // 為了保持多次測試結果一樣，每次開始時都刪除
        jedis.del(key);
        List<String> values = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            char c = (char) (65 + i);
            values.add(String.valueOf(c));
        }
        for (int i = 0; i < values.size(); i++) {
            jedis.lpush(key, values.get(i));
        }
        List<String> val = jedis.lrange(key, 0, -1);
        System.out.println(val);
        // 結果：[J, I, H, G, F, E, D, C, B, A]
    }

    private static void testSet(Jedis jedis) {
        String key = "test:set:a";
        // 為了保持多次測試結果一樣，每次開始時都刪除
        jedis.del(key);
        Set<String> values = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            char c = (char) (65 + i);
            values.add(String.valueOf(c));
        }
        Iterator<String> ite = values.iterator();
        while (ite.hasNext()) {
            String value = ite.next();
            jedis.sadd(key, value);
        }
        Set<String> val = jedis.smembers(key);
        System.out.println(val);
        // 結果：[D, E, F, G, A, B, C, H, I, J]
    }

    private static void testSortedSet(Jedis jedis) {
        String key = "test:sortedset:a";
        // 為了保持多次測試結果一樣，每次開始時都刪除
        jedis.del(key);
        String[] values = { "C", "B", "G", "D", "d" };
        jedis.zadd(key, 10, "E");
        for (int i = 0; i < values.length; i++) {
            jedis.zadd(key, i + 10, values[i]);
        }
        jedis.zadd(key, 10, "F");
        Set<String> val = jedis.zrange(key, 0, -1);
        System.out.println(val);
        // 結果：[C, E, F, B, G, D, d]
    }

    private static void testHash(Jedis jedis) {
        String key = "test:hash:a";
        // 為了保持多次測試結果一樣，每次開始時都刪除
        jedis.del(key);
        Map<String, String> values = new HashMap<>();
        for (int i = 0; i < 10; i++) {
            String s = String.valueOf((char) (i + 'A'));
            values.put(s, s + "_val");
        }
        Iterator<Entry<String, String>> ite = values.entrySet().iterator();
        while (ite.hasNext()) {
            Entry<String, String> entry = ite.next();
            String k = entry.getKey();
            String v = entry.getValue();
            jedis.hset(key, k, v);
        }
        Map<String, String> val = jedis.hgetAll(key);
        System.out.println(val);
        // 結果：{D=D_val, E=E_val, F=F_val, G=G_val, A=A_val, B=B_val, C=C_val,
        // H=H_val, I=I_val, J=J_val}
    }
}