我的程式碼：

public class TestPing {
   // 連線本地的 Redis 服務
public static void main(String[] args) {
      Jedis jedis = new Jedis("127.0.0.1",6379);
System.out.println(jedis.ping());
}


}

public class TestApi {
   @Test
public  void keyTest() {
      Jedis jedis = new Jedis("127.0.0.1", 6379);
jedis.set("k1"
 
,"v1");
jedis.set("k2","v2");
jedis.set("k3","v3");
//key
Set<String> keys = jedis.keys("*");
      for (String key : keys) {
         System.out.println(key);
}
      //key是否存在
System.out.println("jedis.exists====>" + jedis.exists("k2"));
/*以秒為單位，返回給定 key 的剩餘生存時間(TTL, time to live)
      返回值：
      當 key 不存在時，返回 -2 。
 
      當 key 存在但沒有設定剩餘生存時間時，返回 -1 。
      否則，以秒為單位，返回 key 的剩餘生存時間。*/
System.out.println(jedis.ttl("k1"));
}

   @Test
public void stringTest() {
      Jedis jedis = new Jedis("127.0.0.1", 6379);
System.out.println(jedis.get("k1"));
jedis.set("k4", "k4_redis");
System.out.println("----------------------------------------"
 
);
jedis.mset("str1", "v1", "str2", "v2", "str3", "v3");
System.out.println(jedis.mget("str1", "str2", "str3"));
}

   @Test
public void listTest() {
      Jedis jedis = new Jedis("127.0.0.1", 6379);
jedis.lpush("mylist", "v1", "v2", "v3", "v4", "v5");
List<String> list = jedis.lrange("mylist", 0, -1);
      for (String element : list) {
         System.out.println(element);
}
   }

   @Test
public void setTest() {
      Jedis jedis = new Jedis("127.0.0.1", 6379);
jedis.sadd("orders", "jd001");
jedis.sadd("orders", "jd002");
jedis.sadd("orders", "jd003");
Set<String> set1 = jedis.smembers("orders");
      for (Iterator iterator = set1.iterator(); iterator.hasNext(); ) {
         String string = (String) iterator.next();
System.out.println(string);
}
      /*移除集合 key 中的一個或多個 member 元素，不存在的 member 元素會被忽略。
      當 key 不是集合型別，返回一個錯誤。*/
jedis.srem("orders", "jd002");
System.out.println(jedis.smembers("orders").size());
}
   @Test
public void hashTest() {
      Jedis jedis = new Jedis("127.0.0.1", 6379);
jedis.hset("hash1", "userName", "lisi");
System.out.println(jedis.hget("hash1", "userName"));
Map<String, String> map = new HashMap<String, String>();
map.put("telphone", "13811814763");
map.put("address", "atguigu");
map.put("email", "[email protected]");
jedis.hmset("hash2", map);
List<String> result = jedis.hmget("hash2", "telphone", "email");
      for (String element : result) {
         System.out.println(element);
}
   }
   @Test
public void zsetTest() {
      Jedis jedis = new Jedis("127.0.0.1", 6379);
jedis.zadd("zset01", 60d, "v1");
jedis.zadd("zset01", 70d, "v2");
jedis.zadd("zset01", 80d, "v3");
jedis.zadd("zset01", 90d, "v4");
Set<String> s1 = jedis.zrange("zset01", 0, -1);
      for (Iterator iterator = s1.iterator(); iterator.hasNext(); ) {
         String string = (String) iterator.next();
System.out.println(string);
}
   }
   @Test
public void multiTest() {
      Jedis jedis = new Jedis("127.0.0.1", 6379);
Transaction transaction = jedis.multi();//被當作一個命令進行執行
Response<String> response = transaction.get("serialNum");
transaction.set("serialNum", "s002");
response = transaction.get("serialNum");
transaction.lpush("list3", "a");
transaction.lpush("list3", "b");
transaction.lpush("list3", "c");
//執行該事物，提交
transaction.exec();
//放棄該事物，不提交
        //transaction.discard();
}
}

public class TestSlaveof {//主從複製，讀寫分離
public static void main(String[] args) throws InterruptedException {
      Jedis jedis_M = new Jedis("127.0.0.1", 6379);
Jedis jedis_S = new Jedis("127.0.0.1", 6380);
jedis_S.slaveof("127.0.0.1", 6379);
jedis_M.set("k6", "v6");
Thread.sleep(500);
System.out.println(jedis_S.get("k6"));
}
}

public class TestTransaction {
   public boolean transMethod() throws  Exception{
      Jedis jedis = new Jedis("127.0.0.1", 6379);
      int balance;// 可用餘額
int debt;// 欠額
int amtToSubtract = 10;// 實刷額度
jedis.watch("balance");
//jedis.set("balance","5");//此句不該出現，講課方便。模擬其他程式已經修改了該條目
Thread.sleep(7000); //休眠7秒
balance = Integer.parseInt(jedis.get("balance"));
      if (balance < amtToSubtract) {
         jedis.unwatch();
System.out.println("modify");
         return false;
} else {
         System.out.println("***********transaction");
Transaction transaction = jedis.multi();
transaction.decrBy("balance", amtToSubtract);
transaction.incrBy("debt", amtToSubtract);
transaction.exec();
balance = Integer.parseInt(jedis.get("balance"));
debt = Integer.parseInt(jedis.get("debt"));
System.out.println("*******" + balance);
System.out.println("*******" + debt);
         return true;
}
   }


   /**
    *    * 通俗點講，watch命令就是標記一個鍵，如果標記了一個鍵， 在提交事務前如果該鍵被別人修改過，那事務就會失敗，這種情況通常可以在程式中
    *    * 重新再嘗試一次。
    *    * 首先標記了鍵balance，然後檢查餘額是否足夠，不足就取消標記，並不做扣減； 足夠的話，就啟動事務進行更新操作，
    *    * 如果在此期間鍵balance被其它人修改， 那在提交事務（執行exec）時就會報錯， 程式中通常可以捕獲這類錯誤再重新執行一次，直到成功。
    *   
    */
public static void main(String[] args) throws Exception{
      TestTransaction test = new TestTransaction();
      boolean retValue = test.transMethod();
System.out.println("main retValue-------: " + retValue);
}
}

public class JedisPoolUtil {
   private static  volatile JedisPool jedisPool = null;//被volatile修飾的變數不會被本地執行緒快取，對該變數的讀寫都是直接操作共享記憶體。
private JedisPoolUtil() {
   }

   public static JedisPool getJedisPoolInstance() {
      if (null == jedisPool) {
         synchronized (JedisPoolUtil.class) {
            if (null == jedisPool) {
               JedisPoolConfig poolConfig = new JedisPoolConfig();
//poolConfig.setMaxActive(1000);
poolConfig.setMaxIdle(32);
//poolConfig.setMaxWait(100 * 1000);
poolConfig.setTestOnBorrow(true);
jedisPool =new JedisPool(poolConfig, "127.0.0.1");
}
         }
      }
      return jedisPool;
}

   public static void release(JedisPool jedisPool, Jedis jedis) {
      if (null != jedis) {
         jedisPool.returnResourceObject(jedis);
}
   }
}

public class TestPool {
   public static void main(String[] args) {
      JedisPool jedisPool = JedisPoolUtil.getJedisPoolInstance();
Jedis jedis = null;
      try {
         jedis = jedisPool.getResource();
jedis.set("k18", "v183");
System.out.println(jedis.get("k18"));
} catch (Exception e) {
         e.printStackTrace();
} finally {
         JedisPoolUtil.release(jedisPool, jedis);
}
   }
}

JedisPool的配置引數大部分是由JedisPoolConfig的對應項來賦值的。

maxActive：控制一個pool可分配多少個jedis例項，通過pool.getResource()來獲取；如果賦值為-1，則表示不限制；如果pool已經分配了maxActive個jedis例項，則此時pool的狀態為exhausted。
maxIdle：控制一個pool最多有多少個狀態為idle(空閒)的jedis例項；
whenExhaustedAction：表示當pool中的jedis例項都被allocated完時，pool要採取的操作；預設有三種。
 WHEN_EXHAUSTED_FAIL --> 表示無jedis例項時，直接丟擲NoSuchElementException；
 WHEN_EXHAUSTED_BLOCK --> 則表示阻塞住，或者達到maxWait時丟擲JedisConnectionException；
 WHEN_EXHAUSTED_GROW --> 則表示新建一個jedis例項，也就說設定的maxActive無用；
maxWait：表示當borrow一個jedis例項時，最大的等待時間，如果超過等待時間，則直接拋JedisConnectionException；
testOnBorrow：獲得一個jedis例項的時候是否檢查連線可用性（ping()）；如果為true，則得到的jedis例項均是可用的；


testOnReturn：return 一個jedis例項給pool時，是否檢查連線可用性（ping()）；


testWhileIdle：如果為true，表示有一個idle object evitor執行緒對idle object進行掃描，如果validate失敗，此object會被從pool中drop掉；這一項只有在timeBetweenEvictionRunsMillis大於0時才有意義；


timeBetweenEvictionRunsMillis：表示idle object evitor兩次掃描之間要sleep的毫秒數；


numTestsPerEvictionRun：表示idle object evitor每次掃描的最多的物件數；


minEvictableIdleTimeMillis：表示一個物件至少停留在idle狀態的最短時間，然後才能被idle object evitor掃描並驅逐；這一項只有在timeBetweenEvictionRunsMillis大於0時才有意義；


softMinEvictableIdleTimeMillis：在minEvictableIdleTimeMillis基礎上，加入了至少minIdle個物件已經在pool裡面了。如果為-1，evicted不會根據idle time驅逐任何物件。如果minEvictableIdleTimeMillis>0，則此項設定無意義，且只有在timeBetweenEvictionRunsMillis大於0時才有意義；


lifo：borrowObject返回物件時，是採用DEFAULT_LIFO（last in first out，即類似cache的最頻繁使用佇列），如果為False，則表示FIFO佇列；


==================================================================================================================
其中JedisPoolConfig對一些引數的預設設定如下：
testWhileIdle=true
minEvictableIdleTimeMills=60000
timeBetweenEvictionRunsMillis=30000
numTestsPerEvictionRun=-1