Jedis 是 Redis 官方首选的 Java client开发包。

工作过程总结的一个演示样例。贴出来,例如以下:

  1. package com.wujintao.redis;
  2. import java.util.Date;
  3. import java.util.HashMap;
  4. import java.util.Iterator;
  5. import java.util.List;
  6. import java.util.Map;
  7. import java.util.Set;
  8. import org.junit.Test;
  9. import redis.clients.jedis.Jedis;
  10. import redis.clients.jedis.Pipeline;
  11. import redis.clients.jedis.SortingParams;
  12. import com.wujintao.redis.util.RedisUtil;
  13. public class TestCase {
  14. /**
  15. * 在不同的线程中使用同样的Jedis实例会发生奇怪的错误。

    可是创建太多的实现也不好由于这意味着会建立非常多sokcet连接。

  16. * 也会导致奇怪的发生错误。

    单一Jedis实例不是线程安全的。为了避免这些问题,能够使用JedisPool,

  17. * JedisPool是一个线程安全的网络连接池。

    能够用JedisPool创建一些可靠Jedis实例,能够从池中拿到Jedis的实例。

  18. * 这样的方式能够解决那些问题而且会实现高效的性能
  19. */
  20. public static void main(String[] args) {
  21. // ...when closing your application:
  22. RedisUtil.getPool().destroy();
  23. }
  24. public static void Hello() {
  25. Jedis jedis = RedisUtil.getJedis();
  26. try {
  27. // 向key-->name中放入了value-->minxr
  28. jedis.set("name", "minxr");
  29. String ss = jedis.get("name");
  30. System.out.println(ss);
  31. // 非常直观。类似map 将jintao append到已经有的value之后
  32. jedis.append("name", "jintao");
  33. ss = jedis.get("name");
  34. System.out.println(ss);
  35. // 2、直接覆盖原来的数据
  36. jedis.set("name", "jintao");
  37. System.out.println(jedis.get("jintao"));
  38. // 删除key相应的记录
  39. jedis.del("name");
  40. System.out.println(jedis.get("name"));// 运行结果:null
  41. /**
  42. * mset相当于 jedis.set("name","minxr"); jedis.set("jarorwar","aaa");
  43. */
  44. jedis.mset("name", "minxr", "jarorwar", "aaa");
  45. System.out.println(jedis.mget("name", "jarorwar"));
  46. } catch (Exception e) {
  47. e.printStackTrace();
  48. } finally {
  49. RedisUtil.getPool().returnResource(jedis);
  50. }
  51. }
  52. private void testKey() {
  53. Jedis jedis = RedisUtil.getJedis();
  54. System.out.println("=============key==========================");
  55. // 清空数据
  56. System.out.println(jedis.flushDB());
  57. System.out.println(jedis.echo("foo"));
  58. // 推断key否存在
  59. System.out.println(jedis.exists("foo"));
  60. jedis.set("key", "values");
  61. System.out.println(jedis.exists("key"));
  62. }
  63. public static void testString() {
  64. System.out.println("==String==");
  65. Jedis jedis = RedisUtil.getJedis();
  66. try {
  67. // String
  68. jedis.set("key", "Hello World!");
  69. String value = jedis.get("key");
  70. System.out.println(value);
  71. } catch (Exception e) {
  72. e.printStackTrace();
  73. } finally {
  74. RedisUtil.getPool().returnResource(jedis);
  75. }
  76. System.out.println("=============String==========================");
  77. // 清空数据
  78. System.out.println(jedis.flushDB());
  79. // 存储数据
  80. jedis.set("foo", "bar");
  81. System.out.println(jedis.get("foo"));
  82. // 若key不存在,则存储
  83. jedis.setnx("foo", "foo not exits");
  84. System.out.println(jedis.get("foo"));
  85. // 覆盖数据
  86. jedis.set("foo", "foo update");
  87. System.out.println(jedis.get("foo"));
  88. // 追加数据
  89. jedis.append("foo", " hello, world");
  90. System.out.println(jedis.get("foo"));
  91. // 设置key的有效期,并存储数据
  92. , "foo not exits");
  93. System.out.println(jedis.get("foo"));
  94. try {
  95. );
  96. } catch (InterruptedException e) {
  97. }
  98. System.out.println(jedis.get("foo"));
  99. // 获取并更改数据
  100. jedis.set("foo", "foo update");
  101. System.out.println(jedis.getSet("foo", "foo modify"));
  102. // 截取value的值
  103. , 3));
  104. System.out.println(jedis.mset("mset1", "mvalue1", "mset2", "mvalue2",
  105. "mset3", "mvalue3", "mset4", "mvalue4"));
  106. System.out.println(jedis.mget("mset1", "mset2", "mset3", "mset4"));
  107. System.out.println(jedis.del(new String[] { "foo", "foo1", "foo3" }));
  108. }
  109. public static void testList() {
  110. System.out.println("==List==");
  111. Jedis jedis = RedisUtil.getJedis();
  112. try {
  113. // 開始前,先移除全部的内容
  114. jedis.del("messages");
  115. jedis.rpush("messages", "Hello how are you?

    ");

  116. jedis.rpush("messages", "Fine thanks. I'm having fun with redis.");
  117. jedis.rpush("messages", "I should look into this NOSQL thing ASAP");
  118. // 再取出全部数据jedis.lrange是按范围取出。
  119. // 第一个是key。第二个是起始位置。第三个是结束位置。jedis.llen获取长度 -1表示取得全部
  120. , -1);
  121. System.out.println(values);
  122. } catch (Exception e) {
  123. e.printStackTrace();
  124. } finally {
  125. RedisUtil.getPool().returnResource(jedis);
  126. }
  127. // 清空数据
  128. System.out.println(jedis.flushDB());
  129. // 加入数据
  130. jedis.lpush("lists", "vector");
  131. jedis.lpush("lists", "ArrayList");
  132. jedis.lpush("lists", "LinkedList");
  133. // 数组长度
  134. System.out.println(jedis.llen("lists"));
  135. // 排序
  136. System.out.println(jedis.sort("lists"));
  137. // 字串
  138. , 3));
  139. // 改动列表中单个值
  140. , "hello list!");
  141. // 获取列表指定下标的值
  142. ));
  143. // 删除列表指定下标的值
  144. , "vector"));
  145. // 删除区间以外的数据
  146. , 1));
  147. // 列表出栈
  148. System.out.println(jedis.lpop("lists"));
  149. // 整个列表值
  150. , -1));
  151. }
  152. public static void testSet() {
  153. System.out.println("==Set==");
  154. Jedis jedis = RedisUtil.getJedis();
  155. try {
  156. jedis.sadd("myset", "1");
  157. jedis.sadd("myset", "2");
  158. jedis.sadd("myset", "3");
  159. jedis.sadd("myset", "4");
  160. Set<String> setValues = jedis.smembers("myset");
  161. System.out.println(setValues);
  162. // 移除noname
  163. jedis.srem("myset", "4");
  164. System.out.println(jedis.smembers("myset"));// 获取全部增加的value
  165. System.out.println(jedis.sismember("myset", "4"));// 推断 minxr
  166. // 是否是sname集合的元素
  167. System.out.println(jedis.scard("sname"));// 返回集合的元素个数
  168. } catch (Exception e) {
  169. e.printStackTrace();
  170. } finally {
  171. RedisUtil.getPool().returnResource(jedis);
  172. }
  173. // 清空数据
  174. System.out.println(jedis.flushDB());
  175. // 加入数据
  176. jedis.sadd("sets", "HashSet");
  177. jedis.sadd("sets", "SortedSet");
  178. jedis.sadd("sets", "TreeSet");
  179. // 推断value是否在列表中
  180. System.out.println(jedis.sismember("sets", "TreeSet"));
  181. ;
  182. // 整个列表值
  183. System.out.println(jedis.smembers("sets"));
  184. // 删除指定元素
  185. System.out.println(jedis.srem("sets", "SortedSet"));
  186. // 出栈
  187. System.out.println(jedis.spop("sets"));
  188. System.out.println(jedis.smembers("sets"));
  189. //
  190. jedis.sadd("sets1", "HashSet1");
  191. jedis.sadd("sets1", "SortedSet1");
  192. jedis.sadd("sets1", "TreeSet");
  193. jedis.sadd("sets2", "HashSet2");
  194. jedis.sadd("sets2", "SortedSet1");
  195. jedis.sadd("sets2", "TreeSet1");
  196. // 交集
  197. System.out.println(jedis.sinter("sets1", "sets2"));
  198. // 并集
  199. System.out.println(jedis.sunion("sets1", "sets2"));
  200. // 差集
  201. System.out.println(jedis.sdiff("sets1", "sets2"));
  202. }
  203. public static void sortedSet() {
  204. System.out.println("==SoretedSet==");
  205. Jedis jedis = RedisUtil.getJedis();
  206. try {
  207. , "Alan Kay");
  208. , "Richard Stallman");
  209. , "Yukihiro Matsumoto");
  210. , "Claude Shannon");
  211. , "Linus Torvalds");
  212. , "Alan Turing");
  213. , -1);
  214. System.out.println(setValues);
  215. , -1);
  216. System.out.println(setValues2);
  217. } catch (Exception e) {
  218. e.printStackTrace();
  219. } finally {
  220. RedisUtil.getPool().returnResource(jedis);
  221. }
  222. // 清空数据
  223. System.out.println(jedis.flushDB());
  224. // 加入数据
  225. jedis.zadd("zset", 10.1, "hello");
  226. jedis.zadd("zset", 10.0, ":");
  227. jedis.zadd("zset", 9.0, "zset");
  228. jedis.zadd("zset", 11.0, "zset!");
  229. // 元素个数
  230. System.out.println(jedis.zcard("zset"));
  231. // 元素下标
  232. System.out.println(jedis.zscore("zset", "zset"));
  233. // 集合子集
  234. , -1));
  235. // 删除元素
  236. System.out.println(jedis.zrem("zset", "zset!"));
  237. System.out.println(jedis.zcount("zset", 9.5, 10.5));
  238. // 整个集合值
  239. , -1));
  240. }
  241. public static void testHsh() {
  242. System.out.println("==Hash==");
  243. Jedis jedis = RedisUtil.getJedis();
  244. try {
  245. Map<String, String> pairs = new HashMap<String, String>();
  246. pairs.put("name", "Akshi");
  247. pairs.put("age", "2");
  248. pairs.put("sex", "Female");
  249. jedis.hmset("kid", pairs);
  250. List<String> name = jedis.hmget("kid", "name");// 结果是个泛型的LIST
  251. // jedis.hdel("kid","age"); //删除map中的某个键值
  252. System.out.println(jedis.hmget("kid", "pwd")); // 由于删除了,所以返回的是null
  253. System.out.println(jedis.hlen("kid")); // 返回key为user的键中存放的值的个数
  254. System.out.println(jedis.exists("kid"));// 是否存在key为user的记录
  255. System.out.println(jedis.hkeys("kid"));// 返回map对象中的全部key
  256. System.out.println(jedis.hvals("kid"));// 返回map对象中的全部value
  257. Iterator<String> iter = jedis.hkeys("kid").iterator();
  258. while (iter.hasNext()) {
  259. String key = iter.next();
  260. System.out.println(key + ":" + jedis.hmget("kid", key));
  261. }
  262. , -1);
  263. values = jedis.hmget("kid", new String[] { "name", "age", "sex" });
  264. System.out.println(values);
  265. , -1);
  266. setValues = jedis.hkeys("kid");
  267. System.out.println(setValues);
  268. values = jedis.hvals("kid");
  269. System.out.println(values);
  270. pairs = jedis.hgetAll("kid");
  271. System.out.println(pairs);
  272. } catch (Exception e) {
  273. e.printStackTrace();
  274. } finally {
  275. RedisUtil.getPool().returnResource(jedis);
  276. }
  277. // 清空数据
  278. System.out.println(jedis.flushDB());
  279. // 加入数据
  280. jedis.hset("hashs", "entryKey", "entryValue");
  281. jedis.hset("hashs", "entryKey1", "entryValue1");
  282. jedis.hset("hashs", "entryKey2", "entryValue2");
  283. // 推断某个值是否存在
  284. System.out.println(jedis.hexists("hashs", "entryKey"));
  285. // 获取指定的值
  286. System.out.println(jedis.hget("hashs", "entryKey")); // 批量获取指定的值
  287. System.out.println(jedis.hmget("hashs", "entryKey", "entryKey1"));
  288. // 删除指定的值
  289. System.out.println(jedis.hdel("hashs", "entryKey"));
  290. // 为key中的域 field 的值加上增量 increment
  291. System.out.println(jedis.hincrBy("hashs", "entryKey", 123l));
  292. // 获取全部的keys
  293. System.out.println(jedis.hkeys("hashs"));
  294. // 获取全部的values
  295. System.out.println(jedis.hvals("hashs"));
  296. }
  297. public static void testOther() throws InterruptedException {
  298. Jedis jedis = RedisUtil.getJedis();
  299. try {
  300. // keys中传入的能够用通配符
  301. System.out.println(jedis.keys("*")); // 返回当前库中全部的key [sose, sanme,
  302. // name, jarorwar, foo,
  303. // sname, java framework,
  304. // user, braand]
  305. System.out.println(jedis.keys("*name"));// 返回的sname [sname, name]
  306. System.out.println(jedis.del("sanmdde"));// 删除key为sanmdde的对象 删除成功返回1
  307. // 删除失败(或者不存在)返回 0
  308. System.out.println(jedis.ttl("sname"));// 返回给定key的有效时间,假设是-1则表示永远有效
  309. , "min");// 通过此方法,能够指定key的存活(有效时间) 时间为秒
  310. );// 睡眠5秒后,剩余时间将为<=5
  311. System.out.println(jedis.ttl("timekey")); // 输出结果为5
  312. , "min"); // 设为1后,以下再看剩余时间就是1了
  313. System.out.println(jedis.ttl("timekey")); // 输出结果为1
  314. System.out.println(jedis.exists("key"));// 检查key是否存在
  315. System.out.println(jedis.rename("timekey", "time"));
  316. System.out.println(jedis.get("timekey"));// 由于移除,返回为null
  317. System.out.println(jedis.get("time")); // 由于将timekey 重命名为time
  318. // 所以能够取得值 min
  319. // jedis 排序
  320. // 注意,此处的rpush和lpush是List的操作。是一个双向链表(但从表现来看的)
  321. jedis.del("a");// 先清除数据。再增加数据进行測试
  322. jedis.rpush("a", "1");
  323. jedis.lpush("a", "6");
  324. jedis.lpush("a", "3");
  325. jedis.lpush("a", "9");
  326. , -1));// [9, 3, 6, 1]
  327. System.out.println(jedis.sort("a")); // [1, 3, 6, 9] //输入排序后结果
  328. , -1));
  329. } catch (Exception e) {
  330. e.printStackTrace();
  331. } finally {
  332. RedisUtil.getPool().returnResource(jedis);
  333. }
  334. }
  335. @org.junit.Test
  336. public void testUnUsePipeline() {
  337. long start = new Date().getTime();
  338. Jedis jedis = RedisUtil.getJedis();
  339. ; i < 10000; i++) {
  340. jedis.set("age1" + i, i + "");
  341. jedis.get("age1" + i);// 每一个操作都发送请求给redis-server
  342. }
  343. long end = new Date().getTime();
  344. System.out.println("unuse pipeline cost:" + (end - start) + "ms");
  345. RedisUtil.getPool().returnResource(jedis);
  346. }
  347. @org.junit.Test
  348. /**
  349. * 參考:http://blog.csdn.net/freebird_lb/article/details/7778919
  350. */
  351. public void testUsePipeline() {
  352. long start = new Date().getTime();
  353. Jedis jedis = RedisUtil.getJedis();
  354. jedis.flushDB();
  355. Pipeline p = jedis.pipelined();
  356. ; i < 10000; i++) {
  357. p.set("age2" + i, i + "");
  358. System.out.println(p.get("age2" + i));
  359. }
  360. p.sync();// 这段代码获取全部的response
  361. long end = new Date().getTime();
  362. System.out.println("use pipeline cost:" + (end - start) + "ms");
  363. RedisUtil.getPool().returnResource(jedis);
  364. }
  365. @org.junit.Test
  366. /**
  367. * 时间复杂度:
  368. O(N+M*log(M))。 N 为要排序的列表或集合内的元素数量, M 为要返回的元素数量。
  369. 假设仅仅是使用 SORT 命令的 GET 选项获取数据而没有进行排序,时间复杂度 O(N)。
  370. */
  371. public void testSort1() {
  372. // 排序默认以数字作为对象。值被解释为双精度浮点数,然后进行比較
  373. Jedis redis = RedisUtil.getJedis();
  374. // 一般SORT用法 最简单的SORT用法是SORT key。
  375. redis.lpush("mylist", "1");
  376. redis.lpush("mylist", "4");
  377. redis.lpush("mylist", "6");
  378. redis.lpush("mylist", "3");
  379. redis.lpush("mylist", "0");
  380. // List<String> list = redis.sort("sort");// 默认是升序
  381. SortingParams sortingParameters = new SortingParams();
  382. sortingParameters.desc();
  383. // sortingParameters.alpha();//当数据集中保存的是字符串值时,你能够用 ALPHA
  384. // 修饰符(modifier)进行排序。
  385. , 2);// 可用于分页查询
  386. List<String> list = redis.sort("mylist", sortingParameters);// 默认是升序
  387. ; i < list.size(); i++) {
  388. System.out.println(list.get(i));
  389. }
  390. redis.flushDB();
  391. RedisUtil.closeJedis(redis);
  392. }
  393. @org.junit.Test
  394. /**
  395. * sort list
  396. * LIST结合hash的排序
  397. */
  398. public void testSort2() {
  399. Jedis jedis = RedisUtil.getJedis();
  400. jedis.del("user:66", "user:55", "user:33", "user:22", "user:11",
  401. "userlist");
  402. jedis.lpush("userlist", "33");
  403. jedis.lpush("userlist", "22");
  404. jedis.lpush("userlist", "55");
  405. jedis.lpush("userlist", "11");
  406. jedis.hset("user:66", "name", "66");
  407. jedis.hset("user:55", "name", "55");
  408. jedis.hset("user:33", "name", "33");
  409. jedis.hset("user:22", "name", "79");
  410. jedis.hset("user:11", "name", "24");
  411. jedis.hset("user:11", "add", "beijing");
  412. jedis.hset("user:22", "add", "shanghai");
  413. jedis.hset("user:33", "add", "guangzhou");
  414. jedis.hset("user:55", "add", "chongqing");
  415. jedis.hset("user:66", "add", "xi'an");
  416. SortingParams sortingParameters = new SortingParams();
  417. // 符号 "->" 用于切割哈希表的键名(key name)和索引域(hash field)。格式为 "key->field" 。
  418. sortingParameters.get("user:*->name");
  419. sortingParameters.get("user:*->add");
  420. //      sortingParameters.by("user:*->name");
  421. //      sortingParameters.get("#");
  422. List<String> result = jedis.sort("userlist", sortingParameters);
  423. for (String item : result) {
  424. System.out.println("item...." + item);
  425. }
  426. /**
  427. * 相应的redisclient命令是:sort ml get user*->name sort ml get user:*->name get
  428. * user:*->add
  429. */
  430. }
  431. @org.junit.Test
  432. /**
  433. * sort set
  434. * SET结合String的排序
  435. */
  436. public void testSort3() {
  437. Jedis jedis = RedisUtil.getJedis();
  438. jedis.del("tom:friend:list", "score:uid:123", "score:uid:456",
  439. "score:uid:789", "score:uid:101", "uid:123", "uid:456",
  440. "uid:789", "uid:101");
  441. jedis.sadd("tom:friend:list", "123"); // tom的好友列表
  442. jedis.sadd("tom:friend:list", "456");
  443. jedis.sadd("tom:friend:list", "789");
  444. jedis.sadd("tom:friend:list", "101");
  445. jedis.set("score:uid:123", "1000"); // 好友相应的成绩
  446. jedis.set("score:uid:456", "6000");
  447. jedis.set("score:uid:789", "100");
  448. jedis.set("score:uid:101", "5999");
  449. jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的具体信息
  450. jedis.set("uid:456", "{'uid':456,'name':'jack'}");
  451. jedis.set("uid:789", "{'uid':789,'name':'jay'}");
  452. jedis.set("uid:101", "{'uid':101,'name':'jolin'}");
  453. SortingParams sortingParameters = new SortingParams();
  454. sortingParameters.desc();
  455. // sortingParameters.limit(0, 2);
  456. // 注意GET操作是有序的,GET user_name_* GET user_password_*
  457. // 和 GET user_password_* GET user_name_*返回的结果位置不同
  458. sortingParameters.get("#");// GET 另一个特殊的规则—— "GET #"
  459. // 。用于获取被排序对象(我们这里的样例是 user_id )的当前元素。

  460. sortingParameters.get("uid:*");
  461. sortingParameters.get("score:uid:*");
  462. sortingParameters.by("score:uid:*");
  463. // 相应的redis 命令是./redis-cli sort tom:friend:list by score:uid:* get # get
  464. // uid:* get score:uid:*
  465. List<String> result = jedis.sort("tom:friend:list", sortingParameters);
  466. for (String item : result) {
  467. System.out.println("item..." + item);
  468. }
  469. }
  470. /**
  471. *
  472. * 仅仅获取对象而不排序 BY 修饰符能够将一个不存在的 key 当作权重,让 SORT 跳过排序操作。

  473. * 该方法用于你希望获取外部对象而又不希望引起排序开销时使用。 # 确保fake_key不存在 redis> EXISTS fake_key
  474. * (integer) 0 # 以fake_key作BY參数。不排序,仅仅GET name 和 GET password redis> SORT
  475. * user_id BY fake_key GET # GET user_name_* GET user_password_* 1) "222" #
  476. * id 2) "hacker" # user_name 3) "hey,im in" # password 4) "59230" 5) "jack"
  477. * 6) "jack201022" 7) "2" 8) "huangz" 9) "nobodyknows" 10) "1" 11) "admin"
  478. * 12) "a_long_long_password"
  479. */
  480. public void testSort4() {
  481. }
  482. /**
  483. *
  484. 保存排序结果 默认情况下, SORT 操作仅仅是简单地返回排序结果,假设你希望保存排序结果,能够给 STORE 选项指定一个 key
  485. * 作为參数。排序结果将以列表的形式被保存到这个 key 上。(若指定 key 已存在,则覆盖。) redis> EXISTS
  486. * user_info_sorted_by_level # 确保指定key不存在 (integer) 0 redis> SORT user_id BY
  487. * user_level_* GET # GET user_name_* GET user_password_* STORE
  488. * user_info_sorted_by_level # 排序 (integer) 12 # 显示有12条结果被保存了 redis> LRANGE
  489. * user_info_sorted_by_level 0 11 # 查看排序结果 1) "59230" 2) "jack" 3)
  490. * "jack201022" 4) "2" 5) "huangz" 6) "nobodyknows" 7) "222" 8) "hacker" 9)
  491. * "hey,im in" 10) "1" 11) "admin" 12) "a_long_long_password" 一个有趣的使用方法是将 SORT
  492. * 结果保存。用 EXPIRE 为结果集设置生存时间。这样结果集就成了 SORT 操作的一个缓存。

    这样就不必频繁地调用 SORT

  493. * 操作了,仅仅有当结果集过期时,才须要再调用一次 SORT 操作。
  494. * 有时候为了正确实现这一使用方法。你可能须要加锁以避免多个client同一时候进行缓存重建(也就是多个client,同一时间进行 SORT
  495. * 操作,并保存为结果集),详细參见 SETNX 命令。
  496. */
  497. @Test
  498. public void testSort5() {
  499. // 排序默认以数字作为对象。值被解释为双精度浮点数。然后进行比較
  500. Jedis jedis = RedisUtil.getJedis();
  501. // 一般SORT用法 最简单的SORT用法是SORT key。
  502. jedis.lpush("mylist", "1");
  503. jedis.lpush("mylist", "4");
  504. jedis.lpush("mylist", "6");
  505. jedis.lpush("mylist", "3");
  506. jedis.lpush("mylist", "0");
  507. // List<String> list = redis.sort("sort");// 默认是升序
  508. SortingParams sortingParameters = new SortingParams();
  509. sortingParameters.desc();
  510. // sortingParameters.alpha();//当数据集中保存的是字符串值时,你能够用 ALPHA
  511. // 修饰符(modifier)进行排序。

  512. // sortingParameters.limit(0, 2);//可用于分页查询
  513. // 没有使用 STORE 參数。返回列表形式的排序结果. 使用 STORE 參数,返回排序结果的元素数量。

  514. jedis.sort("mylist", sortingParameters, "mylist");// 排序后指定排序结果到一个KEY中。这里讲结果覆盖原来的KEY
  515. , -1);
  516. ; i < list.size(); i++) {
  517. System.out.println(list.get(i));
  518. }
  519. jedis.sadd("tom:friend:list", "123"); // tom的好友列表
  520. jedis.sadd("tom:friend:list", "456");
  521. jedis.sadd("tom:friend:list", "789");
  522. jedis.sadd("tom:friend:list", "101");
  523. jedis.set("score:uid:123", "1000"); // 好友相应的成绩
  524. jedis.set("score:uid:456", "6000");
  525. jedis.set("score:uid:789", "100");
  526. jedis.set("score:uid:101", "5999");
  527. jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的具体信息
  528. jedis.set("uid:456", "{'uid':456,'name':'jack'}");
  529. jedis.set("uid:789", "{'uid':789,'name':'jay'}");
  530. jedis.set("uid:101", "{'uid':101,'name':'jolin'}");
  531. sortingParameters = new SortingParams();
  532. // sortingParameters.desc();
  533. sortingParameters.get("#");// GET 另一个特殊的规则—— "GET #"
  534. // ,用于获取被排序对象(我们这里的样例是 user_id )的当前元素。
  535. sortingParameters.by("score:uid:*");
  536. jedis.sort("tom:friend:list", sortingParameters, "tom:friend:list");
  537. , -1);
  538. for (String item : result) {
  539. System.out.println("item..." + item);
  540. }
  541. jedis.flushDB();
  542. RedisUtil.closeJedis(jedis);
  543. }
  544. public void testMore(){
  545. //ZRANGE取出最新的10个项目。

  546. //使用LPUSH + LTRIM。确保仅仅取出最新的1000条项目。
  547. //HINCRBY key field increment,为哈希表 key 中的域 field 的值加上增量 increment
  548. //INCRBY,HINCRBY等等。redis有了原子递增(atomic increment),你能够放心的加上各种计数。用GETSET重置,或者是让它们过期。

  549. // LREM greet 2 morning     # 移除从表头到表尾,最先发现的两个 morning,这个能够用来删除特定评论
  550. // zrevrank test a 查看a在sorted set中倒排序时排在第几名,查询结果依照INDEX,所以INDEX是3表示排在第四名
  551. // zrank test a 相反,表示正排序时候的名次
  552. // zscore test one表示one这个元素在sorted set中的score为多少
  553. // zrevrange test 0 -1 表示sorted set倒排序,zrange test 0 -1表示正排序
  554. //将一个或多个 member 元素及其 score 值增加到有序集 key 其中。假设某个 member 已经是有序集的成员,那么更新这个 member 的 score 值,并通过又一次插入这个 member 元素,来保证该 member 在正确的位置上。
  555. //zrem test one删除sorted set中某个元素
  556. }
  557. public List<String> get_latest_comments(int start, int num_items){
  558. //获取最新评论
  559. //LPUSH latest.comments <ID>
  560. //-我们将列表裁剪为指定长度,因此Redis仅仅须要保存最新的5000条评论:
  561. //LTRIM latest.comments 0 5000
  562. //们做了限制不能超过5000个ID。因此我们的获取ID函数会一直询问Redis。仅仅有在start/count參数超出了这个范围的时候。才须要去訪问数据库。
  563. Jedis jedis = RedisUtil.getJedis();
  564. ) ;
  565. if(id_list.size()<num_items){
  566. //id_list = SQL.EXECUTE("SELECT ... ORDER BY time LIMIT ...");
  567. }
  568. return id_list;
  569. }
  570. @Test
  571. public void testDB() {
  572. Jedis jedis = RedisUtil.getJedis();
  573. ));// select db-index
  574. // 通过索引选择数据库。默认连接的数据库全部是0,默认数据库数是16个。返回1表示成功。0失败
  575. System.out.println(jedis.dbSize());// dbsize 返回当前数据库的key数量
  576. System.out.println(jedis.keys("*")); // 返回匹配指定模式的全部key
  577. System.out.println(jedis.randomKey());
  578. jedis.flushDB();// 删除当前数据库中全部key,此方法不会失败。慎用
  579. jedis.flushAll();// 删除全部数据库中的全部key。此方法不会失败。更加慎用
  580. }
  581. @Test
  582. public void testMget() {
  583. Jedis jedis = RedisUtil.getJedis();
  584. jedis.flushDB();// 删除当前数据库中全部key,此方法不会失败。慎用
  585. jedis.rpush("ids", "aa");
  586. jedis.rpush("ids", "bb");
  587. jedis.rpush("ids", "cc");
  588. , -1);
  589. jedis.set("aa", "{'name':'zhoujie','age':20}");
  590. jedis.set("bb", "{'name':'yilin','age':28}");
  591. jedis.set("cc", "{'name':'lucy','age':21}");
  592. List<String> list = jedis.mget(ids.toArray(new String[ids.size()]));
  593. System.out.println(list);
  594. }
  595. /**
  596. * 能够利用lrange对list进行分页操作
  597. */
  598. @Test
  599. public void queryPageBy() {
  600. ;
  601. ;
  602. Jedis jedis = RedisUtil.getJedis();
  603. jedis.del("a");
  604. ; i <= 30; i++) {
  605. jedis.rpush("a", i + "");
  606. }
  607. );// 由于redis中list元素位置基数是0
  608. ;
  609. List<String> results = jedis.lrange("a", start, end);// 从start算起。start算一个元素,到结束那个元素
  610. for (String str : results) {
  611. System.out.println(str);
  612. }
  613. }
  614. @Test
  615. /**
  616. * [向Redis list压入ID而不是实际的数据]
  617. 在上面的样例里 ,我们将“对象”(此例中是简单消息)直接压入Redis list。但通常不应这么做,
  618. 因为对象可能被多次引用:比如在一个list中维护其时间顺序,在一个集合中保存它的类别,仅仅要有必要。它还会出如今其它list中,等等。
  619. 让我们回到reddit.com的样例,将用户提交的链接(新闻)加入到list中,有更可靠的方法例如以下所看到的:
  620. $ redis-cli incr next.news.id
  621. (integer) 1
  622. $ redis-cli set news:1:title "Redis is simple"
  623. OK
  624. $ redis-cli set news:1:url "http://code.google.com/p/redis"
  625. OK
  626. $ redis-cli lpush submitted.news 1
  627. OK
  628. 我们自增一个key,非常easy得到一个独一无二的自增ID,然后通过此ID创建对象–为对象的每一个字段设置一个key。最后将新对象的ID压入submitted.news list。
  629. 这仅仅是牛刀小试。在命令參考文档中能够读到全部和list有关的命令。你能够删除元素,旋转list,依据索引获取和设置元素,当然也能够用LLEN得到list的长度。
  630. */
  631. public void testListStrUsage() {
  632. String title = "太阳能是绿色能源4";
  633. String url = "http://javacreazyer.iteye.com";
  634. Jedis jedis = RedisUtil.getJedis();
  635. long adInfoId = jedis.incr("ad:adinfo:next.id");
  636. jedis.set("ad:adinfo:" + adInfoId + ":title", title);
  637. jedis.set("ad:adinfo:" + adInfoId + ":url", url);
  638. jedis.lpush("ad:adinfo", String.valueOf(adInfoId));
  639. String resultTitle = jedis.get("ad:adinfo:" + adInfoId + ":title");
  640. String resultUrl = jedis.get("ad:adinfo:" + adInfoId + ":url");
  641. , -1);
  642. System.out.println(resultTitle);
  643. System.out.println(resultUrl);
  644. System.out.println(ids);
  645. /**
  646. * dbsize返回的是全部key的数目,包含已经过期的, 而redis-cli keys "*"查询得到的是有效的key数目
  647. */
  648. System.out.println(jedis.dbSize());
  649. jedis.flushAll();
  650. }
  651. /**
  652. * 以下是一个简单的方案:对每一个想加标签的对象,用一个标签ID集合与之关联,而且对每一个已有的标签,一组对象ID与之关联。 比如如果我们的新闻ID
  653. * 1000被加了三个标签tag 1,2,5和77,就能够设置以下两个集合: $ redis-cli sadd news:1000:tags 1
  654. * (integer) 1 $ redis-cli sadd news:1000:tags 2 (integer) 1 $ redis-cli
  655. * sadd news:1000:tags 5 (integer) 1 $ redis-cli sadd news:1000:tags 77
  656. * (integer) 1 $ redis-cli sadd tag:1:objects 1000 (integer) 1 $ redis-cli
  657. * sadd tag:2:objects 1000 (integer) 1 $ redis-cli sadd tag:5:objects 1000
  658. * (integer) 1 $ redis-cli sadd tag:77:objects 1000 (integer) 1
  659. * 要获取一个对象的全部标签,如此简单: $ redis-cli smembers news:1000:tags 1. 5 2. 1 3. 77 4.
  660. * 2 而有些看上去并不简单的操作仍然能使用对应的Redis命令轻松实现。

    比如我们或许想获得一份同一时候拥有标签1, 2,

  661. * 10和27的对象列表。这能够用SINTER命令来做,他能够在不同集合之间取出交集。因此为达目的我们仅仅需: $ redis-cli sinter
  662. * tag:1:objects tag:2:objects tag:10:objects tag:27:objects ... no result
  663. * in our dataset composed of just one object ...
  664. * 在命令參考文档中能够找到和集合相关的其它命令,令人感兴趣的一抓一大把。一定要留意SORT命令,Redis集合和list都是可排序的。
  665. */
  666. @Test
  667. public void testSetUsage() {
  668. Jedis jedis = RedisUtil.getJedis();
  669. jedis.sadd("zhongsou:news:1000:tags", "1");
  670. jedis.sadd("zhongsou:news:1000:tags", "2");
  671. jedis.sadd("zhongsou:news:1000:tags", "5");
  672. jedis.sadd("zhongsou:news:1000:tags", "77");
  673. jedis.sadd("zhongsou:news:2000:tags", "1");
  674. jedis.sadd("zhongsou:news:2000:tags", "2");
  675. jedis.sadd("zhongsou:news:2000:tags", "5");
  676. jedis.sadd("zhongsou:news:2000:tags", "77");
  677. jedis.sadd("zhongsou:news:3000:tags", "2");
  678. jedis.sadd("zhongsou:news:4000:tags", "77");
  679. jedis.sadd("zhongsou:news:5000:tags", "1");
  680. jedis.sadd("zhongsou:news:6000:tags", "5");
  681. + "");
  682. + "");
  683. + "");
  684. + "");
  685. + "");
  686. + "");
  687. + "");
  688. + "");
  689. Set<String> sets = jedis.sinter("zhongsou:tag:1:objects",
  690. "zhongsou:tag:2:objects", "zhongsou:tag:5:objects",
  691. "zhongsou:tag:77:objects");
  692. System.out.println(sets);
  693. jedis.flushAll();
  694. }
  695. @Test
  696. public void testSortedSetUsage() {
  697. Jedis jedis = RedisUtil.getJedis();
  698. , "Alan Kay");
  699. , "Richard Stallman");
  700. , "Jay");
  701. , "Jellon");
  702. , "Yukihiro Matsumoto");
  703. , "Claude Shannon");
  704. , "Linus Torvalds");
  705. , "Alan Turing");
  706. , -1);
  707. System.out.println(hackers);
  708. , -1);
  709. System.out.println(hackers2);
  710. // 区间操作,我们请求Redis返回score介于负无穷到1920年之间的元素(两个极值也包括了)。
  711. Set<String> hackers3 = jedis.zrangeByScore("zhongsou:hackers", "-inf",
  712. "1920");
  713. System.out.println(hackers3);
  714. // ZREMRANGEBYSCORE 这个名字尽管不算好。但他却很实用,还会返回已删除的元素数量。
  715. long num = jedis.zremrangeByScore("zhongsou:hackers", "-inf", "1920");
  716. System.out.println(num);
  717. jedis.flushAll();
  718. }
  719. }
  1. /**
  2. * 获取连接池.
  3. * @return 连接池实例
  4. */
  5. private static JedisPool getPool(String ip,int port) {
  6. JedisPoolConfig config = new JedisPoolConfig();
  7. config.setMaxActive(RedisConfig.getMaxactive());
  8. config.setMaxIdle(RedisConfig.getMaxidle());
  9. config.setMaxWait(RedisConfig.getMaxwait());
  10. config.setTestOnBorrow(true);
  11. config.setTestOnReturn(true);
  12. try{
  13. /**
  14. *假设你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
  15. *请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
  16. */
  17. pool = new JedisPool(config, ip, port,RedisConfig.getTimeout());
  18. } catch(Exception e) {
  19. e.printStackTrace();
  20. }
  21. return pool;
  22. }

附加一个工作中经常使用到的Jedis工具类,例如以下:

  1. package com.zhongsou.vertportal.util;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import redis.clients.jedis.Jedis;
  7. import redis.clients.jedis.JedisPool;
  8. import redis.clients.jedis.JedisPoolConfig;
  9. import com.zhongsou.vertportal.conf.BaseConfig;
  10. import com.zhongsou.vertportal.conf.RedisConfig;
  11. /**
  12. * Redis工具类,用于获取RedisPool.
  13. * 參考官网说明例如以下:
  14. * You shouldn't use the same instance from different threads because you'll have strange errors.
  15. * And sometimes creating lots of Jedis instances is not good enough because it means lots of sockets and connections,
  16. * which leads to strange errors as well. A single Jedis instance is not threadsafe!
  17. * To avoid these problems, you should use JedisPool, which is a threadsafe pool of network connections.
  18. * This way you can overcome those strange errors and achieve great performance.
  19. * To use it, init a pool:
  20. *  JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
  21. *  You can store the pool somewhere statically, it is thread-safe.
  22. *  JedisPoolConfig includes a number of helpful Redis-specific connection pooling defaults.
  23. *  For example, Jedis with JedisPoolConfig will close a connection after 300 seconds if it has not been returned.
  24. * @author wujintao
  25. */
  26. public class JedisUtil  {
  27. protected Logger log = LoggerFactory.getLogger(getClass());
  28. /**
  29. * 私有构造器.
  30. */
  31. private JedisUtil() {
  32. }
  33. private static Map<String,JedisPool> maps  = new HashMap<String,JedisPool>();
  34. /**
  35. * 获取连接池.
  36. * @return 连接池实例
  37. */
  38. private static JedisPool getPool(String ip,int port) {
  39. String key = ip+":" +port;
  40. JedisPool pool = null;
  41. if(!maps.containsKey(key)) {
  42. JedisPoolConfig config = new JedisPoolConfig();
  43. config.setMaxActive(RedisConfig.getMaxactive());
  44. config.setMaxIdle(RedisConfig.getMaxidle());
  45. config.setMaxWait(RedisConfig.getMaxwait());
  46. config.setTestOnBorrow(true);
  47. config.setTestOnReturn(true);
  48. try{
  49. /**
  50. *假设你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
  51. *请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
  52. */
  53. pool = new JedisPool(config, ip, port,RedisConfig.getTimeout());
  54. maps.put(key, pool);
  55. } catch(Exception e) {
  56. e.printStackTrace();
  57. }
  58. }else{
  59. pool = maps.get(key);
  60. }
  61. return pool;
  62. }
  63. /**
  64. *类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例
  65. *没有绑定关系,并且仅仅有被调用到时才会装载,从而实现了延迟载入。
  66. */
  67. private static class RedisUtilHolder{
  68. /**
  69. * 静态初始化器,由JVM来保证线程安全
  70. */
  71. private static JedisUtil instance = new JedisUtil();
  72. }
  73. /**
  74. *当getInstance方法第一次被调用的时候,它第一次读取
  75. *RedisUtilHolder.instance,导致RedisUtilHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静
  76. *态域,从而创建RedisUtil的实例,因为是静态的域,因此仅仅会在虚拟机装载类的时候初始化一次。并由虚拟机来保证它的线程安全性。
  77. *这个模式的优势在于,getInstance方法并没有被同步,而且仅仅是运行一个域的訪问,因此延迟初始化并没有添加不论什么訪问成本。
  78. */
  79. public static JedisUtil getInstance() {
  80. return RedisUtilHolder.instance;
  81. }
  82. /**
  83. * 获取Redis实例.
  84. * @return Redis工具类实例
  85. */
  86. public Jedis getJedis(String ip,int port) {
  87. Jedis jedis  = null;
  88. ;
  89. do{
  90. try{
  91. jedis = getPool(ip,port).getResource();
  92. //log.info("get redis master1!");
  93. } catch (Exception e) {
  94. log.error("get redis master1 failed!", e);
  95. // 销毁对象
  96. getPool(ip,port).returnBrokenResource(jedis);
  97. }
  98. count++;
  99. }while(jedis==null&&count<BaseConfig.getRetryNum());
  100. return jedis;
  101. }
  102. /**
  103. * 释放redis实例到连接池.
  104. * @param jedis redis实例
  105. */
  106. public void closeJedis(Jedis jedis,String ip,int port) {
  107. if(jedis != null) {
  108. getPool(ip,port).returnResource(jedis);
  109. }
  110. }
  111. }

开发參考资料:

redis官方文档:http://redis.io/documentation

redis命令參考中文版:http://redis.readthedocs.org/en/2.4/index.html


Jedis学习使用(java操作redis)的更多相关文章

  1. Java操作Redis工具类

    依赖 jar 包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis< ...

  2. java操作redis之jedis篇

    首先来简单介绍一下jedis,其实一句话就可以概括的,就是java操作redis的一种api.我们知道redis提供了基本上所有常用编程语言的clients,大家可以到http://redis.io/ ...

  3. java操作redis学习(一):安装及连接

    文章参考自:http://www.cnblogs.com/edisonfeng/p/3571870.html,在此基础上进行了修改. 一.下载安装Redis redis官网显示暂时不支持Windows ...

  4. java 操作redis

    使用Java操作Redis需要jedis-2.1.0.jar,如果需要使用Redis连接池的话,还需commons-pool-1.5.4.jar package com.test; import ja ...

  5. windows下Redis安装及利用java操作Redis

    一.windows下Redis安装 1.Redis下载 下载地址:https://github.com/MicrosoftArchive/redis 打开下载地址后,选择版本 然后选择压缩包 下载 R ...

  6. java操作redis集群配置[可配置密码]和工具类(比较好用)

    转: java操作redis集群配置[可配置密码]和工具类 java操作redis集群配置[可配置密码]和工具类     <dependency>   <groupId>red ...

  7. java操作redis集群配置[可配置密码]和工具类

    java操作redis集群配置[可配置密码]和工具类     <dependency>   <groupId>redis.clients</groupId>   & ...

  8. Linux+Redis实战教程_day02_3、redis数据类型_4、String命令_5、hash命令_6、java操作redis数据库技术

    3. redis数据类型[重点] redis 使用的是键值对保存数据.(map) key:全部都是字符串 value:有五种数据类型 Key名:自定义,key名不要过长,否则影响使用效率 Key名不要 ...

  9. Java操作redis【二十】

    1.首先需要将redis的绑定地址为127.0.0.1去掉,同时将redis的保护模式去掉,并且开放6379端口. 如果是保护模式需要输入密码才能连接. (1)去掉绑定地址: (2)去掉保护模式: ( ...

  10. 使用Java操作Redis(一)

    Redis是一款基于key-value的数据库服务器,安装完成后我们可以通过redis-cli使用Redis提供的命令完成各种操作.redis-cli实际上就是一款客户端,和redis-server建 ...

随机推荐

  1. 717. 1-bit and 2-bit Characters@python

    We have two special characters. The first character can be represented by one bit 0. The second char ...

  2. SMTP error 554 !!

    哇,我真的amazing, incredible!! 我只是想写一个简单的邮件,结果他一直报554错误!!! 期间,通过百度,我发现了可能导致 此,讨厌至极的错误,有N多原因: 但我的原因 谜之离谱! ...

  3. POJ-2442-Sequence(二叉堆)

    POJ-2442 Description Given m sequences, each contains n non-negative integer. Now we may select one ...

  4. 用户管理命令--useradd

    用户管理命令--useradd 作用:用于添加一个新的用户 格式:useradd [ 选项 ] 用户名 选项的常用介绍 -u: UID指定用户id,必须是唯一的,并且大于499 -c: 添加注释,可以 ...

  5. Go:单元测试

    测试用的文件名必须以 _test.go 结尾: 测试用的函数名必须以 Test 开头,一般来说:Test+被测试的函数名(第一个字母必须大写): func TestXx(t *testing.T) { ...

  6. Java性能调优概述

    目录 Java性能调优概述 性能优化有风险和弊端,性能调优必须有明确的目标,不要为了调优而调优!!!盲目调优,风险远大于收益!!! 程序性能的主要表现点 执行速度:程序的反映是否迅速,响应时间是否足够 ...

  7. 07 mongodb

    mongodb mongodb简介 简介 MongoDB是一个基于分布式文件存储的数据库.由C++语言编写.旨在为Web应用提供可扩展的高性能数据存储解决方案.    MongoDB是一个介于关系数据 ...

  8. C#语言之字符串和正则表达式

    本文将完成以下两个目标: 一.创建字符串: 二.正则表达式: 首先,我先来介绍一下System.String类: System.String是一个类,专门用于存储字符串,允许对字符串进行许多操作. 使 ...

  9. ES6(Iterator 和 for...of 循环)

    Iterator 和 for...of 循环 1.什么是 Iterator 接口 Iterator 接口功能:用一种相同办法的接口让不同的数据结构得到统一的读取命令的方式 2.Iterator的基本用 ...

  10. 【Codeforces 1006D】Two Strings Swaps

    [链接] 我是链接,点我呀:) [题意] 题意 [题解] 注意只能改变a不能改变b 然后只要让a[i],b[i],a[n-i-1],b[n-i-1]这4个字符能凑成两对.全都一样就可以了 分类讨论下就 ...