redis存储和查询的java实现

1.Redis简介

 Redis是一个key-value存储系统。和Memcached类似，但是解决了断电后数据完全丢失的情况，而且她支持更多无化的value类型，除了和string外，还支持lists（链表）、sets（集合）和zsets（有序集合）几种数据类型。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。

2.Redis的性能

官方数据：每秒可存110000条 , 每秒可取 81000 条.

3.安装Redis

redis的代码遵循ANSI-C编写，系统（如Linux,等）上安装运行。而且Redis并不依赖任何非标准库，也没有编译参数必需添加。

先去官网下载源码：

wget http://redis.googlecode.com/files/redis-2.4.6.tar.gz

解压：

tar –zxvf redis-2.4.6.tar.gz

编译

需要说明的事，redis的安装非常简单，已经有现成的Makefile文件，直接运行make命令即可。

make

make install

Redis 由四个可执行文件：redis-benchmark、redis-cli、redis-server、redis-stat这四个文件，加上一个redis.conf就构成了整个redis的最终可用包。它们的作用如下：

• redis-server：Redis服务器的daemon启动程序
• redis-cli：Redis命令行操作工具。当然，你也可以用telnet根据其纯文本协议来操作
• redis-benchmark：Redis性能测试工具，测试Redis在你的系统及你的配置下的读写性能
• redis-stat：Redis状态检测工具，可以检测Redis当前状态参数及延迟状况

现在就可以启动redis了，redis只有一个启动参数，就是他的配置文件路径。

redis-server /etc/redis.conf

注意，默认复制过去的redis.conf文件的daemonize参数为no，所以redis不会在后台运行，这时要测试，我们需要重新开一个终端。修改为yes则为后台运行redis。另外配置文件中规定了pid文件，log文件和数据文件的地址，如果有需要先修改，默认log信息定向到stdout.

下面是redis.conf的主要配置参数的意义：

• daemonize：是否以后台daemon方式运行
• pidfile：pid文件位置
• port：监听的端口号
• timeout：请求超时时间
• loglevel：log信息级别
• logfile：log文件位置
• databases：开启数据库的数量
• save * *：保存快照的频率，第一个*表示多长时间，第三个*表示执行多少次写操作。在一定时间内执行一定数量的写操作时，自动保存快照。可设置多个条件。
• rdbcompression：是否使用压缩
• dbfilename：数据快照文件名（只是文件名，不包括目录）
• dir：数据快照的保存目录（这个是目录）
• appendonly：是否开启appendonlylog，开启的话每次写操作会记一条log，这会提高数据抗风险能力，但影响效率。
• appendfsync：appendonlylog如何同步到磁盘（三个选项，分别是每次写都强制调用fsync、每秒启用一次fsync、不调用fsync等待系统自己同步）

这时你可以打开一个终端进行测试了，配置文件中默认的监听端口是6379

我们可以开启一个Redis客户端进行测试

[root@test01 ~]# redis-cli
Could not connect to Redis at 127.0.0.1:6379: Connection refused
not connected> exit
[root@test01 ~]# redis-server /etc/redis.conf
[root@test01 ~]# redis-cli
redis 127.0.0.1:6379> quit

4.常用操作

通过Java 调用redis API，实现存储和查询：

[java] view plain copy

1. import com.agd.utils.PropertiesUtils;  
2.   
3. import redis.clients.jedis.JedisPool;  
4. import redis.clients.jedis.JedisPoolConfig;  
5.   
6. /** 
7.  *  取redis 连接池 
8.  * <一句话功能简述> 
9.  * <功能详细描述> 
10.  *  
11.  * @author  khj 
12.  * @see  [相关类/方法] 
13.  * @since  [产品/模块版本] 
14.  */  
15. public class RedisClientPool  
16. {  
17.  public static RedisClientPool redisClientPool = getInstance();  
18.       
19.     public static JedisPool jedisPool;  
20.       
21.     public static synchronized RedisClientPool getInstance()  
22.     {  
23.         if (null == redisClientPool)  
24.         {  
25.             redisClientPool = new RedisClientPool();  
26.         }  
27.         return redisClientPool;  
28.     }  
29.       
30.     public RedisClientPool()  
31.     {  
32.         if (null == jedisPool)  
33.         {  
34.             init();  
35.         }  
36.     }  
37.       
38.     /** 
39.      *   初始化Jedis 
40.      * <一句话功能简述> 
41.      * <功能详细描述> 
42.      * @return 
43.      * @see [类、类#方法、类#成员] 
44.      */  
45.     private static JedisPoolConfig initPoolConfig()  
46.     {  
47.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();  
48.         // 控制一个pool最多有多少个状态为idle的jedis实例  
49.         jedisPoolConfig.setMaxIdle(1000);  
50.         // 最大能够保持空闲状态的对象数  
51.         jedisPoolConfig.setMaxIdle(300);  
52.         // 超时时间  
53.         jedisPoolConfig.setMaxWaitMillis(1000);  
54.         // 在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；  
55.         jedisPoolConfig.setTestOnBorrow(true);  
56.         // 在还会给pool时，是否提前进行validate操作  
57.         jedisPoolConfig.setTestOnReturn(true);  
58.           
59.         return jedisPoolConfig;  
60.     }  
61.       
62.     /** 
63.      * 初始化jedis连接池 
64.      */  
65.     public static void init()  
66.     {  
67.         JedisPoolConfig jedisPoolConfig = initPoolConfig();  
68.         String host = PropertiesUtils.getValue("redis.host");//"localhost";  
69.         int port = Integer.parseInt(PropertiesUtils.getValue("redis.port"));//6379;  
70.         int timeout = Integer.parseInt(PropertiesUtils.getValue("redis.timeout"));//60000;  
71.         // 构造连接池  
72.         jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);  
73.     }  

[java] view plain copy

1. import java.util.List;  
2. import java.util.Map;  
3. import java.util.concurrent.ConcurrentHashMap;  
4.   
5. import redis.clients.jedis.Jedis;  
6.   
7. /** 
8.  *  redis 操作api 
9.  * <一句话功能简述> 
10.  * <功能详细描述> 
11.  *  
12.  * @author  khj 
13.  * @see  [相关类/方法] 
14.  * @since  [产品/模块版本] 
15.  */  
16. public class RedisClient   
17. {  
18.     /** 
19.      *  保存数据   类型为 Map 
20.      * <一句话功能简述> 
21.      * <功能详细描述> 
22.      * @param flag 
23.      * @param mapData 
24.      * @see [类、类#方法、类#成员] 
25.      */  
26.     public static void setMapDataToRedis(String flag,Map<String,String> mapData)  
27.     {         
28.         Jedis redisClient = null;  
29.         try  
30.         {  
31.             redisClient = RedisClientPool.jedisPool.getResource();  
32.             redisClient.hmset(flag,mapData);  
33.         }   
34.         catch (Exception e)  
35.         {  
36.             // 销毁对象  
37.             RedisClientPool.jedisPool.returnBrokenResource(redisClient);  
38.         }  
39.         finally  
40.         {  
41.             // 还原到连接池  
42.             RedisClientPool.jedisPool.returnResource(redisClient);  
43.         }  
44.     }  
45.       
46.     /** 
47.      *  保存数据   类型为 key-value 
48.      * <一句话功能简述> 
49.      * <功能详细描述> 
50.      * @param flag 
51.      * @param field 
52.      * @param value 
53.      * @see [类、类#方法、类#成员] 
54.      */  
55.     public static void setDataToRedis(String flag,String field,String value)  
56.     {  
57.         Jedis redisClient = null;  
58.         try  
59.         {  
60.             redisClient = RedisClientPool.jedisPool.getResource();  
61.             redisClient.hset(flag, field, value);  
62.         }   
63.         catch (Exception e)  
64.         {  
65.             // 销毁对象  
66.             RedisClientPool.jedisPool.returnBrokenResource(redisClient);  
67.         }  
68.         finally  
69.         {  
70.             // 还原到连接池  
71.             RedisClientPool.jedisPool.returnResource(redisClient);  
72.         }  
73.     }  
74.       
75.     /** 
76.      *  获取Map数据 
77.      * <一句话功能简述> 
78.      * <功能详细描述> 
79.      * @param flag 
80.      * @return 
81.      * @see [类、类#方法、类#成员] 
82.      */  
83.     public static Map<String,String> getMapData(String flag)  
84.     {  
85.         Map<String,String> dataMap = null;  
86.           
87.         Jedis redisClient = null;  
88.         try  
89.         {  
90.             redisClient = RedisClientPool.jedisPool.getResource();  
91.             dataMap = redisClient.hgetAll(flag);  
92.         }   
93.         catch (Exception e)  
94.         {  
95.             // 销毁对象  
96.             RedisClientPool.jedisPool.returnBrokenResource(redisClient);  
97.         }  
98.         finally  
99.         {  
100.             // 还原到连接池  
101.             RedisClientPool.jedisPool.returnResource(redisClient);  
102.         }  
103.         return dataMap;  
104.     }  
105.       
106.     public static long deleteData(String flag)  
107.     {  
108.         long result = 0;  
109.         Jedis redisClient = null;  
110.         try  
111.         {  
112.             redisClient = RedisClientPool.jedisPool.getResource();  
113.             result = redisClient.del(flag);  
114.         }   
115.         catch (Exception e)  
116.         {  
117.             // 销毁对象  
118.             RedisClientPool.jedisPool.returnBrokenResource(redisClient);  
119.         }  
120.         finally  
121.         {  
122.             // 还原到连接池  
123.             RedisClientPool.jedisPool.returnResource(redisClient);  
124.         }  
125.           
126.         return result;  
127.     }  
128.       
129.     /** 
130.      * 根据key和字段获取数据  
131.      * <一句话功能简述> 
132.      * <功能详细描述> 
133.      * @param flag 
134.      * @param field 
135.      * @return 
136.      * @see [类、类#方法、类#成员] 
137.      */  
138.     public static String getData(String flag,String field)  
139.     {  
140.         String data = null;  
141.         Jedis redisClient = null;  
142.         try  
143.         {  
144.             redisClient = RedisClientPool.jedisPool.getResource();  
145.             data = redisClient.hget(flag, field);  
146.         }   
147.         catch (Exception e)  
148.         {  
149.             // 销毁对象  
150.             RedisClientPool.jedisPool.returnBrokenResource(redisClient);  
151.         }  
152.         finally  
153.         {  
154.             // 还原到连接池  
155.             RedisClientPool.jedisPool.returnResource(redisClient);  
156.         }  
157.           
158.         return data;  
159.     }  
160.   
161.       
162.     public static void main(String[] args)  throws Exception  
163.     {           
164.         RedisClient.testMap();    
165.     }    
166.       
167.       
168.     public void testList()  
169.     {    
170.        Jedis redis = RedisClientPool.jedisPool.getResource();  
171.         //hset key field value将哈希表key中的域field的值设为value。   
172.         redis.hset("table", "field1", "value1");   
173.         redis.hset("table", "field2", "value2");   
174.         redis.hset("table", "field3", "value3");   
175.         //返回哈希表key中，一个或多个给定域的值。   
176.         List<String> list = redis.hmget("table","field1","field2","field3");   
177.         for(String tmp : list)  
178.         {   
179.             System.out.println(tmp);   
180.         }   
181.     }  
182.       
183.     public static void testMap()  
184.     {  
185.         //同时将多个field - value(域-值)对设置到哈希表key中。   
186.         Map<String,String> map = new ConcurrentHashMap<String,String>();  
187.         for (int i = 0;i < 10000;i++)  
188.         {  
189.             map.put("field"+i, "value"+i);   
190.         }  
191.         if (null != getData("table", "field1"))  
192.         {  
193.             deleteData("table");  
194.         }  
195.         //得到map下面的username的值   
196.         Map<String,String> maps = getMapData("table");  
197.         System.out.println(maps.size());  
198.           
199.         setMapDataToRedis("table",map);  
200.   
201.         //HGETALL key返回哈希表key中，所有的域和值。   
202.         maps = getMapData("table");   
203.          
204.         System.out.println(maps.size());  
205.     }  
206.   
207. }