AI专业者开发社区 1 号成员
  •  0 回帖  •  0 浏览  •  5 个月前
 

Redis学习记录之Java中的初步使用

1. 关于 Redis

[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. redis 下载地址：<span style="font-family: Arial, Helvetica, sans-serif;">http://download.csdn.net/detail/he90227/8569855</span>  
 
[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. Redis 是什么？两句话可以做下概括：   
  2. 1. 是一个完全开源免费的 key-value 内存数据库   
  3. 2. 通常被认为是一个数据结构服务器，主要是因为其有着丰富的数据结构 strings、map、 list、sets、 sorted sets  
  4.   
  5.   
  6. 它通过提供多种键值数据类型来适应不同场景下的存储需求，并借助许多高层级的接口使其可以胜任如缓存、队列系统等不同的角色  
  7. 和 Memcached 类似，但是解决了断电后数据完全丢失的情况，而且她支持更多无化的 value 类型，除了和 string 外，  
  8. 还支持 lists（链表）、sets（集合）和 zsets（有序集合）几种数据类型。这些数据类型都支持 push/pop、add/remove 及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的  
  9.   
  10.   
  11. 2. 支持的数据类型    
  12.             字符串类型    string  
  13.             散列类型         Hash  
  14.             链表表类型     lists  
  15.             集合类型          sets  
  16.             有序集合类型  zsets  
  17.   
  18. 说明：  
  19.      string 是最简单的类型，你可以理解成与 Memcached 一模一个的类型，一个 key 对应一个 value，其上支持的操作与 Memcached 的操作类似。但它的功能更丰富。  
  20.      list 是一个链表结构，主要功能是 push、pop、获取一个范围的所有值等等。操作中 key 理解为链表的名字。  
  21.      set 是集合，和我们数学中的集合概念相似，对集合的操作有添加删除元素，有对多个集合求交并差等操作。操作中 key 理解为集合的名字。  
  22.      zset 是 set 的一个升级版本，他在 set 的基础上增加了一个顺序属性，这一属性在添加修改元素的时候可以指定，每次指定后，zset 会自动重新按新的值调整顺序。可以理解了有两列的 mysql 表，一列存 value，一列存顺序。操作中 key 理解为 zset 的名字。  
  23.      Hash 数据类型允许用户用 Redis 存储对象类型,Hash 数据类型的一个重要优点是, 当你存储的数据对象只有很少几个 key 值时, 数据存储的内存消耗会很小.  
  24.   
  25.   
  26.    
  27. 3. 内存存储于持久化  
  28.    
  29.     Redis 数据库中的所有数据都存储在内存中，同时提供了对持久化的支持，即：可以将内存中的数据异步写入硬盘中，同时不会影响继续提供服务  
  30.       
  31.       
  32. redis 主从配置  
  33.   
  34. redis 支持 master-slave 的主从配置，配置方法是在从机的配置文件中指定 slaveof 参数为主机的 ip 和 port 即可  
  35.   
  36.   
  37. 4. Redis VS  Memcached   
  38.   
  39.    1. 都可以做为缓存系统使用  
  40.    2. 性能上 Redis 是单线程模型，Memcached 支持多线程，所有在多核服务器上后者的性能更高一些  
  41.    3.Redis 支持高级的数据类型和持久化等功能  
  42.    4. 存储方式方面：Memcached 只支持简单的 key-value 存储，不支持枚举，不支持持久化和复制等功能  
  43.   
  44.   
  45. 5. 安装 Redis  -- Redis 官方仅支持 Linux、Unix 和 OS X，不支持 Windows  
  46.   
  47.   
  48. Linux 下安装：  wget 或拷贝到指定目录下    ---  解压后在 src 目录下使用 macke 命令完成编译  
  49.   
  50.   
  51. wget http://download.redis.io/redis-stable.tar.gz  
  52. tar xzf redis-stable.tar.gz  
  53. cd redis-stable  
  54. make  
  55.   
  56.   
  57. 需要说明的事，redis 的安装非常简单，已经有现成的 Makefile 文件，直接运行 make 命令即可。  
  58.   
  59. make  
  60.   
  61. make install  
  62.   
  63.   
  64. Redis 由四个可执行文件：redis-benchmark、redis-cli、redis-server、redis-stat 这四个文件，加上一个 redis.conf 就构成了整个 redis 的最终可用包。它们的作用如下：  
  65.   
  66.   
  67. redis-server：Redis 服务器的 daemon 启动程序  
  68. redis-cli：Redis 命令行操作工具。当然，你也可以用 telnet 根据其纯文本协议来操作  
  69. redis-benchmark：Redis 性能测试工具，测试 Redis 在你的系统及你的配置下的读写性能  
  70. redis-stat：Redis 状态检测工具，可以检测 Redis 当前状态参数及延迟状况  
  71.   
  72.   
  73. 6. 启动和停止 Redis  
  74.   
  75.   
  76. 编译后生成的可执行文件  
  77.      redis-server                 ----  Redis 服务器  
  78.      redis-cli                    ----  Redis 命令行客户端  
  79.        
  80.   
  81.   
  82. redis-server   是 Redis 的服务器，启动 Redis 即运行 redis-server  
  83. redis-cli      是 Redis 自带的 Redis 命令行客户端，学习 Redis 的重要工具  
  84.   
  85.   
  86.   
  87.   
  88. 启动 Redis  
  89.        1. 直接启动      -- 运行 redis-server 即可启动 redis  
  90.                      注意：  
  91.            Redis 服务器默认会使用 6379 端口，通过 --port 参数可以自定义使用的端口号  
  92.            eg:  
  93.                redis-server --port 6380  
  94.         
  95. 停止 Redis  
  96.   
  97.   
  98.        redis-cli shutdown         
  99.   
  100.   
  101. Redis 有可能正在将内存中的数据同步到硬盘中，强行终止 Redis 进程可能会导致数据丢失，正确的做法是向 Redis 发送 shutdown 命令  
  102. 当 Redis 收到 shutdown 命令后，会先断开所有客户端连接，然后根据配置执行持久化，最后完成退出  
 


2.Redis 配置和常用命令

[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. 1.Redis 配置  
[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. redis.conf 配置文件：  
  2. 引用  
  3. #是否作为守护进程运行  
  4. daemonize yes  
  5. #配置 pid 的存放路径及文件名，默认为当前路径下  
  6. pidfile redis.pid  
  7. #Redis 默认监听端口  
  8. port 6379  
  9. #客户端闲置多少秒后，断开连接  
  10. timeout 300  
  11. #日志显示级别  
  12. loglevel verbose  
  13. #指定日志输出的文件名，也可指定到标准输出端口  
  14. logfile stdout  
  15. #设置数据库的数量，默认连接的数据库是 0，可以通过 select N 来连接不同的数据库  
  16. databases 16  
  17. #保存数据到 disk 的策略  
  18. #当有一条 Keys 数据被改变是，900 秒刷新到 disk 一次  
  19. save 900 1  
  20. #当有 10 条 Keys 数据被改变时，300 秒刷新到 disk 一次  
  21. save 300 10  
  22. #当有 1w 条 keys 数据被改变时，60 秒刷新到 disk 一次  
  23. save 60 10000  
  24. #当 dump  .rdb 数据库的时候是否压缩数据对象  
  25. rdbcompression yes  
  26. #dump 数据库的数据保存的文件名  
  27. dbfilename dump.rdb  
  28. #Redis 的工作目录  
  29. dir /home/falcon/redis-2.0.0/  
  30. ###########  Replication #####################  
  31. #Redis 的复制配置  
  32. # slaveof <masterip> <masterport>  
  33. # masterauth <master-password>  
  34.   
  35. ############## SECURITY ###########  
  36. # requirepass foobared  
  37.   
  38. ############### LIMITS ##############  
  39. #最大客户端连接数  
  40. # maxclients 128  
  41. #最大内存使用率  
  42. # maxmemory <bytes>  
  43.   
  44. ########## APPEND ONLY MODE #########  
  45. #是否开启日志功能  
  46. appendonly no  
  47. # 刷新日志到 disk 的规则  
  48. # appendfsync always  
  49. appendfsync everysec  
  50. # appendfsync no  
  51. ################ VIRTUAL MEMORY ###########  
  52. #是否开启 VM 功能  
  53. vm-enabled no  
  54. # vm-enabled yes  
  55. vm-swap-file logs/redis.swap  
  56. vm-max-memory 0  
  57. vm-page-size 32  
  58. vm-pages 134217728  
  59. vm-max-threads 4  
  60. ############# ADVANCED CONFIG ###############  
  61. glueoutputbuf yes  
  62. hash-max-zipmap-entries 64  
  63. hash-max-zipmap-value 512  
  64. #是否重置 Hash 表  
  65. activerehashing yes  
 
[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. 常规操作命令  
  2.    
  3. 01  exits key              // 测试指定 key 是否存在，返回 1 表示存在，0 不存在  
  4. 02  del key1 key2 ....keyN // 删除给定 key, 返回删除 key 的数目，0 表示给定 key 都不存在  
  5. 03  type key               // 返回给定 key 的 value 类型。返回 none 表示不存在 key,string 字符类型，list 链表类型 set 无序集合类型...  
  6. 04  keys pattern           // 返回匹配指定模式的所有 key, 下面给个例子  
  7. 05  randomkey              // 返回从当前数据库中随机选择的一个 key, 如果当前数据库是空的，返回空串  
  8. 06  rename oldkey newkey   // 原子的重命名一个 key, 如果 newkey 存在，将会被覆盖，返回 1 表示成功，0 失败。可能是 oldkey 不存在或者和 newkey 相同  
  9. 07  renamenx oldkey newkey // 同上，但是如果 newkey 存在返回失败  
  10. 08  dbsize                 // 返回当前数据库的 key 数量  
  11. 09  expire key seconds     // 为 key 指定过期时间，单位是秒。返回 1 成功，0 表示 key 已经设置过过期时间或者不存在  
  12. 10  ttl key                // 返回设置过过期时间的 key 的剩余过期秒数 -1 表示 key 不存在或者没有设置过过期时间  
  13. 11  select db-index        // 通过索引选择数据库，默认连接的数据库所有是 0, 默认数据库数是 16 个。返回 1 表示成功，0 失败  
  14. 12  move key db-index      // 将 key 从当前数据库移动到指定数据库。返回 1 成功。0 如果 key 不存在，或者已经在指定数据库中  
  15. 13  flushdb                // 删除当前数据库中所有 key, 此方法不会失败。慎用  
  16. 14  flushall               // 删除所有数据库中的所有 key，此方法不会失败。更加慎用  
  17. string 类型数据操作命令  
  18.    
  19. 01  set key value         // 设置 key 对应的值为 string 类型的 value, 返回 1 表示成功，0 失败  
  20. 02  setnx key value       // 同上，如果 key 已经存在，返回 0 。nx 是 not exist 的意思  
  21. 03  get key               // 获取 key 对应的 string 值, 如果 key 不存在返回 nil  
  22. 04  getset key value      // 原子的设置 key 的值，并返回 key 的旧值。如果 key 不存在返回 nil  
  23. 05  mget key1 key2 ... keyN            // 一次获取多个 key 的值，如果对应 key 不存在，则对应返回 nil。下面是个实验, 首先清空当前数据库，然后设置 k1,k2. 获取时 k3 对应返回 nil  
  24. 06  mset key1 value1 ... keyN valueN   // 一次设置多个 key 的值，成功返回 1 表示所有的值都设置了，失败返回 0 表示没有任何值被设置  
  25. 07  msetnx key1 value1 ... keyN valueN // 同上，但是不会覆盖已经存在的 key  
  26. 08  incr key              // 对 key 的值做加加操作, 并返回新的值。注意 incr 一个不是 int 的 value 会返回错误，incr 一个不存在的 key，则设置 key 为 1  
  27. 09  decr key              // 同上，但是做的是减减操作，decr 一个不存在 key，则设置 key 为 -1  
  28. 10  incrby key integer    // 同 incr，加指定值 ，key 不存在时候会设置 key，并认为原来的 value 是 0  
  29. 11  decrby key integer    // 同 decr，减指定值。decrby 完全是为了可读性，我们完全可以通过 incrby 一个负值来实现同样效果，反之一样。  
  30. 12  append key value      // 给指定 key 的字符串值追加 value, 返回新字符串值的长度。下面给个例子  
  31. 13  substr key start end  // 返回截取过的 key 的字符串值, 注意并不修改 key 的值。下标是从 0 开始的，接着上面例子  
  32. list 类型数据操作命令  
  33.    
  34. 01  lpush key string          // 在 key 对应 list 的头部添加字符串元素，返回 1 表示成功，0 表示 key 存在且不是 list 类型  
  35. 02  rpush key string          // 同上，在尾部添加  
  36. 03  llen key                  // 返回 key 对应 list 的长度，key 不存在返回 0, 如果 key 对应类型不是 list 返回错误  
  37. 04  lrange key start end      // 返回指定区间内的元素，下标从 0 开始，负值表示从后面计算，-1 表示倒数第一个元素 ，key 不存在返回空列表  
  38. 05  ltrim key start end       // 截取 list，保留指定区间内元素，成功返回 1，key 不存在返回错误  
  39. 06  lset key index value      // 设置 list 中指定下标的元素值，成功返回 1，key 或者下标不存在返回错误  
  40. 07  lrem key count value      // 从 key 对应 list 中删除 count 个和 value 相同的元素。count 为 0 时候删除全部  
  41. 08  lpop key                  // 从 list 的头部删除元素，并返回删除元素。如果 key 对应 list 不存在或者是空返回 nil，如果 key 对应值不是 list 返回错误  
  42. 09  rpop                      // 同上，但是从尾部删除  
  43. 10  blpop key1...keyN timeout // 从左到右扫描返回对第一个非空 list 进行 lpop 操作并返回，比如 blpop list1 list2 list3 0 , 如果 list 不存在 list2,list3 都是非空则对 list2 做 lpop 并返回从 list2 中删除的元素。如果所有的 list 都是空或不存在，则会阻塞 timeout 秒，timeout 为 0 表示一直阻塞。当阻塞时，如果有 client 对 key1...keyN 中的任意 key 进行 push 操作，则第一在这个 key 上被阻塞的 client 会立即返回。如果超时发生，则返回 nil。有点像 unix 的 select 或者 poll  
  44. 11  brpop                     // 同 blpop，一个是从头部删除一个是从尾部删除  
  45. 12  rpoplpush srckey destkey  // 从 srckey 对应 list 的尾部移除元素并添加到 destkey 对应 list 的头部, 最后返回被移除的元素值，整个操作是原子的. 如果 srckey 是空或者不存在返回 nil  
  46. set 类型数据操作命令  
  47.    
  48. 01  sadd key member                // 添加一个 string 元素到,key 对应的 set 集合中，成功返回 1, 如果元素以及在集合中返回 0,key 对应的 set 不存在返回错误  
  49. 02  srem key member                // 从 key 对应 set 中移除给定元素，成功返回 1，如果 member 在集合中不存在或者 key 不存在返回 0，如果 key 对应的不是 set 类型的值返回错误  
  50. 03  spop key                       // 删除并返回 key 对应 set 中随机的一个元素, 如果 set 是空或者 key 不存在返回 nil  
  51. 04  srandmember key                // 同 spop，随机取 set 中的一个元素，但是不删除元素  
  52. 05  smove srckey dstkey member     // 从 srckey 对应 set 中移除 member 并添加到 dstkey 对应 set 中，整个操作是原子的。成功返回 1, 如果 member 在 srckey 中不存在返回 0，如果 key 不是 set 类型返回错误  
  53. 06  scard key                      // 返回 set 的元素个数，如果 set 是空或者 key 不存在返回 0  
  54. 07  sismember key member           // 判断 member 是否在 set 中，存在返回 1，0 表示不存在或者 key 不存在  
  55. 08  sinter key1 key2...keyN        // 返回所有给定 key 的交集  
  56. 09  sinterstore dstkey key1...keyN // 同 sinter，但是会同时将交集存到 dstkey 下  
  57. 10  sunion key1 key2...keyN        // 返回所有给定 key 的并集  
  58. 11  sunionstore dstkey key1...keyN // 同 sunion，并同时保存并集到 dstkey 下  
  59. 12  sdiff key1 key2...keyN         // 返回所有给定 key 的差集  
  60. 13  sdiffstore dstkey key1...keyN  // 同 sdiff，并同时保存差集到 dstkey 下  
  61. 14  smembers key                   // 返回 key 对应 set 的所有元素，结果是无序的  
  62. sorted set 类型数据操作命令  
  63.    
  64. 01  zadd key score member        // 添加元素到集合，元素在集合中存在则更新对应 score  
  65. 02  zrem key member              // 删除指定元素，1 表示成功，如果元素不存在返回 0  
  66. 03  zincrby key incr member      // 增加对应 member 的 score 值，然后移动元素并保持 skip list 保持有序。返回更新后的 score 值  
  67. 04  zrank key member             // 返回指定元素在集合中的排名（下标）, 集合中元素是按 score 从小到大排序的  
  68. 05  zrevrank key member          // 同上, 但是集合中元素是按 score 从大到小排序  
  69. 06  zrange key start end         // 类似 lrange 操作从集合中去指定区间的元素。返回的是有序结果  
  70. 07  zrevrange key start end      // 同上，返回结果是按 score 逆序的  
  71. 08  zrangebyscore key min max    // 返回集合中 score 在给定区间的元素  
  72. 09  zcount key min max           // 返回集合中 score 在给定区间的数量  
  73. 10  zcard key                    // 返回集合中元素个数  
  74. 11  zscore key element           // 返回给定元素对应的 score  
  75. 12  zremrangebyrank key min max  // 删除集合中排名在给定区间的元素  
  76. 13  zremrangebyscore key min max // 删除集合中 score 在给定区间的元素  
  77. hash 类型数据操作命令  
  78.    
  79. 01  hset key field value       // 设置 hash field 为指定值，如果 key 不存在，则先创建  
  80. 02  hget key field             // 获取指定的 hash field  
  81. 03  hmget key filed1....fieldN // 获取全部指定的 hash filed  
  82. 04  hmset key filed1 value1 ... filedN valueN // 同时设置 hash 的多个 field  
  83. 05  hincrby key field integer  // 将指定的 hash filed 加上给定值  
  84. 06  hexists key field          // 测试指定 field 是否存在  
  85. 07  hdel key field             // 删除指定的 hash field  
  86. 08  hlen key                   // 返回指定 hash 的 field 数量  
  87. 09  hkeys key                  // 返回 hash 的所有 field  
  88. 10  hvals key                  // 返回 hash 的所有 value  
  89. 11  hgetall                    // 返回 hash 的所有 filed 和 value  


3.redis 在 Java 中的使用

1.maven 依赖：
 
[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. <!-- Redis 依赖 -->  
  2. <dependency>  
  3.     <groupId>redis.clients</groupId>  
  4.     <artifactId>jedis</artifactId>  
  5.     <version>2.7.0</version>  
  6. </dependency>  
  7.   
  8. <!-- Spring 整合 Redis 依赖 -->  
  9. <dependency>  
  10.     <groupId>org.springframework.data</groupId>  
  11.     <artifactId>spring-data-redis</artifactId>  
  12.     <version>1.5.0.RELEASE</version>  
  13. </dependency>  


2. 客户端实例

 
[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. properties 文件基本配置  
  2. redis.pool.maxActive=100  
  3. redis.pool.maxIdle=20  
  4. redis.pool.maxWait=3000  
  5. redis.ip=localhost  
  6. redis.port=6379  


[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. import java.util.ResourceBundle;  
  2.   
  3. import com.alibaba.fastjson.JSON;  
  4.   
  5. import redis.clients.jedis.Jedis;  
  6. import redis.clients.jedis.JedisPool;  
  7. import redis.clients.jedis.JedisPoolConfig;  
  8. import redis.clients.jedis.ShardedJedis;  
  9. import redis.clients.jedis.ShardedJedisPool;  
  10.   
  11. public class RedisClient {  
  12.       
  13.     public  static  JedisPool jedisPool; // 池化管理 jedis 链接池  
  14.         
  15.       static {  
  16.           
  17.         // 读取相关的配置  
  18.         ResourceBundle resourceBundle = ResourceBundle.getBundle("redis");  
  19.         int maxActive = Integer.parseInt(resourceBundle.getString("redis.pool.maxActive"));  
  20.         int maxIdle = Integer.parseInt(resourceBundle.getString("redis.pool.maxIdle"));  
  21.         int maxWait = Integer.parseInt(resourceBundle.getString("redis.pool.maxWait"));  
  22.           
  23.         String ip = resourceBundle.getString("redis.ip");  
  24.         int port = Integer.parseInt(resourceBundle.getString("redis.port"));  
  25.           
  26.         JedisPoolConfig config = new JedisPoolConfig();    
  27.         // 设置最大连接数  
  28.         config.setMaxTotal(maxActive);  
  29.         // 设置最大空闲数  
  30.         config.setMaxIdle(maxIdle);  
  31.         // 设置超时时间  
  32.         config.setMaxWaitMillis(maxWait);  
  33.           
  34.         // 初始化连接池  
  35.         jedisPool = new JedisPool(config, ip, port);   
  36.       }  
  37.         
  38.       /**  
  39.        * 向缓存中设置字符串内容  
  40.        * @param key key  
  41.        * @param value value  
  42.        * @return  
  43.        * @throws Exception  
  44.        */  
  45.       public static boolean  set(String key,String value) throws Exception{  
  46.         Jedis jedis = null;  
  47.         try {  
  48.           jedis = jedisPool.getResource();  
  49.           jedis.set(key, value);  
  50.           return true;  
  51.         } catch (Exception e) {  
  52.           e.printStackTrace();  
  53.           return false;  
  54.         }finally{  
  55.           jedisPool.returnResource(jedis);  
  56.         }  
  57.       }  
  58.         
  59.       /**  
  60.        * 向缓存中设置对象  
  61.        * @param key   
  62.        * @param value  
  63.        * @return  
  64.        */  
  65.       public static boolean  set(String key,Object value){  
  66.         Jedis jedis = null;  
  67.         try {  
  68.           String objectJson = JSON.toJSONString(value);  
  69.           jedis = jedisPool.getResource();  
  70.           jedis.set(key, objectJson);  
  71.           return true;  
  72.         } catch (Exception e) {  
  73.           e.printStackTrace();  
  74.           return false;  
  75.         }finally{  
  76.           jedisPool.returnResource(jedis);  
  77.         }  
  78.       }  
  79.         
  80.       /**  
  81.        * 删除缓存中得对象，根据 key  
  82.        * @param key  
  83.        * @return  
  84.        */  
  85.       public static boolean del(String key){  
  86.         Jedis jedis = null;  
  87.         try {  
  88.           jedis = jedisPool.getResource();  
  89.           jedis.del(key);  
  90.           return true;  
  91.         } catch (Exception e) {  
  92.           e.printStackTrace();  
  93.           return false;  
  94.         }finally{  
  95.           jedisPool.returnResource(jedis);  
  96.         }  
  97.       }  
  98.         
  99.       /**  
  100.        * 根据 key 获取内容  
  101.        * @param key  
  102.        * @return  
  103.        */  
  104.       public static Object get(String key){  
  105.         Jedis jedis = null;  
  106.         try {  
  107.           jedis = jedisPool.getResource();  
  108.           Object value = jedis.get(key);  
  109.           return value;  
  110.         } catch (Exception e) {  
  111.           e.printStackTrace();  
  112.           return false;  
  113.         }finally{  
  114.           jedisPool.returnResource(jedis);  
  115.         }  
  116.       }  
  117.         
  118.   
  119.       /**  
  120.        * 根据 key 获取对象  
  121.        * @param key  
  122.        * @return  
  123.        */  
  124.       public static <T> T get(String key,Class<T> clazz){  
  125.         Jedis jedis = null;  
  126.         try {  
  127.           jedis = jedisPool.getResource();  
  128.           String value = jedis.get(key);  
  129.           return JSON.parseObject(value, clazz);  
  130.         } catch (Exception e) {  
  131.           e.printStackTrace();  
  132.           return null;  
  133.         }finally{  
  134.           jedisPool.returnResource(jedis);  
  135.         }  
  136.       }  
  137.         
  138. //  private Jedis jedis;  // 非切片的客户端连接  
  139. //  private JedisPool jedisPool; // 非切片连接池  
  140. //  private ShardedJedis shardedJedis; // 切片的数据库连接  
  141. //  private ShardedJedisPool shardedJedisPool; // 切片连接池  
  142. //    
  143. //  public RedisClient() {  
  144. //      initialPool();  
  145. //      initialShardedPool();  
  146. //      shardedJedis = shardedJedisPool.getResource();  
  147. //      jedis = jedisPool.getResource();  
  148. //  }  
  149. //  
  150. //  /*  
  151. //   * 初始化非切片池  
  152. //   */  
  153. //  private void initialPool() {  
  154. //      // 池基本配置  
  155. //      JedisPoolConfig config = new JedisPoolConfig();  
  156. //      config.setMaxIdle(5);  
  157. //      config.set  
  158. //  }  
  159. //    
  160. //  private void initialShardedPool() {  
  161. //      shardedJedisPool   
  162. //        
  163. //  }  
  164.       
  165. }  

[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. 测试代码  
  2. package com.jay.demo6.redis.test;  
  3.   
  4. import org.junit.Test;  
  5.   
  6. public class RedisDemoTest {  
  7.   
  8.     /*  
  9.      * 向 Redis 中添加需要缓存的数据  
  10.      */  
  11.     @Test  
  12.     public void setUserCache() {  
  13.         // 向缓冲中添加保存对象  
  14.         UserDO user1 = new UserDO();  
  15.         user1.setId(1111);  
  16.         user1.setSex(true);  
  17.         user1.setPhone("1783797435");  
  18.         user1.setEmail("gfdsgjg@163.com");  
  19.   
  20.         // 调用方法处理  
  21.         boolean resultCache = RedisClient.set("user1", user1);  
  22.         if (resultCache) {  
  23.             System.out.println("向缓存中保存对象成功。");  
  24.         } else {  
  25.             System.out.println("向缓存中保存对象失败。");  
  26.         }  
  27.     }  
  28.       
  29.     /*  
  30.      * 从 Reids 中获取缓存的数据  
  31.      */  
  32.     @Test  
  33.     public void getUserCahce(){  
  34.         UserDO user1 = RedisClient.get("user1",UserDO.class);  
  35.         if(user1!=null){  
  36.             System.out.println(user1.toString());  
  37.         }  
  38.     }  
  39. }  
[html] view plain copy 在CODE上查看代码片派生到我的代码片
  1. </pre><pre code_snippet_id="637583" snippet_file_name="blog_20150407_12_3514709" name="code" class="html">package com.jay.demo6.redis.test;  
  2.   
  3.   
  4. public class UserDO {  
  5.     private int id;  
  6.     private boolean sex;  
  7.     private String name;  
  8.     private String phone;  
  9.     private String email;  
  10.   
  11.   
  12.     public UserDO() {  
  13.         super();  
  14.     }  
  15.   
  16.   
  17.     public int getId() {  
  18.         return id;  
  19.     }  
  20.   
  21.   
  22.     public void setId(int id) {  
  23.         this.id = id;  
  24.     }  
  25.   
  26.   
  27.     public boolean isSex() {  
  28.         return sex;  
  29.     }  
  30.   
  31.   
  32.     public void setSex(boolean sex) {  
  33.         this.sex = sex;  
  34.     }  
  35.   
  36.   
  37.     public String getName() {  
  38.         return name;  
  39.     }  
  40.   
  41.   
  42.     public void setName(String name) {  
  43.         this.name = name;  
  44.     }  
  45.   
  46.   
  47.     public String getPhone() {  
  48.         return phone;  
  49.     }  
  50.   
  51.   
  52.     public void setPhone(String phone) {  
  53.         this.phone = phone;  
  54.     }  
  55.   
  56.   
  57.     public String getEmail() {  
  58.         return email;  
  59.     }  
  60.   
  61.   
  62.     public void setEmail(String email) {  
  63.         this.email = email;  
  64.     }  
  65.   
  66.   
  67.     @Override  
  68.     public String toString() {  
  69.         return "UserDO [id=" + id + ", sex=" + (sex?" 男 ":" 女 ") + ", name=" + name  
  70.                 + ", phone=" + phone + ", email=" + email + "]";  
  71.     }  
  72. }