最近了解了一下非关系型数据库 redis
会使用简单的命令 在自己本地电脑
使用时必须先启动服务器端 在启动客户端
redis 简介
Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。
基本介绍
redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)和zset(有序集合)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类keyvalue存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。[1]
java 实现的redis 工具类
1.加入jar包
2.代码
1 . package redis.utils; 2 2. 3 3. import java.util.List; 4 4. import java.util.Map; 5 5. import java.util.Set; 6 6. 7 7. //import org.apache.log4j.Logger; 8 8. 9 9. 10 10. import redis.clients.jedis.Jedis; 11 11. import redis.clients.jedis.JedisPool; 12 12. import redis.clients.jedis.JedisPoolConfig; 13 13. import redis.clients.jedis.SortingParams; 14 14. import redis.clients.jedis.BinaryClient.LIST_POSITION; 15 15. import redis.clients.util.SafeEncoder; 16 16. 17 17. /** 18 18. * @author Mr.hu 19 19. * @version crateTime：2013-10-30 下午5:41:30 20 20. * Class Explain:JedisUtil 21 21. */ 22 22. public class JedisUtil { 23 23. 24 24. //private Logger log = Logger.getLogger(this.getClass()); 25 25. /**缓存生存时间 */ 26 26. private final int expire = 60000; 27 27. /** 操作Key的方法 */ 28 28. public Keys KEYS; 29 29. /** 对存储结构为String类型的操作 */ 30 30. public Strings STRINGS; 31 31. /** 对存储结构为List类型的操作 */ 32 32. public Lists LISTS; 33 33. /** 对存储结构为Set类型的操作 */ 34 34. public Sets SETS; 35 35. /** 对存储结构为HashMap类型的操作 */ 36 36. public Hash HASH; 37 37. /** 对存储结构为Set(排序的)类型的操作 */ 38 38. public SortSet SORTSET; 39 39. private static JedisPool jedisPool = null; 40 40. 41 41. private JedisUtil() { 42 42. 43 43. } 44 44. static { 45 45. JedisPoolConfig config = new JedisPoolConfig(); 46 46. //控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取； 47 47. //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。 48 48. config.setMaxTotal(500); 49 49. //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。 50 50. config.setMaxIdle(5); 51 51. //表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException； 52 52. config.setMaxWaitMillis(1000 * 100); 53 53. //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的； 54 54. config.setTestOnBorrow(true); 55 55. 56 56. //redis如果设置了密码： 57 57. /*jedisPool = new JedisPool(config, JRedisPoolConfig.REDIS_IP, 58 58. JRedisPoolConfig.REDIS_PORT, 59 59. 10000,JRedisPoolConfig.REDIS_PASSWORD); */ 60 60. 61 61. //redis未设置了密码： 62 62. jedisPool = new JedisPool(config, "172.30.37.73",6379); 63 63. } 64 64. 65 65. public JedisPool getPool() { 66 66. return jedisPool; 67 67. } 68 68. 69 69. /** 70 70. * 从jedis连接池中获取获取jedis对象 71 71. * @return 72 72. */ 73 73. public Jedis getJedis() { 74 74. return jedisPool.getResource(); 75 75. } 76 76. 77 77. 78 78. private static final JedisUtil jedisUtil = new JedisUtil(); 79 79. 80 80. 81 81. /** 82 82. * 获取JedisUtil实例 83 83. * @return 84 84. */ 85 85. public static JedisUtil getInstance() { 86 86. return jedisUtil; 87 87. } 88 88. 89 89. /** 90 90. * 回收jedis(放到finally中) 91 91. * @param jedis 92 92. */ 93 93. public void returnJedis(Jedis jedis) { 94 94. if (null != jedis && null != jedisPool) { 95 95. jedisPool.returnResource(jedis); 96 96. } 97 97. } 98 98. 99 99. /** 100 100. * 销毁连接(放到catch中) 101 101. * @param pool 102 102. * @param jedis 103 103. */ 104 104. public static void returnBrokenResource(Jedis jedis) { 105 105. if (null != jedis && null != jedisPool) { 106 106. jedisPool.returnResource(jedis); 107 107. } 108 108. } 109 109. 110 110. 111 111. /** 112 112. * 设置过期时间 113 113. * @author ruan 2013-4-11 114 114. * @param key 115 115. * @param seconds 116 116. */ 117 117. public void expire(String key, int seconds) { 118 118. if (seconds <= 0) { 119 119. return; 120 120. } 121 121. Jedis jedis = getJedis(); 122 122. jedis.expire(key, seconds); 123 123. returnJedis(jedis); 124 124. } 125 125. 126 126. /** 127 127. * 设置默认过期时间 128 128. * @author ruan 2013-4-11 129 129. * @param key 130 130. */ 131 131. public void expire(String key) { 132 132. expire(key, expire); 133 133. } 134 134. 135 135. 136 136. //*******************************************Keys*******************************************// 137 137. public class Keys { 138 138. 139 139. /** 140 140. * 清空所有key 141 141. */ 142 142. public String flushAll() { 143 143. Jedis jedis = getJedis(); 144 144. String stata = jedis.flushAll(); 145 145. returnJedis(jedis); 146 146. return stata; 147 147. } 148 148. 149 149. /** 150 150. * 更改key 151 151. * @param String oldkey 152 152. * @param String newkey 153 153. * @return 状态码 154 154. * */ 155 155. public String rename(String oldkey, String newkey) { 156 156. return rename(SafeEncoder.encode(oldkey), 157 157. SafeEncoder.encode(newkey)); 158 158. } 159 159. 160 160. /** 161 161. * 更改key,仅当新key不存在时才执行 162 162. * @param String oldkey 163 163. * @param String newkey 164 164. * @return 状态码 165 165. * */ 166 166. public long renamenx(String oldkey, String newkey) { 167 167. Jedis jedis = getJedis(); 168 168. long status = jedis.renamenx(oldkey, newkey); 169 169. returnJedis(jedis); 170 170. return status; 171 171. } 172 172. 173 173. /** 174 174. * 更改key 175 175. * @param String oldkey 176 176. * @param String newkey 177 177. * @return 状态码 178 178. * */ 179 179. public String rename(byte[] oldkey, byte[] newkey) { 180 180. Jedis jedis = getJedis(); 181 181. String status = jedis.rename(oldkey, newkey); 182 182. returnJedis(jedis); 183 183. return status; 184 184. } 185 185. 186 186. /** 187 187. * 设置key的过期时间，以秒为单位 188 188. * @param String key 189 189. * @param 时间,已秒为单位 190 190. * @return 影响的记录数 191 191. * */ 192 192. public long expired(String key, int seconds) { 193 193. Jedis jedis = getJedis(); 194 194. long count = jedis.expire(key, seconds); 195 195. returnJedis(jedis); 196 196. return count; 197 197. } 198 198. 199 199. /** 200 200. * 设置key的过期时间,它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00，格里高利历）的偏移量。 201 201. * @param String key 202 202. * @param 时间,已秒为单位 203 203. * @return 影响的记录数 204 204. * */ 205 205. public long expireAt(String key, long timestamp) { 206 206. Jedis jedis = getJedis(); 207 207. long count = jedis.expireAt(key, timestamp); 208 208. returnJedis(jedis); 209 209. return count; 210 210. } 211 211. 212 212. /** 213 213. * 查询key的过期时间 214 214. * @param String key 215 215. * @return 以秒为单位的时间表示 216 216. * */ 217 217. public long ttl(String key) { 218 218. //ShardedJedis sjedis = getShardedJedis(); 219 219. Jedis sjedis=getJedis(); 220 220. long len = sjedis.ttl(key); 221 221. returnJedis(sjedis); 222 222. return len; 223 223. } 224 224. 225 225. /** 226 226. * 取消对key过期时间的设置 227 227. * @param key 228 228. * @return 影响的记录数 229 229. * */ 230 230. public long persist(String key) { 231 231. Jedis jedis = getJedis(); 232 232. long count = jedis.persist(key); 233 233. returnJedis(jedis); 234 234. return count; 235 235. } 236 236. 237 237. /** 238 238. * 删除keys对应的记录,可以是多个key 239 239. * @param String ... keys 240 240. * @return 删除的记录数 241 241. * */ 242 242. public long del(String... keys) { 243 243. Jedis jedis = getJedis(); 244 244. long count = jedis.del(keys); 245 245. returnJedis(jedis); 246 246. return count; 247 247. } 248 248. 249 249. /** 250 250. * 删除keys对应的记录,可以是多个key 251 251. * @param String .. keys 252 252. * @return 删除的记录数 253 253. * */ 254 254. public long del(byte[]... keys) { 255 255. Jedis jedis = getJedis(); 256 256. long count = jedis.del(keys); 257 257. returnJedis(jedis); 258 258. return count; 259 259. } 260 260. 261 261. /** 262 262. * 判断key是否存在 263 263. * @param String key 264 264. * @return boolean 265 265. * */ 266 266. public boolean exists(String key) { 267 267. //ShardedJedis sjedis = getShardedJedis(); 268 268. Jedis sjedis=getJedis(); 269 269. boolean exis = sjedis.exists(key); 270 270. returnJedis(sjedis); 271 271. return exis; 272 272. } 273 273. 274 274. /** 275 275. * 对List,Set,SortSet进行排序,如果集合数据较大应避免使用这个方法 276 276. * @param String key 277 277. * @return List<String> 集合的全部记录 278 278. * **/ 279 279. public List<String> sort(String key) { 280 280. //ShardedJedis sjedis = getShardedJedis(); 281 281. Jedis sjedis=getJedis(); 282 282. List<String> list = sjedis.sort(key); 283 283. returnJedis(sjedis); 284 284. return list; 285 285. } 286 286. 287 287. /** 288 288. * 对List,Set,SortSet进行排序或limit 289 289. * @param String key 290 290. * @param SortingParams parame 定义排序类型或limit的起止位置. 291 291. * @return List<String> 全部或部分记录 292 292. * **/ 293 293. public List<String> sort(String key, SortingParams parame) { 294 294. //ShardedJedis sjedis = getShardedJedis(); 295 295. Jedis sjedis=getJedis(); 296 296. List<String> list = sjedis.sort(key, parame); 297 297. returnJedis(sjedis); 298 298. return list; 299 299. } 300 300. 301 301. /** 302 302. * 返回指定key存储的类型 303 303. * @param String key 304 304. * @return String string|list|set|zset|hash 305 305. * **/ 306 306. public String type(String key) { 307 307. //ShardedJedis sjedis = getShardedJedis(); 308 308. Jedis sjedis=getJedis(); 309 309. String type = sjedis.type(key); 310 310. returnJedis(sjedis); 311 311. return type; 312 312. } 313 313. 314 314. /** 315 315. * 查找所有匹配给定的模式的键 316 316. * @param String key的表达式,*表示多个，？表示一个 317 317. * */ 318 318. public Set<String> keys(String pattern) { 319 319. Jedis jedis = getJedis(); 320 320. Set<String> set = jedis.keys(pattern); 321 321. returnJedis(jedis); 322 322. return set; 323 323. } 324 324. } 325 325. 326 326. //*******************************************Sets*******************************************// 327 327. public class Sets { 328 328. 329 329. /** 330 330. * 向Set添加一条记录，如果member已存在返回0,否则返回1 331 331. * @param String key 332 332. * @param String member 333 333. * @return 操作码,0或1 334 334. * */ 335 335. public long sadd(String key, String member) { 336 336. Jedis jedis = getJedis(); 337 337. long s = jedis.sadd(key, member); 338 338. returnJedis(jedis); 339 339. return s; 340 340. } 341 341. 342 342. public long sadd(byte[] key, byte[] member) { 343 343. Jedis jedis = getJedis(); 344 344. long s = jedis.sadd(key, member); 345 345. returnJedis(jedis); 346 346. return s; 347 347. } 348 348. 349 349. /** 350 350. * 获取给定key中元素个数 351 351. * @param String key 352 352. * @return 元素个数 353 353. * */ 354 354. public long scard(String key) { 355 355. //ShardedJedis sjedis = getShardedJedis(); 356 356. Jedis sjedis = getJedis(); 357 357. long len = sjedis.scard(key); 358 358. returnJedis(sjedis); 359 359. return len; 360 360. } 361 361. 362 362. /** 363 363. * 返回从第一组和所有的给定集合之间的差异的成员 364 364. * @param String ... keys 365 365. * @return 差异的成员集合 366 366. * */ 367 367. public Set<String> sdiff(String... keys) { 368 368. Jedis jedis = getJedis(); 369 369. Set<String> set = jedis.sdiff(keys); 370 370. returnJedis(jedis); 371 371. return set; 372 372. } 373 373. 374 374. /** 375 375. * 这个命令等于sdiff,但返回的不是结果集,而是将结果集存储在新的集合中，如果目标已存在，则覆盖。 376 376. * @param String newkey 新结果集的key 377 377. * @param String ... keys 比较的集合 378 378. * @return 新集合中的记录数 379 379. * **/ 380 380. public long sdiffstore(String newkey, String... keys) { 381 381. Jedis jedis = getJedis(); 382 382. long s = jedis.sdiffstore(newkey, keys); 383 383. returnJedis(jedis); 384 384. return s; 385 385. } 386 386. 387 387. /** 388 388. * 返回给定集合交集的成员,如果其中一个集合为不存在或为空，则返回空Set 389 389. * @param String ... keys 390 390. * @return 交集成员的集合 391 391. * **/ 392 392. public Set<String> sinter(String... keys) { 393 393. Jedis jedis = getJedis(); 394 394. Set<String> set = jedis.sinter(keys); 395 395. returnJedis(jedis); 396 396. return set; 397 397. } 398 398. 399 399. /** 400 400. * 这个命令等于sinter,但返回的不是结果集,而是将结果集存储在新的集合中，如果目标已存在，则覆盖。 401 401. * @param String newkey 新结果集的key 402 402. * @param String ... keys 比较的集合 403 403. * @return 新集合中的记录数 404 404. * **/ 405 405. public long sinterstore(String newkey, String... keys) { 406 406. Jedis jedis = getJedis(); 407 407. long s = jedis.sinterstore(newkey, keys); 408 408. returnJedis(jedis); 409 409. return s; 410 410. } 411 411. 412 412. /** 413 413. * 确定一个给定的值是否存在 414 414. * @param String key 415 415. * @param String member 要判断的值 416 416. * @return 存在返回1，不存在返回0 417 417. * **/ 418 418. public boolean sismember(String key, String member) { 419 419. //ShardedJedis sjedis = getShardedJedis(); 420 420. Jedis sjedis = getJedis(); 421 421. boolean s = sjedis.sismember(key, member); 422 422. returnJedis(sjedis); 423 423. return s; 424 424. } 425 425. 426 426. /** 427 427. * 返回集合中的所有成员 428 428. * @param String key 429 429. * @return 成员集合 430 430. * */ 431 431. public Set<String> smembers(String key) { 432 432. //ShardedJedis sjedis = getShardedJedis(); 433 433. Jedis sjedis = getJedis(); 434 434. Set<String> set = sjedis.smembers(key); 435 435. returnJedis(sjedis); 436 436. return set; 437 437. } 438 438. 439 439. public Set<byte[]> smembers(byte[] key) { 440 440. //ShardedJedis sjedis = getShardedJedis(); 441 441. Jedis sjedis = getJedis(); 442 442. Set<byte[]> set = sjedis.smembers(key); 443 443. returnJedis(sjedis); 444 444. return set; 445 445. } 446 446. 447 447. /** 448 448. * 将成员从源集合移出放入目标集合 <br/> 449 449. * 如果源集合不存在或不包哈指定成员，不进行任何操作，返回0<br/> 450 450. * 否则该成员从源集合上删除，并添加到目标集合，如果目标集合中成员已存在，则只在源集合进行删除 451 451. * @param String srckey 源集合 452 452. * @param String dstkey 目标集合 453 453. * @param String member 源集合中的成员 454 454. * @return 状态码，1成功，0失败 455 455. * */ 456 456. public long smove(String srckey, String dstkey, String member) { 457 457. Jedis jedis = getJedis(); 458 458. long s = jedis.smove(srckey, dstkey, member); 459 459. returnJedis(jedis); 460 460. return s; 461 461. } 462 462. 463 463. /** 464 464. * 从集合中删除成员 465 465. * @param String key 466 466. * @return 被删除的成员 467 467. * */ 468 468. public String spop(String key) { 469 469. Jedis jedis = getJedis(); 470 470. String s = jedis.spop(key); 471 471. returnJedis(jedis); 472 472. return s; 473 473. } 474 474. 475 475. /** 476 476. * 从集合中删除指定成员 477 477. * @param String key 478 478. * @param String member 要删除的成员 479 479. * @return 状态码，成功返回1，成员不存在返回0 480 480. * */ 481 481. public long srem(String key, String member) { 482 482. Jedis jedis = getJedis(); 483 483. long s = jedis.srem(key, member); 484 484. returnJedis(jedis); 485 485. return s; 486 486. } 487 487. 488 488. /** 489 489. * 合并多个集合并返回合并后的结果，合并后的结果集合并不保存<br/> 490 490. * @param String ... keys 491 491. * @return 合并后的结果集合 492 492. * @see sunionstore 493 493. * */ 494 494. public Set<String> sunion(String... keys) { 495 495. Jedis jedis = getJedis(); 496 496. Set<String> set = jedis.sunion(keys); 497 497. returnJedis(jedis); 498 498. return set; 499 499. } 500 500. 501 501. /** 502 502. * 合并多个集合并将合并后的结果集保存在指定的新集合中，如果新集合已经存在则覆盖 503 503. * @param String newkey 新集合的key 504 504. * @param String ... keys 要合并的集合 505 505. * **/ 506 506. public long sunionstore(String newkey, String... keys) { 507 507. Jedis jedis = getJedis(); 508 508. long s = jedis.sunionstore(newkey, keys); 509 509. returnJedis(jedis); 510 510. return s; 511 511. } 512 512. } 513 513. 514 514. //*******************************************SortSet*******************************************// 515 515. public class SortSet { 516 516. 517 517. /** 518 518. * 向集合中增加一条记录,如果这个值已存在，这个值对应的权重将被置为新的权重 519 519. * @param String key 520 520. * @param double score 权重 521 521. * @param String member 要加入的值， 522 522. * @return 状态码 1成功，0已存在member的值 523 523. * */ 524 524. public long zadd(String key, double score, String member) { 525 525. Jedis jedis = getJedis(); 526 526. long s = jedis.zadd(key, score, member); 527 527. returnJedis(jedis); 528 528. return s; 529 529. } 530 530. 531 531. /*public long zadd(String key, Map<Double, String> scoreMembers) { 532 532. Jedis jedis = getJedis(); 533 533. long s = jedis.zadd(key, scoreMembers); 534 534. returnJedis(jedis); 535 535. return s; 536 536. }*/ 537 537. 538 538. /** 539 539. * 获取集合中元素的数量 540 540. * @param String key 541 541. * @return 如果返回0则集合不存在 542 542. * */ 543 543. public long zcard(String key) { 544 544. //ShardedJedis sjedis = getShardedJedis(); 545 545. Jedis sjedis = getJedis(); 546 546. long len = sjedis.zcard(key); 547 547. returnJedis(sjedis); 548 548. return len; 549 549. } 550 550. 551 551. /** 552 552. * 获取指定权重区间内集合的数量 553 553. * @param String key 554 554. * @param double min 最小排序位置 555 555. * @param double max 最大排序位置 556 556. * */ 557 557. public long zcount(String key, double min, double max) { 558 558. //ShardedJedis sjedis = getShardedJedis(); 559 559. Jedis sjedis = getJedis(); 560 560. long len = sjedis.zcount(key, min, max); 561 561. returnJedis(sjedis); 562 562. return len; 563 563. } 564 564. 565 565. /** 566 566. * 获得set的长度 567 567. * 568 568. * @param key 569 569. * @return 570 570. */ 571 571. public long zlength(String key) { 572 572. long len = 0; 573 573. Set<String> set = zrange(key, 0, -1); 574 574. len = set.size(); 575 575. return len; 576 576. } 577 577. 578 578. /** 579 579. * 权重增加给定值，如果给定的member已存在 580 580. * @param String key 581 581. * @param double score 要增的权重 582 582. * @param String member 要插入的值 583 583. * @return 增后的权重 584 584. * */ 585 585. public double zincrby(String key, double score, String member) { 586 586. Jedis jedis = getJedis(); 587 587. double s = jedis.zincrby(key, score, member); 588 588. returnJedis(jedis); 589 589. return s; 590 590. } 591 591. 592 592. /** 593 593. * 返回指定位置的集合元素,0为第一个元素，-1为最后一个元素 594 594. * @param String key 595 595. * @param int start 开始位置(包含) 596 596. * @param int end 结束位置(包含) 597 597. * @return Set<String> 598 598. * */ 599 599. public Set<String> zrange(String key, int start, int end) { 600 600. //ShardedJedis sjedis = getShardedJedis(); 601 601. Jedis sjedis = getJedis(); 602 602. Set<String> set = sjedis.zrange(key, start, end); 603 603. returnJedis(sjedis); 604 604. return set; 605 605. } 606 606. 607 607. /** 608 608. * 返回指定权重区间的元素集合 609 609. * @param String key 610 610. * @param double min 上限权重 611 611. * @param double max 下限权重 612 612. * @return Set<String> 613 613. * */ 614 614. public Set<String> zrangeByScore(String key, double min, double max) { 615 615. //ShardedJedis sjedis = getShardedJedis(); 616 616. Jedis sjedis = getJedis(); 617 617. Set<String> set = sjedis.zrangeByScore(key, min, max); 618 618. returnJedis(sjedis); 619 619. return set; 620 620. } 621 621. 622 622. /** 623 623. * 获取指定值在集合中的位置，集合排序从低到高 624 624. * @see zrevrank 625 625. * @param String key 626 626. * @param String member 627 627. * @return long 位置 628 628. * */ 629 629. public long zrank(String key, String member) { 630 630. //ShardedJedis sjedis = getShardedJedis(); 631 631. Jedis sjedis = getJedis(); 632 632. long index = sjedis.zrank(key, member); 633 633. returnJedis(sjedis); 634 634. return index; 635 635. } 636 636. 637 637. /** 638 638. * 获取指定值在集合中的位置，集合排序从高到低 639 639. * @see zrank 640 640. * @param String key 641 641. * @param String member 642 642. * @return long 位置 643 643. * */ 644 644. public long zrevrank(String key, String member) { 645 645. //ShardedJedis sjedis = getShardedJedis(); 646 646. Jedis sjedis = getJedis(); 647 647. long index = sjedis.zrevrank(key, member); 648 648. returnJedis(sjedis); 649 649. return index; 650 650. } 651 651. 652 652. /** 653 653. * 从集合中删除成员 654 654. * @param String key 655 655. * @param String member 656 656. * @return 返回1成功 657 657. * */ 658 658. public long zrem(String key, String member) { 659 659. Jedis jedis = getJedis(); 660 660. long s = jedis.zrem(key, member); 661 661. returnJedis(jedis); 662 662. return s; 663 663. } 664 664. 665 665. /** 666 666. * 删除 667 667. * @param key 668 668. * @return 669 669. */ 670 670. public long zrem(String key) { 671 671. Jedis jedis = getJedis(); 672 672. long s = jedis.del(key); 673 673. returnJedis(jedis); 674 674. return s; 675 675. } 676 676. 677 677. /** 678 678. * 删除给定位置区间的元素 679 679. * @param String key 680 680. * @param int start 开始区间，从0开始(包含) 681 681. * @param int end 结束区间,-1为最后一个元素(包含) 682 682. * @return 删除的数量 683 683. * */ 684 684. public long zremrangeByRank(String key, int start, int end) { 685 685. Jedis jedis = getJedis(); 686 686. long s = jedis.zremrangeByRank(key, start, end); 687 687. returnJedis(jedis); 688 688. return s; 689 689. } 690 690. 691 691. /** 692 692. * 删除给定权重区间的元素 693 693. * @param String key 694 694. * @param double min 下限权重(包含) 695 695. * @param double max 上限权重(包含) 696 696. * @return 删除的数量 697 697. * */ 698 698. public long zremrangeByScore(String key, double min, double max) { 699 699. Jedis jedis = getJedis(); 700 700. long s = jedis.zremrangeByScore(key, min, max); 701 701. returnJedis(jedis); 702 702. return s; 703 703. } 704 704. 705 705. /** 706 706. * 获取给定区间的元素，原始按照权重由高到低排序 707 707. * @param String key 708 708. * @param int start 709 709. * @param int end 710 710. * @return Set<String> 711 711. * */ 712 712. public Set<String> zrevrange(String key, int start, int end) { 713 713. //ShardedJedis sjedis = getShardedJedis(); 714 714. Jedis sjedis = getJedis(); 715 715. Set<String> set = sjedis.zrevrange(key, start, end); 716 716. returnJedis(sjedis); 717 717. return set; 718 718. } 719 719. 720 720. /** 721 721. * 获取给定值在集合中的权重 722 722. * @param String key 723 723. * @param memeber 724 724. * @return double 权重 725 725. * */ 726 726. public double zscore(String key, String memebr) { 727 727. //ShardedJedis sjedis = getShardedJedis(); 728 728. Jedis sjedis = getJedis(); 729 729. Double score = sjedis.zscore(key, memebr); 730 730. returnJedis(sjedis); 731 731. if (score != null) 732 732. return score; 733 733. return 0; 734 734. } 735 735. } 736 736. 737 737. //*******************************************Hash*******************************************// 738 738. public class Hash { 739 739. 740 740. /** 741 741. * 从hash中删除指定的存储 742 742. * @param String key 743 743. * @param String fieid 存储的名字 744 744. * @return 状态码，1成功，0失败 745 745. * */ 746 746. public long hdel(String key, String fieid) { 747 747. Jedis jedis = getJedis(); 748 748. long s = jedis.hdel(key, fieid); 749 749. returnJedis(jedis); 750 750. return s; 751 751. } 752 752. 753 753. public long hdel(String key) { 754 754. Jedis jedis = getJedis(); 755 755. long s = jedis.del(key); 756 756. returnJedis(jedis); 757 757. return s; 758 758. } 759 759. 760 760. /** 761 761. * 测试hash中指定的存储是否存在 762 762. * @param String key 763 763. * @param String fieid 存储的名字 764 764. * @return 1存在，0不存在 765 765. * */ 766 766. public boolean hexists(String key, String fieid) { 767 767. //ShardedJedis sjedis = getShardedJedis(); 768 768. Jedis sjedis = getJedis(); 769 769. boolean s = sjedis.hexists(key, fieid); 770 770. returnJedis(sjedis); 771 771. return s; 772 772. } 773 773. 774 774. /** 775 775. * 返回hash中指定存储位置的值 776 776. * 777 777. * @param String key 778 778. * @param String fieid 存储的名字 779 779. * @return 存储对应的值 780 780. * */ 781 781. public String hget(String key, String fieid) { 782 782. //ShardedJedis sjedis = getShardedJedis(); 783 783. Jedis sjedis = getJedis(); 784 784. String s = sjedis.hget(key, fieid); 785 785. returnJedis(sjedis); 786 786. return s; 787 787. } 788 788. 789 789. public byte[] hget(byte[] key, byte[] fieid) { 790 790. //ShardedJedis sjedis = getShardedJedis(); 791 791. Jedis sjedis = getJedis(); 792 792. byte[] s = sjedis.hget(key, fieid); 793 793. returnJedis(sjedis); 794 794. return s; 795 795. } 796 796. 797 797. /** 798 798. * 以Map的形式返回hash中的存储和值 799 799. * @param String key 800 800. * @return Map<Strinig,String> 801 801. * */ 802 802. public Map<String, String> hgetAll(String key) { 803 803. //ShardedJedis sjedis = getShardedJedis(); 804 804. Jedis sjedis = getJedis(); 805 805. Map<String, String> map = sjedis.hgetAll(key); 806 806. returnJedis(sjedis); 807 807. return map; 808 808. } 809 809. 810 810. /** 811 811. * 添加一个对应关系 812 812. * @param String key 813 813. * @param String fieid 814 814. * @param String value 815 815. * @return 状态码 1成功，0失败，fieid已存在将更新，也返回0 816 816. * **/ 817 817. public long hset(String key, String fieid, String value) { 818 818. Jedis jedis = getJedis(); 819 819. long s = jedis.hset(key, fieid, value); 820 820. returnJedis(jedis); 821 821. return s; 822 822. } 823 823. 824 824. public long hset(String key, String fieid, byte[] value) { 825 825. Jedis jedis = getJedis(); 826 826. long s = jedis.hset(key.getBytes(), fieid.getBytes(), value); 827 827. returnJedis(jedis); 828 828. return s; 829 829. } 830 830. 831 831. /** 832 832. * 添加对应关系，只有在fieid不存在时才执行 833 833. * @param String key 834 834. * @param String fieid 835 835. * @param String value 836 836. * @return 状态码 1成功，0失败fieid已存 837 837. * **/ 838 838. public long hsetnx(String key, String fieid, String value) { 839 839. Jedis jedis = getJedis(); 840 840. long s = jedis.hsetnx(key, fieid, value); 841 841. returnJedis(jedis); 842 842. return s; 843 843. } 844 844. 845 845. /** 846 846. * 获取hash中value的集合 847 847. * 848 848. * @param String 849 849. * key 850 850. * @return List<String> 851 851. * */ 852 852. public List<String> hvals(String key) { 853 853. //ShardedJedis sjedis = getShardedJedis(); 854 854. Jedis sjedis = getJedis(); 855 855. List<String> list = sjedis.hvals(key); 856 856. returnJedis(sjedis); 857 857. return list; 858 858. } 859 859. 860 860. /** 861 861. * 在指定的存储位置加上指定的数字，存储位置的值必须可转为数字类型 862 862. * @param String key 863 863. * @param String fieid 存储位置 864 864. * @param String long value 要增加的值,可以是负数 865 865. * @return 增加指定数字后，存储位置的值 866 866. * */ 867 867. public long hincrby(String key, String fieid, long value) { 868 868. Jedis jedis = getJedis(); 869 869. long s = jedis.hincrBy(key, fieid, value); 870 870. returnJedis(jedis); 871 871. return s; 872 872. } 873 873. 874 874. /** 875 875. * 返回指定hash中的所有存储名字,类似Map中的keySet方法 876 876. * @param String key 877 877. * @return Set<String> 存储名称的集合 878 878. * */ 879 879. public Set<String> hkeys(String key) { 880 880. //ShardedJedis sjedis = getShardedJedis(); 881 881. Jedis sjedis = getJedis(); 882 882. Set<String> set = sjedis.hkeys(key); 883 883. returnJedis(sjedis); 884 884. return set; 885 885. } 886 886. 887 887. /** 888 888. * 获取hash中存储的个数，类似Map中size方法 889 889. * @param String key 890 890. * @return long 存储的个数 891 891. * */ 892 892. public long hlen(String key) { 893 893. //ShardedJedis sjedis = getShardedJedis(); 894 894. Jedis sjedis = getJedis(); 895 895. long len = sjedis.hlen(key); 896 896. returnJedis(sjedis); 897 897. return len; 898 898. } 899 899. 900 900. /** 901 901. * 根据多个key，获取对应的value，返回List,如果指定的key不存在,List对应位置为null 902 902. * @param String key 903 903. * @param String ... fieids 存储位置 904 904. * @return List<String> 905 905. * */ 906 906. public List<String> hmget(String key, String... fieids) { 907 907. //ShardedJedis sjedis = getShardedJedis(); 908 908. Jedis sjedis = getJedis(); 909 909. List<String> list = sjedis.hmget(key, fieids); 910 910. returnJedis(sjedis); 911 911. return list; 912 912. } 913 913. 914 914. public List<byte[]> hmget(byte[] key, byte[]... fieids) { 915 915. //ShardedJedis sjedis = getShardedJedis(); 916 916. Jedis sjedis = getJedis(); 917 917. List<byte[]> list = sjedis.hmget(key, fieids); 918 918. returnJedis(sjedis); 919 919. return list; 920 920. } 921 921. 922 922. /** 923 923. * 添加对应关系，如果对应关系已存在，则覆盖 924 924. * @param Strin key 925 925. * @param Map <String,String> 对应关系 926 926. * @return 状态，成功返回OK 927 927. * */ 928 928. public String hmset(String key, Map<String, String> map) { 929 929. Jedis jedis = getJedis(); 930 930. String s = jedis.hmset(key, map); 931 931. returnJedis(jedis); 932 932. return s; 933 933. } 934 934. 935 935. /** 936 936. * 添加对应关系，如果对应关系已存在，则覆盖 937 937. * @param Strin key 938 938. * @param Map <String,String> 对应关系 939 939. * @return 状态，成功返回OK 940 940. * */ 941 941. public String hmset(byte[] key, Map<byte[], byte[]> map) { 942 942. Jedis jedis = getJedis(); 943 943. String s = jedis.hmset(key, map); 944 944. returnJedis(jedis); 945 945. return s; 946 946. } 947 947. 948 948. } 949 949. 950 950. 951 951. //*******************************************Strings*******************************************// 952 952. public class Strings { 953 953. /** 954 954. * 根据key获取记录 955 955. * @param String key 956 956. * @return 值 957 957. * */ 958 958. public String get(String key) { 959 959. //ShardedJedis sjedis = getShardedJedis(); 960 960. Jedis sjedis = getJedis(); 961 961. String value = sjedis.get(key); 962 962. returnJedis(sjedis); 963 963. return value; 964 964. } 965 965. 966 966. /** 967 967. * 根据key获取记录 968 968. * @param byte[] key 969 969. * @return 值 970 970. * */ 971 971. public byte[] get(byte[] key) { 972 972. //ShardedJedis sjedis = getShardedJedis(); 973 973. Jedis sjedis = getJedis(); 974 974. byte[] value = sjedis.get(key); 975 975. returnJedis(sjedis); 976 976. return value; 977 977. } 978 978. 979 979. /** 980 980. * 添加有过期时间的记录 981 981. * 982 982. * @param String key 983 983. * @param int seconds 过期时间，以秒为单位 984 984. * @param String value 985 985. * @return String 操作状态 986 986. * */ 987 987. public String setEx(String key, int seconds, String value) { 988 988. Jedis jedis = getJedis(); 989 989. String str = jedis.setex(key, seconds, value); 990 990. returnJedis(jedis); 991 991. return str; 992 992. } 993 993. 994 994. /** 995 995. * 添加有过期时间的记录 996 996. * 997 997. * @param String key 998 998. * @param int seconds 过期时间，以秒为单位 999 999. * @param String value 1000 1000. * @return String 操作状态 1001 1001. * */ 1002 1002. public String setEx(byte[] key, int seconds, byte[] value) { 1003 1003. Jedis jedis = getJedis(); 1004 1004. String str = jedis.setex(key, seconds, value); 1005 1005. returnJedis(jedis); 1006 1006. return str; 1007 1007. } 1008 1008. 1009 1009. /** 1010 1010. * 添加一条记录，仅当给定的key不存在时才插入 1011 1011. * @param String key 1012 1012. * @param String value 1013 1013. * @return long 状态码，1插入成功且key不存在，0未插入，key存在 1014 1014. * */ 1015 1015. public long setnx(String key, String value) { 1016 1016. Jedis jedis = getJedis(); 1017 1017. long str = jedis.setnx(key, value); 1018 1018. returnJedis(jedis); 1019 1019. return str; 1020 1020. } 1021 1021. 1022 1022. /** 1023 1023. * 添加记录,如果记录已存在将覆盖原有的value 1024 1024. * @param String key 1025 1025. * @param String value 1026 1026. * @return 状态码 1027 1027. * */ 1028 1028. public String set(String key, String value) { 1029 1029. return set(SafeEncoder.encode(key), SafeEncoder.encode(value)); 1030 1030. } 1031 1031. 1032 1032. /** 1033 1033. * 添加记录,如果记录已存在将覆盖原有的value 1034 1034. * @param String key 1035 1035. * @param String value 1036 1036. * @return 状态码 1037 1037. * */ 1038 1038. public String set(String key, byte[] value) { 1039 1039. return set(SafeEncoder.encode(key), value); 1040 1040. } 1041 1041. 1042 1042. /** 1043 1043. * 添加记录,如果记录已存在将覆盖原有的value 1044 1044. * @param byte[] key 1045 1045. * @param byte[] value 1046 1046. * @return 状态码 1047 1047. * */ 1048 1048. public String set(byte[] key, byte[] value) { 1049 1049. Jedis jedis = getJedis(); 1050 1050. String status = jedis.set(key, value); 1051 1051. returnJedis(jedis); 1052 1052. return status; 1053 1053. } 1054 1054. 1055 1055. /** 1056 1056. * 从指定位置开始插入数据，插入的数据会覆盖指定位置以后的数据<br/> 1057 1057. * 例:String str1="123456789";<br/> 1058 1058. * 对str1操作后setRange(key,4,0000)，str1="123400009"; 1059 1059. * @param String key 1060 1060. * @param long offset 1061 1061. * @param String value 1062 1062. * @return long value的长度 1063 1063. * */ 1064 1064. public long setRange(String key, long offset, String value) { 1065 1065. Jedis jedis = getJedis(); 1066 1066. long len = jedis.setrange(key, offset, value); 1067 1067. returnJedis(jedis); 1068 1068. return len; 1069 1069. } 1070 1070. 1071 1071. /** 1072 1072. * 在指定的key中追加value 1073 1073. * @param String key 1074 1074. * @param String value 1075 1075. * @return long 追加后value的长度 1076 1076. * **/ 1077 1077. public long append(String key, String value) { 1078 1078. Jedis jedis = getJedis(); 1079 1079. long len = jedis.append(key, value); 1080 1080. returnJedis(jedis); 1081 1081. return len; 1082 1082. } 1083 1083. 1084 1084. /** 1085 1085. * 将key对应的value减去指定的值，只有value可以转为数字时该方法才可用 1086 1086. * @param String key 1087 1087. * @param long number 要减去的值 1088 1088. * @return long 减指定值后的值 1089 1089. * */ 1090 1090. public long decrBy(String key, long number) { 1091 1091. Jedis jedis = getJedis(); 1092 1092. long len = jedis.decrBy(key, number); 1093 1093. returnJedis(jedis); 1094 1094. return len; 1095 1095. } 1096 1096. 1097 1097. /** 1098 1098. * <b>可以作为获取唯一id的方法</b><br/> 1099 1099. * 将key对应的value加上指定的值，只有value可以转为数字时该方法才可用 1100 1100. * @param String key 1101 1101. * @param long number 要减去的值 1102 1102. * @return long 相加后的值 1103 1103. * */ 1104 1104. public long incrBy(String key, long number) { 1105 1105. Jedis jedis = getJedis(); 1106 1106. long len = jedis.incrBy(key, number); 1107 1107. returnJedis(jedis); 1108 1108. return len; 1109 1109. } 1110 1110. 1111 1111. /** 1112 1112. * 对指定key对应的value进行截取 1113 1113. * @param String key 1114 1114. * @param long startOffset 开始位置(包含) 1115 1115. * @param long endOffset 结束位置(包含) 1116 1116. * @return String 截取的值 1117 1117. * */ 1118 1118. public String getrange(String key, long startOffset, long endOffset) { 1119 1119. //ShardedJedis sjedis = getShardedJedis(); 1120 1120. Jedis sjedis = getJedis(); 1121 1121. String value = sjedis.getrange(key, startOffset, endOffset); 1122 1122. returnJedis(sjedis); 1123 1123. return value; 1124 1124. } 1125 1125. 1126 1126. /** 1127 1127. * 获取并设置指定key对应的value<br/> 1128 1128. * 如果key存在返回之前的value,否则返回null 1129 1129. * @param String key 1130 1130. * @param String value 1131 1131. * @return String 原始value或null 1132 1132. * */ 1133 1133. public String getSet(String key, String value) { 1134 1134. Jedis jedis = getJedis(); 1135 1135. String str = jedis.getSet(key, value); 1136 1136. returnJedis(jedis); 1137 1137. return str; 1138 1138. } 1139 1139. 1140 1140. /** 1141 1141. * 批量获取记录,如果指定的key不存在返回List的对应位置将是null 1142 1142. * @param String keys 1143 1143. * @return List<String> 值得集合 1144 1144. * */ 1145 1145. public List<String> mget(String... keys) { 1146 1146. Jedis jedis = getJedis(); 1147 1147. List<String> str = jedis.mget(keys); 1148 1148. returnJedis(jedis); 1149 1149. return str; 1150 1150. } 1151 1151. 1152 1152. /** 1153 1153. * 批量存储记录 1154 1154. * @param String keysvalues 例:keysvalues="key1","value1","key2","value2"; 1155 1155. * @return String 状态码 1156 1156. * */ 1157 1157. public String mset(String... keysvalues) { 1158 1158. Jedis jedis = getJedis(); 1159 1159. String str = jedis.mset(keysvalues); 1160 1160. returnJedis(jedis); 1161 1161. return str; 1162 1162. } 1163 1163. 1164 1164. /** 1165 1165. * 获取key对应的值的长度 1166 1166. * @param String key 1167 1167. * @return value值得长度 1168 1168. * */ 1169 1169. public long strlen(String key) { 1170 1170. Jedis jedis = getJedis(); 1171 1171. long len = jedis.strlen(key); 1172 1172. returnJedis(jedis); 1173 1173. return len; 1174 1174. } 1175 1175. } 1176 1176. 1177 1177. 1178 1178. //*******************************************Lists*******************************************// 1179 1179. public class Lists { 1180 1180. /** 1181 1181. * List长度 1182 1182. * @param String key 1183 1183. * @return 长度 1184 1184. * */ 1185 1185. public long llen(String key) { 1186 1186. return llen(SafeEncoder.encode(key)); 1187 1187. } 1188 1188. 1189 1189. /** 1190 1190. * List长度 1191 1191. * @param byte[] key 1192 1192. * @return 长度 1193 1193. * */ 1194 1194. public long llen(byte[] key) { 1195 1195. //ShardedJedis sjedis = getShardedJedis(); 1196 1196. Jedis sjedis = getJedis(); 1197 1197. long count = sjedis.llen(key); 1198 1198. returnJedis(sjedis); 1199 1199. return count; 1200 1200. } 1201 1201. 1202 1202. /** 1203 1203. * 覆盖操作,将覆盖List中指定位置的值 1204 1204. * @param byte[] key 1205 1205. * @param int index 位置 1206 1206. * @param byte[] value 值 1207 1207. * @return 状态码 1208 1208. * */ 1209 1209. public String lset(byte[] key, int index, byte[] value) { 1210 1210. Jedis jedis = getJedis(); 1211 1211. String status = jedis.lset(key, index, value); 1212 1212. returnJedis(jedis); 1213 1213. return status; 1214 1214. } 1215 1215. 1216 1216. /** 1217 1217. * 覆盖操作,将覆盖List中指定位置的值 1218 1218. * @param key 1219 1219. * @param int index 位置 1220 1220. * @param String value 值 1221 1221. * @return 状态码 1222 1222. * */ 1223 1223. public String lset(String key, int index, String value) { 1224 1224. return lset(SafeEncoder.encode(key), index, 1225 1225. SafeEncoder.encode(value)); 1226 1226. } 1227 1227. 1228 1228. /** 1229 1229. * 在value的相对位置插入记录 1230 1230. * @param key 1231 1231. * @param LIST_POSITION 前面插入或后面插入 1232 1232. * @param String pivot 相对位置的内容 1233 1233. * @param String value 插入的内容 1234 1234. * @return 记录总数 1235 1235. * */ 1236 1236. public long linsert(String key, LIST_POSITION where, String pivot, 1237 1237. String value) { 1238 1238. return linsert(SafeEncoder.encode(key), where, 1239 1239. SafeEncoder.encode(pivot), SafeEncoder.encode(value)); 1240 1240. } 1241 1241. 1242 1242. /** 1243 1243. * 在指定位置插入记录 1244 1244. * @param String key 1245 1245. * @param LIST_POSITION 前面插入或后面插入 1246 1246. * @param byte[] pivot 相对位置的内容 1247 1247. * @param byte[] value 插入的内容 1248 1248. * @return 记录总数 1249 1249. * */ 1250 1250. public long linsert(byte[] key, LIST_POSITION where, byte[] pivot, 1251 1251. byte[] value) { 1252 1252. Jedis jedis = getJedis(); 1253 1253. long count = jedis.linsert(key, where, pivot, value); 1254 1254. returnJedis(jedis); 1255 1255. return count; 1256 1256. } 1257 1257. 1258 1258. /** 1259 1259. * 获取List中指定位置的值 1260 1260. * @param String key 1261 1261. * @param int index 位置 1262 1262. * @return 值 1263 1263. * **/ 1264 1264. public String lindex(String key, int index) { 1265 1265. return SafeEncoder.encode(lindex(SafeEncoder.encode(key), index)); 1266 1266. } 1267 1267. 1268 1268. /** 1269 1269. * 获取List中指定位置的值 1270 1270. * @param byte[] key 1271 1271. * @param int index 位置 1272 1272. * @return 值 1273 1273. * **/ 1274 1274. public byte[] lindex(byte[] key, int index) { 1275 1275. //ShardedJedis sjedis = getShardedJedis(); 1276 1276. Jedis sjedis = getJedis(); 1277 1277. byte[] value = sjedis.lindex(key, index); 1278 1278. returnJedis(sjedis); 1279 1279. return value; 1280 1280. } 1281 1281. 1282 1282. /** 1283 1283. * 将List中的第一条记录移出List 1284 1284. * @param String key 1285 1285. * @return 移出的记录 1286 1286. * */ 1287 1287. public String lpop(String key) { 1288 1288. return SafeEncoder.encode(lpop(SafeEncoder.encode(key))); 1289 1289. } 1290 1290. 1291 1291. /** 1292 1292. * 将List中的第一条记录移出List 1293 1293. * @param byte[] key 1294 1294. * @return 移出的记录 1295 1295. * */ 1296 1296. public byte[] lpop(byte[] key) { 1297 1297. Jedis jedis = getJedis(); 1298 1298. byte[] value = jedis.lpop(key); 1299 1299. returnJedis(jedis); 1300 1300. return value; 1301 1301. } 1302 1302. 1303 1303. /** 1304 1304. * 将List中最后第一条记录移出List 1305 1305. * 1306 1306. * @param byte[] key 1307 1307. * @return 移出的记录 1308 1308. * */ 1309 1309. public String rpop(String key) { 1310 1310. Jedis jedis = getJedis(); 1311 1311. String value = jedis.rpop(key); 1312 1312. returnJedis(jedis); 1313 1313. return value; 1314 1314. } 1315 1315. 1316 1316. /** 1317 1317. * 向List尾部追加记录 1318 1318. * @param String key 1319 1319. * @param String value 1320 1320. * @return 记录总数 1321 1321. * */ 1322 1322. public long lpush(String key, String value) { 1323 1323. return lpush(SafeEncoder.encode(key), SafeEncoder.encode(value)); 1324 1324. } 1325 1325. 1326 1326. /** 1327 1327. * 向List头部追加记录 1328 1328. * @param String key 1329 1329. * @param String value 1330 1330. * @return 记录总数 1331 1331. * */ 1332 1332. public long rpush(String key, String value) { 1333 1333. Jedis jedis = getJedis(); 1334 1334. long count = jedis.rpush(key, value); 1335 1335. returnJedis(jedis); 1336 1336. return count; 1337 1337. } 1338 1338. 1339 1339. /** 1340 1340. * 向List头部追加记录 1341 1341. * @param String key 1342 1342. * @param String value 1343 1343. * @return 记录总数 1344 1344. * */ 1345 1345. public long rpush(byte[] key, byte[] value) { 1346 1346. Jedis jedis = getJedis(); 1347 1347. long count = jedis.rpush(key, value); 1348 1348. returnJedis(jedis); 1349 1349. return count; 1350 1350. } 1351 1351. 1352 1352. /** 1353 1353. * 向List中追加记录 1354 1354. * @param byte[] key 1355 1355. * @param byte[] value 1356 1356. * @return 记录总数 1357 1357. * */ 1358 1358. public long lpush(byte[] key, byte[] value) { 1359 1359. Jedis jedis = getJedis(); 1360 1360. long count = jedis.lpush(key, value); 1361 1361. returnJedis(jedis); 1362 1362. return count; 1363 1363. } 1364 1364. 1365 1365. /** 1366 1366. * 获取指定范围的记录，可以做为分页使用 1367 1367. * @param String key 1368 1368. * @param long start 1369 1369. * @param long end 1370 1370. * @return List 1371 1371. * */ 1372 1372. public List<String> lrange(String key, long start, long end) { 1373 1373. //ShardedJedis sjedis = getShardedJedis(); 1374 1374. Jedis sjedis = getJedis(); 1375 1375. List<String> list = sjedis.lrange(key, start, end); 1376 1376. returnJedis(sjedis); 1377 1377. return list; 1378 1378. } 1379 1379. 1380 1380. /** 1381 1381. * 获取指定范围的记录，可以做为分页使用 1382 1382. * @param byte[] key 1383 1383. * @param int start 1384 1384. * @param int end 如果为负数，则尾部开始计算 1385 1385. * @return List 1386 1386. * */ 1387 1387. public List<byte[]> lrange(byte[] key, int start, int end) { 1388 1388. //ShardedJedis sjedis = getShardedJedis(); 1389 1389. Jedis sjedis = getJedis(); 1390 1390. List<byte[]> list = sjedis.lrange(key, start, end); 1391 1391. returnJedis(sjedis); 1392 1392. return list; 1393 1393. } 1394 1394. 1395 1395. /** 1396 1396. * 删除List中c条记录，被删除的记录值为value 1397 1397. * @param byte[] key 1398 1398. * @param int c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录 1399 1399. * @param byte[] value 要匹配的值 1400 1400. * @return 删除后的List中的记录数 1401 1401. * */ 1402 1402. public long lrem(byte[] key, int c, byte[] value) { 1403 1403. Jedis jedis = getJedis(); 1404 1404. long count = jedis.lrem(key, c, value); 1405 1405. returnJedis(jedis); 1406 1406. return count; 1407 1407. } 1408 1408. 1409 1409. /** 1410 1410. * 删除List中c条记录，被删除的记录值为value 1411 1411. * @param String key 1412 1412. * @param int c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录 1413 1413. * @param String value 要匹配的值 1414 1414. * @return 删除后的List中的记录数 1415 1415. * */ 1416 1416. public long lrem(String key, int c, String value) { 1417 1417. return lrem(SafeEncoder.encode(key), c, SafeEncoder.encode(value)); 1418 1418. } 1419 1419. 1420 1420. /** 1421 1421. * 算是删除吧，只保留start与end之间的记录 1422 1422. * @param byte[] key 1423 1423. * @param int start 记录的开始位置(0表示第一条记录) 1424 1424. * @param int end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推） 1425 1425. * @return 执行状态码 1426 1426. * */ 1427 1427. public String ltrim(byte[] key, int start, int end) { 1428 1428. Jedis jedis = getJedis(); 1429 1429. String str = jedis.ltrim(key, start, end); 1430 1430. returnJedis(jedis); 1431 1431. return str; 1432 1432. } 1433 1433. 1434 1434. /** 1435 1435. * 算是删除吧，只保留start与end之间的记录 1436 1436. * @param String key 1437 1437. * @param int start 记录的开始位置(0表示第一条记录) 1438 1438. * @param int end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推） 1439 1439. * @return 执行状态码 1440 1440. * */ 1441 1441. public String ltrim(String key, int start, int end) { 1442 1442. return ltrim(SafeEncoder.encode(key), start, end); 1443 1443. } 1444 1444. } 1445 1445. 1446 1446. public static void main(String[] args) { 1447 1447. JedisUtil jedisUtil= JedisUtil.getInstance(); 1448 1448. JedisUtil.Strings strings=jedisUtil.new Strings(); 1449 1449. strings.set("nnn", "nnnn"); 1450 1450. System.out.println("-----"+strings.get("nnn")); 1451 1451. 1452 1452. Jedis jedis=JedisUtil.getInstance().getJedis(); 1453 1453. for (int i = 0; i < 10; i++) { 1454 1454. jedis.set("test", "test"); 1455 1455. System.out.println(i+"=="+jedis.get("test")); 1456 1456. 1457 1457. } 1458 1458. JedisUtil.getInstance().returnJedis(jedis); 1459 1459. } 1460 1460. 1461 1461. }
3.
测试 类 ：
1 JedisUtil jedisUtil= JedisUtil.getInstance(); 2 2. JedisUtil.Strings strings=jedisUtil.new Strings(); 3 3. strings.set("nnn", "nnnn"); 4 4. System.out.println("-----"+strings.get("nnn"));
这个可以自己玩玩
毕竟项目中只是用到它来存日志文件的
主要还是好好学习mysql 及 Oracle
欢迎大家吐槽 我的不足之处 @@@@@@@@@@@@@@@@@@@@@