Linux 下 Redis使用介绍

出自http://blog.csdn.net/ajun_studio/article/details/6698147 和http://www.oschina.net/question/12_18065?sort=time

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类keyvalue存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP,Java客户端，使用很方便。

Redis使用单线程的IO复用模型，自己封装了一个简单的AeEvent事件处理框架，主要实现了epoll、kqueue和select，对于单纯只有IO操作来说，单线程可以将速度优势发挥到最大，但是Redis也提供了一些简单的计算功能，比如排序、聚合等，对于这些操作，单线程模型实际会严重影响整体吞吐量，CPU计算过程中，整个IO调度都是被阻塞住的。

Redis除了作为存储之外还提供了一些其它方面的功能，比如聚合计算、pubsub、scripting等，对于此类功能需要了解其实现原理，清楚地了解到它的局限性后，才能正确的使用，比如pubsub功能，这个实际是没有任何持久化支持的，消费方连接闪断或重连之间过来的消息是会全部丢失的，又比如聚合计算和scripting等功能受Redis单线程模型所限，是不可能达到很高的吞吐量的，需要谨慎使用。

本例子Linux采用的centOs5.4

下面来介绍一下redis的安装

[java] view plaincopyprint?

1. wget  http://redis.googlecode.com/files/redis-2.0.4.tar.gz
2. tar zxvf redis-2.0.4.tar.gz
3. cd  redis-2.0.4
4. make

make完后 redis-2.0.4目录下会出现编译后的redis服务程序redis-server,还有用于测试的客户端程序redis-cli

安装成功

启动服务

./redis-server

也可以通过启动参数告诉redis使用指定配置文件使用下面命令启动

./redis-server redis.conf

redis.conf是一个默认的配置文件。我们可以根据需要使用自己的配置文件。

启动redis服务进程后，就可以使用测试客户端程序redis-cli和redis服务交互了

注意启动的时候，会出现

WARNING overcommit_memory is set to 0!Background save may fail under

low memory condition. To fix this issue add‘vm.overcommit_memory = 1‘ to /etc/sysctl.conf and 

[6020] 10 Aug 20:58:21 * The server is nowready to accept connections on port 6379

[6020] 10 Aug 20:58:21 - 0 clientsconnected (0 slaves), 533432 bytes in use

[6020] 10 Aug 20:58:30 - 0 clientsconnected (0 slaves), 533432 bytes in use

还有就是执行：sysctl vm.overcommit_memory=1

关于redis一些资料的学习可以到http://www.cnblogs.com/xhan/archive/2011/02/08/1949867.html去学习
，很全面

下面介绍一个简单java客户端Jedis，大家可以到https://github.com/xetorthio/jedis这网址下载

redis作为NoSQL数据库的一种应用，响应速度和命中率上还是比较高效的。项目中需要用集中式可横向扩展的缓存框架，做了一点调研，即便redis、memcached存在效率上的差异（具体比较参考http://timyang.net/data/mcdb-tt-redis/），但其实都能满足目前项目的需求；但是redis还是比较风骚的，支持链表和集合操作，支持正则表达式查找key，目前项目缓存的结果大多是链表，如果链表新增或者修改数据的话，redis就体现出了极大的优势（memcached只能重新加载链表，redis可以对链表新增或者修改）

1：下载redis

下载地址 http://code.google.com/p/redis/downloads/list

推荐下载redis-1.2.6.tar.gz,之前这个版本同事已经有成功安装运行的经验，redis-2.0.4.tar.gz 这个版本我安装后无法操作缓存数据，具体原因后续再说

2：安装redis

下载后解压 tar zxvf redis-1.2.6.tar.gz 到任意目录，例如/usr/local/redis-1.2.6

解压后，进入redis目录

cd /usr/local/redis-1.2.6

make

拷贝文件

cp redis.conf /etc/ 这个文件时redis启动的配置文件

cp redis-benchmark redis-cli redis-server /usr/bin/ #这个倒是很有用，这样就不用再执行时加上./了，而且可以在任何地方执行

设置内存分配策略（可选，根据服务器的实际情况进行设置）

/proc/sys/vm/overcommit_memory

可选值：0、1、2。

0， 表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；否则，内存申请失败，并把错误返回给应用进程。

1， 表示内核允许分配所有的物理内存，而不管当前的内存状态如何。

2， 表示内核允许分配超过所有物理内存和交换空间总和的内存

值得注意的一点是，redis在dump数据的时候，会fork出一个子进程，理论上child进程所占用的内存和parent是一样的，比如parent占用的内存为8G，这个时候也要同样分配8G的内存给child,如果内存无法负担，往往会造成redis服务器的down机或者IO负载过高，效率下降。所以这里比较优化的内存分配策略应该设置为 1（表示内核允许分配所有的物理内存，而不管当前的内存状态如何）

开启redis端口，修改防火墙配置文件

vi /etc/sysconfig/iptables

加入端口配置

-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 6379 -j ACCEPT

重新加载规则

service iptables restart

3：启动redis服务

[[email protected] redis-1.2.6]# pwd

/usr/local/redis-1.2.6

[[email protected] redis-1.2.6]# redis-server /etc/redis.conf

查看进程，确认redis已经启动

[[email protected] redis-1.2.6]# ps -ef | grep redis

root       401 29222  0 18:06 pts/3    00:00:00 grep redis

root     29258     1  0 16:23 ?        00:00:00 redis-server /etc/redis.conf

如果这里启动redis服务失败，一般情况下是因为redis.conf文件有问题，建议检查或找个可用的配置文件进行覆盖，避免少走弯路，这里建议，修改redis.conf，设置redis进程为后台守护进程

# By default Redis does not run as a daemon. Use ‘yes‘ if you need it.

# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.

daemonize yes

4：测试redis

[[email protected] redis-1.2.6]# redis-cli

redis> set name songbin

OK

redis> get name

"songbin"

5：关闭redis服务

redis-cli shutdown

redis服务关闭后，缓存数据会自动dump到硬盘上，硬盘地址为redis.conf中的配置项dbfilename dump.rdb所设定

强制备份数据到磁盘，使用如下命令

redis-cli save 或者 redis-cli -p 6380 save（指定端口）

安装的时候，make完了之后再make install 就自动安装到/usr/local/bin下了，不用手动cp的

这里给大家提供一个简单的对jedis的封装类以供参考

Redis.java

[java] view plaincopyprint?

1. package com.ajun.redis;
2. import java.util.ArrayList;
3. import java.util.List;
4. import java.util.Set;
5. import java.util.TreeSet;
6. import redis.clients.jedis.Jedis;
7. import redis.clients.jedis.JedisPool;
8. import redis.clients.jedis.JedisPoolConfig;
9. /**
10. *
11. * @author ajun
12. *
13. */
14. public class Redis {
15. private static JedisPool pool;
16. private static int DBIndex=1;
17. private static String host="192.168.1.200";
18. private static int port=6379;
19. private static int timeout=60*1000;
20. static {
21. JedisPoolConfig config = new JedisPoolConfig();
22. config.setMaxActive(100);
23. config.setMaxIdle(20);
24. config.setMaxWait((long)1000);
25. config.setTestOnBorrow(false);
26. pool = new JedisPool(config, host, port, timeout);//线程数量限制，IP地址，端口，超时时间
27. }
28. /**
29. *  注意：
30. *  作为一个key value存在，很多开发者自然的使用set/get方式来使用Redis，实际上这并不是最优化的使用方法。
31. *  尤其在未启用VM情况下，Redis全部数据需要放入内存，节约内存尤其重要。
32. 假如一个key-value单元需要最小占用512字节，即使只存一个字节也占了512字节。
33. 这时候就有一个设计模式，可以把key复用，几个key-value放入一个key中，value再作为一个set存入，
34. 这样同样512字节就会存放10-100倍的容量。
35. 用于存储多个key-value的值，比如可以存储好多的person Object
36. 例子：>redis-cli
37. 存储：redis 127.0.0.1:6379> hset personhash personId personObject
38. 获得：redis 127.0.0.1:6379> hget personhash personId (就可以获得当前personId对应的person对象)
39. * @param key hashset key
40. * @param field 相当于personId
41. * @param value  person Object
42. */
43. public static void hsetItem(String key,String field,byte [] value){
44. Jedis jedis=null;
45. try {
46. jedis = pool.getResource();
47. jedis.connect();
48. jedis.select(DBIndex);
49. jedis.hset(key.getBytes(), field.getBytes(), value);
50. } catch (Exception e) {
51. e.printStackTrace();
52. }finally{
53. if(jedis!=null)
54. pool.returnResource(jedis);
55. }
56. }
57. public static byte []  hgetItem(String key,String field){
58. Jedis jedis=null;
59. byte [] value = null;
60. try {
61. jedis = pool.getResource();
62. jedis.connect();
63. jedis.select(DBIndex);
64. value= jedis.hget(key.getBytes(), field.getBytes());
65. //jedis.hgetAll(key);
66. } catch (Exception e) {
67. e.printStackTrace();
68. }finally{
69. if(jedis!=null)
70. pool.returnResource(jedis);
71. }
72. return value;
73. }
74. /**
75. * @param key
76. * @param value
77. * @param seconds 有效时间 秒为单位 0为永久有效
78. */
79. public static void setItem(String key ,byte [] value,int seconds){
80. Jedis jedis=null;
81. try {
82. jedis = pool.getResource();
83. jedis.connect();
84. jedis.select(DBIndex);
85. if(seconds==0){
86. jedis.set(key.getBytes(), value);
87. }else{
88. jedis.setex(key.getBytes(), seconds, value);
89. }
90. } catch (Exception e) {
91. e.printStackTrace();
92. }finally{
93. if(jedis!=null)
94. pool.returnResource(jedis);
95. }
96. }
97. /**
98. * 删除
99. * @param keys
100. */
101. public static void del(String... keys){
102. Jedis jedis=null;
103. if(keys!=null){
104. try {
105. jedis = pool.getResource();
106. jedis.connect();
107. jedis.select(DBIndex);
108. jedis.del(keys);
109. } catch (Exception e) {
110. e.printStackTrace();
111. }finally{
112. if(jedis!=null)
113. pool.returnResource(jedis);
114. }
115. }
116. }
117. /**
118. * 头部添加元素
119. * @param key
120. * @param value
121. */
122. public static void lpushToList(String key,byte[] value){
123. Jedis jedis=null;
124. try {
125. jedis = pool.getResource();
126. jedis.connect();
127. jedis.select(DBIndex);
128. jedis.lpush(key.getBytes(), value);
129. } catch (Exception e) {
130. e.printStackTrace();
131. }
132. finally{
133. if(jedis!=null)
134. pool.returnResource(jedis);
135. }
136. }
137. /**
138. * 返回List
139. * @param key
140. * @param value
141. */
142. public static List<byte[]>  lrangeFromList(String key,int start ,int end){
143. Jedis jedis=null;
144. List<byte[]> list = null;
145. try {
146. jedis = pool.getResource();
147. jedis.connect();
148. jedis.select(DBIndex);
149. list = jedis.lrange(key.getBytes(), start, end);
150. } catch (Exception e) {
151. e.printStackTrace();
152. }
153. finally{
154. if(jedis!=null)
155. pool.returnResource(jedis);
156. }
157. return list;
158. }
159. /**
160. *
161. * @param key key
162. * @param member 存储的value
163. * @param score 排序字段 一般为objecId
164. */
165. public static void addItemToSortSet(String key,byte[] member,double score){
166. Jedis jedis=null;
167. try {
168. jedis = pool.getResource();
169. jedis.connect();
170. jedis.select(DBIndex);
171. jedis.zadd(key.getBytes(), score, member);
172. } catch (Exception e) {
173. e.printStackTrace();
174. }finally{
175. if(jedis!=null)
176. pool.returnResource(jedis);
177. }
178. }
179. public static void addListToSortSet(String key,List<byte[]> list,List<Double> scores){
180. Jedis jedis=null;
181. try {
182. jedis = pool.getResource();
183. jedis.connect();
184. jedis.select(DBIndex);
185. if(list!=null&& !list.isEmpty()&& scores!=null&& !scores.isEmpty() && list.size()==scores.size()){
186. for(int i=0;i<list.size();i++){
187. jedis.zadd(key.getBytes(), scores.get(i), list.get(i));
188. }
189. }
190. } catch (Exception e) {
191. e.printStackTrace();
192. }finally{
193. if(jedis!=null)
194. pool.returnResource(jedis);
195. }
196. }
197. public static List<byte[]> getFromSortSet(String key,int start ,int end,OrderStatus orderStatus){
198. Jedis jedis=null;
199. List<byte[]> list = new ArrayList<byte[]>();
200. Set<byte[]> set= new TreeSet<byte[]>();
201. try {
202. jedis = pool.getResource();
203. jedis.connect();
204. jedis.select(DBIndex);
205. if(orderStatus.equals(OrderStatus.DESC)){
206. set = jedis.zrevrange(key.getBytes(), start, end);
207. }else{
208. set = jedis.zrange(key.getBytes(), start, end);
209. }
210. if(set!=null && !set.isEmpty()){
211. for(byte[] b:set){
212. list.add(b);
213. }
214. }
215. } catch (Exception e) {
216. e.printStackTrace();
217. }finally{
218. if(jedis!=null)
219. pool.returnResource(jedis);
220. }
221. return list;
222. }
223. public static byte[] getItem(String key)
224. {
225. Jedis jedis=null;
226. byte[] s=null;
227. try {
228. jedis = pool.getResource();
229. jedis.select(DBIndex);
230. s = jedis.get(key.getBytes());
231. return s;
232. } catch (Exception e) {
233. e.printStackTrace();
234. return s;
235. }
236. finally{
237. if(jedis!=null)
238. pool.returnResource(jedis);
239. }
240. }
241. public static void delItem(String key)
242. {
243. Jedis jedis=null;
244. try {
245. jedis = pool.getResource();
246. jedis.select(DBIndex);
247. jedis.del(key.getBytes());
248. } catch (Exception e) {
249. e.printStackTrace();
250. }
251. finally{
252. if(jedis!=null)
253. pool.returnResource(jedis);
254. }
255. }
256. public static long getIncrement(String key)
257. {
258. Jedis jedis=null;
259. try {
260. jedis = pool.getResource();
261. jedis.select(DBIndex);
262. return jedis.incr(key);
263. } catch (Exception e) {
264. e.printStackTrace();
265. return 0L;
266. }
267. finally{
268. if(jedis!=null)
269. pool.returnResource(jedis);
270. }
271. }
272. public static void getkeys(String pattern){
273. Jedis jedis=null;
274. try {
275. jedis = pool.getResource();
276. jedis.select(DBIndex);
277. Set<String> keys = jedis.keys(pattern);
278. for(String b:keys){
279. System.out.println("keys==> "+b);
280. }
281. } catch (Exception e) {
282. e.printStackTrace();
283. }
284. finally{
285. if(jedis!=null)
286. pool.returnResource(jedis);
287. }
288. }
289. }

Linux 下 Redis使用介绍,布布扣,bubuko.com