Redis+Jedis简单应用

一、jedis的简单应用

1、导入jar包(jedis-2.3.0.jar)

2、实例

 

Java代码  收藏代码
  1. package cn.tzz.redis.simple;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6. import java.util.Map;  
  7.   
  8. import org.junit.Before;  
  9. import org.junit.Test;  
  10.   
  11. import redis.clients.jedis.Jedis;  
  12.   
  13. public class RedisTest {  
  14.   
  15.     private Jedis jedis;  
  16.       
  17.     @Before  
  18.     public void initJedis(){  
  19.         jedis = new Jedis("127.0.0.1",6379);  
  20.     }  
  21.       
  22.     /**添加*/  
  23.     public void addValue(String key, String value){  
  24.         jedis.set(key, value);  
  25.     }  
  26.       
  27.     /**拼接*/  
  28.     public void append(String key, String value){  
  29.         jedis.append(key, value);  
  30.     }  
  31.       
  32.     /**设置多个键值对*/  
  33.     public void mset(){  
  34.         jedis.mset("name","t","age","26","qq","123456");  
  35.     }  
  36.       
  37.     /**根据key删除*/  
  38.     public void deleteValue(String key){  
  39.         jedis.del(key);  
  40.     }  
  41.     /**根据key获取Value*/  
  42.     public String getValue(String key){  
  43.         return jedis.get(key);  
  44.     }  
  45.     /**修改key*/  
  46.     public void renameKey(String oldkey, String newkey){  
  47.         jedis.rename(oldkey, newkey);  
  48.     }  
  49.       
  50.     @Test  
  51.     public void testAddValue(){  
  52.         String key = "key";  
  53.         addValue(key, "abc");  
  54.         String value = getValue(key);  
  55.         System.out.println(value);  
  56.     }  
  57.       
  58.     @Test  
  59.     public void testAppend(){  
  60.         String key = "key";  
  61.         testAddValue();  
  62.         append(key, "--ccc");  
  63.         String value = getValue(key);  
  64.         System.out.println(value);  
  65.     }  
  66.       
  67.     @Test  
  68.     public void testMset(){  
  69.         mset();  
  70.         System.out.println(getValue("name") + "-" + getValue("age") + "-" +getValue("qq"));  
  71.     }  
  72.       
  73.     @Test  
  74.     public void testDeleteValue(){  
  75.         String key = "key1";  
  76.         deleteValue(key);  
  77.         String value = getValue(key);  
  78.         System.out.println(value);  
  79.     }  
  80.     @Test  
  81.     public void testRenameKey(){  
  82.         String key = "key1";  
  83.         String newkey = "key2";  
  84.         addValue(key, "abc");  
  85.         renameKey(key, newkey);  
  86.         String value = getValue(newkey);  
  87.         System.out.println(value);  
  88.     }  
  89.       
  90.     /**Map*/  
  91.     @Test  
  92.     public void testMap() {  
  93.         Map<String, String> map = new HashMap<String, String>();  
  94.         map.put("name""tzz");  
  95.         map.put("age""26");  
  96.         map.put("qq""123456");  
  97.         jedis.hmset("user", map);  
  98.         // 取出user中的name,执行结果:[minxr]-->注意结果是一个泛型的List  
  99.         // 第一个参数是存入redis中map对象的key,后面跟的是放入map中的对象的key,后面的key可以跟多个,是可变参数  
  100.         List<String> rsmap = jedis.hmget("user""name""age""qq");  
  101.         System.out.println(rsmap);  
  102.   
  103.         // 删除map中的某个键值  
  104.         jedis.hdel("user""age");  
  105.         System.out.println(jedis.hmget("user""age")); // 因为删除了,所以返回的是null  
  106.         System.out.println(jedis.hlen("user")); // 返回key为user的键中存放的值的个数2  
  107.         System.out.println(jedis.exists("user"));// 是否存在key为user的记录 返回true  
  108.         System.out.println(jedis.hkeys("user"));// 返回map对象中的所有key  
  109.         System.out.println(jedis.hvals("user"));// 返回map对象中的所有value  
  110.   
  111.         Iterator<String> iter = jedis.hkeys("user").iterator();  
  112.         while (iter.hasNext()) {  
  113.             String key = iter.next();  
  114.             System.out.println(key + ":" + jedis.hmget("user", key));  
  115.         }  
  116.     }  
  117.       
  118.     /**操作List */  
  119.     @Test  
  120.     public void testList() {  
  121.         // 开始前,先移除所有的内容  
  122.         jedis.del("test-list");  
  123.         System.out.println(jedis.lrange("test-list"0, -1));  
  124.         jedis.lpush("test-list""1");  
  125.         jedis.lpush("test-list""22");  
  126.         jedis.lpush("test-list""333");  
  127.         // 再取出所有数据jedis.lrange是按范围取出,  
  128.         // 第一个是key,第二个是起始位置,第三个是结束位置,jedis.llen获取长度 -1表示取得所有  
  129.         System.out.println(jedis.lrange("test-list"0, -1));  
  130.   
  131.         jedis.del("test-list");  
  132.         jedis.rpush("test-list""1");  
  133.         jedis.rpush("test-list""22");  
  134.         jedis.rpush("test-list""333");  
  135.         System.out.println(jedis.lrange("test-list"0, -1));  
  136.     }  
  137.   
  138.     /**Set*/  
  139.     @Test  
  140.     public void testSet() {  
  141.         // 添加  
  142.         jedis.sadd("test-set""a","b");  
  143.         jedis.sadd("test-set""b");  
  144.         jedis.sadd("test-set""c");  
  145.         jedis.sadd("test-set""d");  
  146.         jedis.sadd("test-set""e");  
  147.         // 移除noname  
  148.         jedis.srem("test-set""who");  
  149.         System.out.println(jedis.smembers("test-set"));// 获取所有加入的value  
  150.         System.out.println(jedis.sismember("test-set""who"));// 判断 who  
  151.                                                             // 是否是user集合的元素  
  152.         System.out.println(jedis.srandmember("test-set"));  
  153.         System.out.println(jedis.scard("test-set"));// 返回集合的元素个数  
  154.     }  
  155.   
  156.     @Test  
  157.     public void test() throws InterruptedException {  
  158.         // jedis 排序  
  159.         // 注意,此处的rpush和lpush是List的操作。是一个双向链表(但从表现来看的)  
  160.         jedis.del("a");// 先清除数据,再加入数据进行测试  
  161.         jedis.rpush("a""1");  
  162.         jedis.lpush("a""6");  
  163.         jedis.lpush("a""3");  
  164.         jedis.lpush("a""9");  
  165.         System.out.println(jedis.lrange("a"0, -1));// [9, 3, 6, 1]  
  166.         System.out.println(jedis.sort("a")); // [1, 3, 6, 9] //输入排序后结果  
  167.         System.out.println(jedis.lrange("a"0, -1));  
  168.     }  
  169. }  

 二、Jedis的池化使用

 

1、导入jar包(jedis-2.3.0.jar + commons-pool2-2.0.jar)

2、配置文件(redis_config.properties)

 

Java代码  收藏代码
  1. #最大分配的对象数    
  2. redis.pool.maxActive=1024  
  3. #最大能够保持idel状态的对象数    
  4. redis.pool.maxIdle=200  
  5. #当池内没有返回对象时,最大等待时间    
  6. redis.pool.maxWait=1000  
  7. #当调用borrow Object方法时,是否进行有效性检查    
  8. redis.pool.testOnBorrow=true  
  9. #当调用return Object方法时,是否进行有效性检查    
  10. redis.pool.testOnReturn=true  
  11. #host  
  12. redis.host=127.0.0.1  
  13. redis.host2=10.118.71.104  
  14. #Port    
  15. redis.port=6379  

 3、实例

 

 

Java代码  收藏代码
  1. package cn.tzz.redis.simple;  
  2.   
  3. import java.util.ResourceBundle;  
  4.   
  5. import org.junit.Before;  
  6. import org.junit.Test;  
  7. import redis.clients.jedis.Jedis;  
  8. import redis.clients.jedis.JedisPool;  
  9. import redis.clients.jedis.JedisPoolConfig;  
  10.   
  11. public class JedisPoolTest {  
  12.   
  13.     private static JedisPool jedisPool;  
  14.   
  15.     /** 初始化jedis连接池 */  
  16.     @Before  
  17.     public void initJedisPool() {  
  18.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();  
  19.         // 读取配置文件  
  20.         ResourceBundle bundle = ResourceBundle.getBundle("redis_config");  
  21.         jedisPoolConfig.setMaxTotal(Integer.parseInt(bundle  
  22.                 .getString("redis.pool.maxActive")));  
  23.         jedisPoolConfig.setMaxIdle(Integer.parseInt(bundle  
  24.                 .getString("redis.pool.maxIdle")));  
  25.         jedisPoolConfig.setMaxWaitMillis(Long.parseLong(bundle  
  26.                 .getString("redis.pool.maxWait")));  
  27.         jedisPoolConfig.setTestOnBorrow(Boolean.parseBoolean(bundle  
  28.                 .getString("redis.pool.testOnBorrow")));  
  29.         jedisPoolConfig.setTestOnReturn(Boolean.parseBoolean(bundle  
  30.                 .getString("redis.pool.testOnReturn")));  
  31.         String host = bundle.getString("redis.host");  
  32.         int port = Integer.valueOf(bundle.getString("redis.port"));  
  33.         int timeout = Integer.valueOf(bundle.getString("redis.pool.maxWait"));  
  34.         // 构造连接池  
  35.         jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);  
  36.     }  
  37.   
  38.     @Test  
  39.     public void testSet() {  
  40.         Jedis jedis = null;  
  41.         try {  
  42.             // 从连接池中获取jedis实例  
  43.             jedis = jedisPool.getResource();  
  44.             String key = "Test_Pool";  
  45.             jedis.del(key);  
  46.             jedis.set(key, "Test_Pool");  
  47.         } catch (Exception e) {  
  48.             // 销毁对象  
  49.             jedisPool.returnBrokenResource(jedis);  
  50.             e.printStackTrace();  
  51.         } finally {  
  52.             // 释放对象池  
  53.             jedisPool.returnResource(jedis);  
  54.         }  
  55.     }  
  56.   
  57.     @Test  
  58.     public void testGet() {  
  59.         Jedis jedis = null;  
  60.         try {  
  61.             jedis = jedisPool.getResource();  
  62.             System.out.println(jedis.get("Test_Pool"));  
  63.         } catch (Exception e) {  
  64.             // 销毁对象  
  65.             jedisPool.returnBrokenResource(jedis);  
  66.             e.printStackTrace();  
  67.         } finally {  
  68.             // 释放对象池  
  69.             jedisPool.returnResource(jedis);  
  70.         }  
  71.     }  
  72. }  

 

 

三、一致性哈希(集群)

Memcached完全基于分布式集群,而Redis是Master-Slave,如果想把Reids,做成集群模式,无外乎多做几套Master-Slave,每套Master-Slave完成各自的容灾处理,通过Client工具,完成一致性哈希。

 

Memcached是在Server端完成Sharding,Redis只能依靠各个Client做Sharding。

实例:

Java代码  收藏代码
  1. package cn.tzz.redis.simple;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.ResourceBundle;  
  6. import org.junit.Before;  
  7. import org.junit.Test;  
  8. import redis.clients.jedis.JedisPoolConfig;  
  9. import redis.clients.jedis.JedisShardInfo;  
  10. import redis.clients.jedis.ShardedJedis;  
  11. import redis.clients.jedis.ShardedJedisPool;  
  12.   
  13. public class JedisPoolTest2 {  
  14.   
  15.     private static ShardedJedisPool shardedJedisPool;  
  16.   
  17.     /** 初始化jedis连接池 */  
  18.     @Before  
  19.     public void initShardedJedisPool() {  
  20.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();  
  21.         // 读取配置文件  
  22.         ResourceBundle bundle = ResourceBundle.getBundle("redis_config");  
  23.         jedisPoolConfig.setMaxTotal(Integer.parseInt(bundle  
  24.                 .getString("redis.pool.maxActive")));  
  25.         jedisPoolConfig.setMaxIdle(Integer.parseInt(bundle  
  26.                 .getString("redis.pool.maxIdle")));  
  27.         jedisPoolConfig.setMaxWaitMillis(Long.parseLong(bundle  
  28.                 .getString("redis.pool.maxWait")));  
  29.         jedisPoolConfig.setTestOnBorrow(Boolean.parseBoolean(bundle  
  30.                 .getString("redis.pool.testOnBorrow")));  
  31.         jedisPoolConfig.setTestOnReturn(Boolean.parseBoolean(bundle  
  32.                 .getString("redis.pool.testOnReturn")));  
  33.         String host = bundle.getString("redis.host");  
  34.         String host2 = bundle.getString("redis.host2");  
  35.         int port = Integer.valueOf(bundle.getString("redis.port"));  
  36.         int timeout = Integer.valueOf(bundle.getString("redis.pool.maxWait"));  
  37.         // 构造连接池  
  38.         JedisShardInfo jedisShardInfo1 = new JedisShardInfo(host, port, timeout);  
  39.         JedisShardInfo jedisShardInfo2 = new JedisShardInfo(host2, port,  
  40.                 timeout);  
  41.         List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();  
  42.         shards.add(jedisShardInfo1);  
  43.         shards.add(jedisShardInfo2);  
  44.         shardedJedisPool = new ShardedJedisPool(jedisPoolConfig, shards);  
  45.     }  
  46.   
  47.     @Test  
  48.     public void testSet() {  
  49.         ShardedJedis jedis = null;  
  50.         try {  
  51.             // 从连接池中获取jedis实例  
  52.             jedis = shardedJedisPool.getResource();  
  53.             String key = "Test_Pool";  
  54.             jedis.del(key);  
  55.             jedis.set(key, "Test_Pool");  
  56.         } catch (Exception e) {  
  57.             // 销毁对象  
  58.             shardedJedisPool.returnBrokenResource(jedis);  
  59.             e.printStackTrace();  
  60.         } finally {  
  61.             // 释放对象池  
  62.             shardedJedisPool.returnResource(jedis);  
  63.         }  
  64.     }  
  65.   
  66.     @Test  
  67.     public void testGet() {  
  68.         ShardedJedis jedis = null;  
  69.         try {  
  70.             jedis = shardedJedisPool.getResource();  
  71.             System.out.println(jedis.get("Test_Pool"));  
  72.         } catch (Exception e) {  
  73.             // 销毁对象  
  74.             shardedJedisPool.returnBrokenResource(jedis);  
  75.             e.printStackTrace();  
  76.         } finally {  
  77.             // 释放对象池  
  78.             shardedJedisPool.returnResource(jedis);  
  79.         }  
  80.     }  
  81. }  
展开阅读全文

没有更多推荐了,返回首页