<dependency>
            <groupId>redis.client</groupId>
            <artifactId>jedis</artifactId>
            <version>2.2.1</version>
        </dependency>

jedis是redis在java端的客戶端操作，通過jedis我們可以對redis裡的快取資料進行增刪改查。

java連線linux上redis服務如果報錯：

原因：
1、linux沒有開放redis埠號；
2、reids相關許可權設定；
解決：
linux開發埠的方法：（埠6379）
1、暫時開啟某埠號方法：iptables -I INPUT -p tcp –dport 6379 -j ACCEPT
2、永久開啟某埠方法：
首先，用vim開啟防火牆配置檔案：
vim /etc/sysconfig/iptables
然後，在iptables檔案內容中加入如下內容:
-A RH-Firewall-1-INPUT -m state –state NEW -m tcp -p tcp –dport 6379 -j ACCEPT
最後，儲存配置檔案後，執行如下命令重啟防火牆:
service iptables restart
redis相關許可權配置方法：
在redis-conf檔案中修改配置成如下兩個配置
a、protected-mode no
b、bind localhost 或者 bind 127.0.0.1 註釋掉

jedis基本操作程式碼

package demo.test;

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

import org.junit.Before;
import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestRedis {
    private Jedis jedis;

    // before註解的方法，在執行test註解的方法之前會執行
 

    @Before
    public void setup() {
        // 連線redis伺服器
        jedis = new Jedis("192.168.83.60", 6379);
        System.out.println("Connection to server sucessfully");
        // 增加一個Key檢測是否連線成功
        // jedis.set("foo", "bar");
        // String value = jedis.get("foo");
        // System.out.println("foo-->"+value);
 

        // 檢視服務是否執行
        System.out.println("Server is running: " + jedis.ping());//輸出PONG則連線成功
        System.out.println("--------------------------------------------");
    }

    /**
     * jedis儲存字串
     */
    @Test
    public void testString() {
        // -----新增資料----------
        jedis.set("name", "xinxin");// 向key-->name中放入了value-->xinxin
        System.out.println(jedis.get("name"));// 執行結果：xinxin

        jedis.append("name", " is my lover"); // 拼接 。
                                                // 如果用redis命令輸入key對應的值是不能有空格的哦
        System.out.println(jedis.get("name"));

        jedis.del("name"); // 刪除某個鍵
        System.out.println(jedis.get("name"));
        // 設定多個鍵值對
        jedis.mset("name", "liuling", "age", "23", "qq", "476777XXX");
        jedis.incr("age"); // 進行加1操作
        System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-"
                + jedis.get("qq"));

        jedis.set("china", "這是個中文值");
        System.out.println(jedis.get("china"));
    }

    /**
     * jedis操作Map
     * 
     * jedis.hmset("user",map);//該方法將java中的map在redis中存成了hash型別的資料物件
     */
    @Test
    public void testMap() {
        // -----新增資料----------
        Map<String, String> map = new HashMap<String, String>();
        map.put("name", "xinxin");
        map.put("age", "22");
        map.put("qq", "123456");
        jedis.hmset("user", map);// hmset方法存入後，該user物件在redis裡面是一個hash型別的資料
        // 第一個引數是存入redis中map物件的key，後面跟的是放入map中的物件的key，後面的key可以跟多個，是可變引數
        List<String> rsmap = jedis.hmget("user", "name", "age", "qq");
        System.out.println(rsmap);

        // 刪除map中的某個鍵值
        jedis.hdel("user", "age");
        System.out.println(jedis.hmget("user", "age")); // 因為刪除了，所以返回的是null
        System.out.println(jedis.hlen("user")); // 返回key為user的鍵中存放的值的個數2
        System.out.println(jedis.exists("user"));// 是否存在key為user的記錄 返回true
        System.out.println(jedis.hkeys("user"));// 返回map物件中的所有key
        System.out.println(jedis.hvals("user"));// 返回map物件中的所有value

        Iterator<String> iter = jedis.hkeys("user").iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            System.out.println(key + ":" + jedis.hmget("user", key));
        }
    }

    /**
     * jedis操作List
     * 
     * jedis.lpush("java framework", "spring")：方法建立了名為java
     * framework的List集合（如果不存在），並添加了一個元素 該方法儲存的物件在redis裡也為List型別的集合
     */
    @Test
    public void testList() {
        // 刪除該list內容
        jedis.del("java framework");
        // 取出所有資料，jedis.lrange是按範圍取出，
        // 第一個是key，第二個是起始位置，第三個是結束位置，jedis.llen獲取長度 -1表示取得所有
        System.out.println("內容：" + jedis.lrange("java framework", 0, -1));
        // 先向key java framework中存放三條資料，在key對應list的頭部新增字串元素
        jedis.lpush("java framework", "spring");
        jedis.lpush("java framework", "struts");
        jedis.lpush("java framework", "hibernate");

        System.out.println(jedis.lrange("java framework", 0, -1));

        jedis.del("java framework");
        // 在key對應list的尾部部新增字串元素
        jedis.rpush("java framework", "spring");
        jedis.rpush("java framework", "struts");
        jedis.rpush("java framework", "hibernate");
        System.out.println(jedis.lrange("java framework", 0, -1));
    }

    /**
     * jedis操作Set
     * 
     * jedis.sadd("user1", "liuling")：建立一個set集合user1（如果不存在），並新增一個元素liuling
     * 該方法儲存的物件在redis裡也為Set集合
     */
    @Test
    public void testSet() {
        // 新增
        jedis.sadd("user1", "liuling");
        jedis.sadd("user1", "xinxin");
        jedis.sadd("user1", "ling");
        jedis.sadd("user1", "zhangxinxin");
        jedis.sadd("user1", "who");
        // 移除noname
        jedis.srem("user1", "who");
        System.out.println(jedis.smembers("user1"));// 獲取所有加入的value
        System.out.println(jedis.sismember("user1", "who"));// 判斷 who
                                                            // 是否是user集合的元素
        System.out.println(jedis.srandmember("user1"));
        System.out.println(jedis.scard("user1"));// 返回集合的元素個數

    }

    /**
     * jedis對key值的操作
     */
    @Test
    public void testKey() {
        Set keys = jedis.keys("*");// 列出所有的key，查詢特定的key如：redis.keys("foo")
        Iterator t1 = keys.iterator();
        while (t1.hasNext()) {
            Object obj1 = t1.next();
            System.out.println(obj1);
        }

        // DEL 移除給定的一個或多個key。如果key不存在，則忽略該命令。
        // redis.del("name");

        // TTL 返回給定key的剩餘生存時間(time to live)(以秒為單位)
        System.out.println(jedis.ttl("name"));

        // PERSIST key 移除給定key的生存時間。
        jedis.persist("name");

        // EXISTS 檢查給定key是否存在。
        jedis.exists("name");

        // MOVE key db
        // 將當前資料庫(預設為0)的key移動到給定的資料庫db當中。如果當前資料庫(源資料庫)和給定資料庫(目標資料庫)有相同名字的給定key，或者key不存在於當前資料庫，那麼MOVE沒有任何效果。
        jedis.move("name", 1);// 將name這個key，移動到資料庫1

        // RENAME key newkey
        // 將key改名為newkey。當key和newkey相同或者key不存在時，返回一個錯誤。當newkey已經存在時，RENAME命令將覆蓋舊值。
        jedis.rename("name", "foonew");

        // TYPE key 返回key所儲存的值的型別。
        System.out.println(jedis.type("name"));// none(key不存在),string(字串),list(列表),set(集合),zset(有序集),hash(雜湊表)

        // EXPIRE key seconds 為給定key設定生存時間。當key過期時，它會被自動刪除。
        jedis.expire("name", 5);// 5秒過期
    }


    /**
     * 測試Redis連線池
     * 
     * 測試這個方法的時候要把@Befor註釋掉，不執行setup方法
     */
    @Test
    public void testJedisPool() {
        jedis = JedisPoolTest.getJedis();
        jedis.set("kunle", "困了就去lol");
        System.out.println(jedis.get("kunle"));
        // jedis.quit();//關閉連線用方法quit
        JedisPoolTest.returnResource(jedis);
        jedis.set("kunle2", "aa");
        System.out.println(jedis.get("kunle2"));
    }

}

這裡面的方法很多，不必強記，這裡的方法名其實和redis裡面對應型別裡各自的命令操作是一樣的。具體參考




jedis連線池程式碼

package demo.test;

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

public class JedisPoolTest {
        //Redis伺服器IP
         private static String ADDR = "127.0.0.1";

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

         //可用連線例項的最大數目，預設值為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;

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

         private static JedisPool jedisPool = null;

         private static ThreadLocal<Jedis> jedisThreadLocal = new ThreadLocal<Jedis>();

         /**
          * 初始化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, ADDR, PORT);
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }

         /**
          * 獲取Jedis例項
          * @return
          */
         public static Jedis getJedis() {
             System.out.println("從連線池獲取jedis連線資源");
             Jedis jedis = jedisThreadLocal.get();
             if(jedis==null){
                 jedis = jedisPool.getResource();
                 jedisThreadLocal.set(jedis);
                 return jedis;
             }
             return jedis;
         }

         /**
          * 釋放jedis資源
          * @param jedis
          */
         public static void returnResource(final Jedis jedis) {
             System.out.println("jedis連線返回到連線池");
             if (jedis != null) {
                 jedisPool.returnResource(jedis);//該方法僅僅將資源返回到連線池了，但是暫時沒有斷開連線
                 jedisThreadLocal.set(null);
             }
         }

}