图文详解Windows下使用Redis缓存工具的方法

一、简介

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)和zset(有序集合)。

这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis

是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。

二、下载redis

Redis 官网 ：http://redis.io/

下载页面：http://redis.io/download

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

Windows 版本下载：https://github.com/dmajkic/redis/downloads

三、环境搭建

1. 放到磁盘里面。

2.根据操作系统 进入相应的目录 ，启动redis服务端 redis-server.exe redis.conf

3.根据操作系统 进入相应的目录 ，启动redis客户端。

4. 测试redis缓存机制。

1. redis-cli.exe -h 127.0.0.1 -p 6379 
2.   
3. set keytest valuestest 
4.   
5. get keytest 

5. 效果如下：

6. 测试调换顺序调用的实例。

这个应用可以用在验证码的校验用以及缓存。

第一个号码 18276487300 发送了一个验证码”1234“，然后存到key-values 里面。

第二个号码 18276487301 发送了一个验证码”2345“，然后存到key-values 里面。

但是第二个验证码先进行验证，所以会先通过18276487301 来获取验证码。

这样就防止了一些验证码不知道对应哪个手机号码了。

后面会根据java配置到项目中应用。

四、redis.conf 配置文件

根据操作系统 进入相应的目录 ，会看到一个配置文件redis.conf。

配置文件的原文如下：

1. # Redis configuration file example 
2.   
3. # Note on units: when memory size is needed, it is possible to specifiy 
4. # it in the usual form of 1k 5GB 4M and so forth: 
5. # 
6. # 1k => 1000 bytes 
7. # 1kb => 1024 bytes 
8. # 1m => 1000000 bytes 
9. # 1mb => 1024*1024 bytes 
10. # 1g => 1000000000 bytes 
11. # 1gb => 1024*1024*1024 bytes 
12. # 
13. # units are case insensitive so 1GB 1Gb 1gB are all the same. 
14.   
15. # By default Redis does not run as a daemon. Use 'yes' if you need it. 
16. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized. 
17. daemonize no 
18.   
19. # When running daemonized, Redis writes a pid file in /var/run/redis.pid by 
20. # default. You can specify a custom pid file location here. 
21. pidfile /var/run/redis.pid 
22.   
23. # Accept connections on the specified port, default is 6379. 
24. # If port 0 is specified Redis will not listen on a TCP socket. 
25. port 6379 
26.   
27. # If you want you can bind a single interface, if the bind option is not 
28. # specified all the interfaces will listen for incoming connections. 
29. # 
30. # bind 127.0.0.1 
31.   
32. # Specify the path for the unix socket that will be used to listen for 
33. # incoming connections. There is no default, so Redis will not listen 
34. # on a unix socket when not specified. 
35. # 
36. # unixsocket /tmp/redis.sock 
37. # unixsocketperm 755 
38.   
39. # Close the connection after a client is idle for N seconds (0 to disable) 
40. timeout 0 
41.   
42. # Set server verbosity to 'debug' 
43. # it can be one of: 
44. # debug (a lot of information, useful for development/testing) 
45. # verbose (many rarely useful info, but not a mess like the debug level) 
46. # notice (moderately verbose, what you want in production probably) 
47. # warning (only very important / critical messages are logged) 
48. loglevel verbose 
49.   
50. # Specify the log file name. Also 'stdout' can be used to force 
51. # Redis to log on the standard output. Note that if you use standard 
52. # output for logging but daemonize, logs will be sent to /dev/null 
53. logfile stdout 
54.   
55. # To enable logging to the system logger, just set 'syslog-enabled' to yes, 
56. # and optionally update the other syslog parameters to suit your needs. 
57. # syslog-enabled no 
58.   
59. # Specify the syslog identity. 
60. # syslog-ident redis 
61.   
62. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7. 
63. # syslog-facility local0 
64.   
65. # Set the number of databases. The default database is DB 0, you can select 
66. # a different one on a per-connection basis using SELECT <dbid> where 
67. # dbid is a number between 0 and 'databases'-1 
68. databases 16 
69.   
70. ################################ SNAPSHOTTING ################################# 
71. # 
72. # Save the DB on disk: 
73. # 
74. #  save <seconds> <changes> 
75. # 
76. #  Will save the DB if both the given number of seconds and the given 
77. #  number of write operations against the DB occurred. 
78. # 
79. #  In the example below the behaviour will be to save: 
80. #  after 900 sec (15 min) if at least 1 key changed 
81. #  after 300 sec (5 min) if at least 10 keys changed 
82. #  after 60 sec if at least 10000 keys changed 
83. # 
84. #  Note: you can disable saving at all commenting all the "save" lines. 
85.   
86. save 900 1 
87. save 300 10 
88. save 60 10000 
89.   
90. # Compress string objects using LZF when dump .rdb databases? 
91. # For default that's set to 'yes' as it's almost always a win. 
92. # If you want to save some CPU in the saving child set it to 'no' but 
93. # the dataset will likely be bigger if you have compressible values or keys. 
94. rdbcompression yes 
95.   
96. # The filename where to dump the DB 
97. dbfilename dump.rdb 
98.   
99. # The working directory. 
100. # 
101. # The DB will be written inside this directory, with the filename specified 
102. # above using the 'dbfilename' configuration directive. 
103. #  
104. # Also the Append Only File will be created inside this directory. 
105. #  
106. # Note that you must specify a directory here, not a file name. 
107. dir ./ 
108.   
109. ################################# REPLICATION ################################# 
110.   
111. # Master-Slave replication. Use slaveof to make a Redis instance a copy of 
112. # another Redis server. Note that the configuration is local to the slave 
113. # so for example it is possible to configure the slave to save the DB with a 
114. # different interval, or to listen to another port, and so on. 
115. # 
116. # slaveof <masterip> <masterport> 
117.   
118. # If the master is password protected (using the "requirepass" configuration 
119. # directive below) it is possible to tell the slave to authenticate before 
120. # starting the replication synchronization process, otherwise the master will 
121. # refuse the slave request. 
122. # 
123. # masterauth <master-password> 
124.   
125. # When a slave lost the connection with the master, or when the replication 
126. # is still in progress, the slave can act in two different ways: 
127. # 
128. # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will 
129. #  still reply to client requests, possibly with out of data data, or the 
130. #  data set may just be empty if this is the first synchronization. 
131. # 
132. # 2) if slave-serve-stale data is set to 'no' the slave will reply with 
133. #  an error "SYNC with master in progress" to all the kind of commands 
134. #  but to INFO and SLAVEOF. 
135. # 
136. slave-serve-stale-data yes 
137.   
138. # Slaves send PINGs to server in a predefined interval. It's possible to change 
139. # this interval with the repl_ping_slave_period option. The default value is 10 
140. # seconds. 
141. # 
142. # repl-ping-slave-period 10 
143.   
144. # The following option sets a timeout for both Bulk transfer I/O timeout and 
145. # master data or ping response timeout. The default value is 60 seconds. 
146. # 
147. # It is important to make sure that this value is greater than the value 
148. # specified for repl-ping-slave-period otherwise a timeout will be detected 
149. # every time there is low traffic between the master and the slave. 
150. # 
151. # repl-timeout 60 
152.   
153. ################################## SECURITY ################################### 
154.   
155. # Require clients to issue AUTH <PASSWORD> before processing any other 
156. # commands. This might be useful in environments in which you do not trust 
157. # others with access to the host running redis-server. 
158. # 
159. # This should stay commented out for backward compatibility and because most 
160. # people do not need auth (e.g. they run their own servers). 
161. #  
162. # Warning: since Redis is pretty fast an outside user can try up to 
163. # 150k passwords per second against a good box. This means that you should 
164. # use a very strong password otherwise it will be very easy to break. 
165. # 
166. # requirepass foobared 
167.   
168. # Command renaming. 
169. # 
170. # It is possilbe to change the name of dangerous commands in a shared 
171. # environment. For instance the CONFIG command may be renamed into something 
172. # of hard to guess so that it will be still available for internal-use 
173. # tools but not available for general clients. 
174. # 
175. # Example: 
176. # 
177. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52 
178. # 
179. # It is also possilbe to completely kill a command renaming it into 
180. # an empty string: 
181. # 
182. # rename-command CONFIG "" 
183.   
184. ################################### LIMITS #################################### 
185.   
186. # Set the max number of connected clients at the same time. By default there 
187. # is no limit, and it's up to the number of file descriptors the Redis process 
188. # is able to open. The special value '0' means no limits. 
189. # Once the limit is reached Redis will close all the new connections sending 
190. # an error 'max number of clients reached'. 
191. # 
192. # maxclients 128 
193.   
194. # Don't use more memory than the specified amount of bytes. 
195. # When the memory limit is reached Redis will try to remove keys with an 
196. # EXPIRE set. It will try to start freeing keys that are going to expire 
197. # in little time and preserve keys with a longer time to live. 
198. # Redis will also try to remove objects from free lists if possible. 
199. # 
200. # If all this fails, Redis will start to reply with errors to commands 
201. # that will use more memory, like SET, LPUSH, and so on, and will continue 
202. # to reply to most read-only commands like GET. 
203. # 
204. # WARNING: maxmemory can be a good idea mainly if you want to use Redis as a 
205. # 'state' server or cache, not as a real DB. When Redis is used as a real 
206. # database the memory usage will grow over the weeks, it will be obvious if 
207. # it is going to use too much memory in the long run, and you'll have the time 
208. # to upgrade. With maxmemory after the limit is reached you'll start to get 
209. # errors for write operations, and this may even lead to DB inconsistency. 
210. # 
211. # maxmemory <bytes> 
212.   
213. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory 
214. # is reached? You can select among five behavior: 
215. #  
216. # volatile-lru -> remove the key with an expire set using an LRU algorithm 
217. # allkeys-lru -> remove any key accordingly to the LRU algorithm 
218. # volatile-random -> remove a random key with an expire set 
219. # allkeys->random -> remove a random key, any key 
220. # volatile-ttl -> remove the key with the nearest expire time (minor TTL) 
221. # noeviction -> don't expire at all, just return an error on write operations 
222. #  
223. # Note: with all the kind of policies, Redis will return an error on write 
224. #    operations, when there are not suitable keys for eviction. 
225. # 
226. #    At the date of writing this commands are: set setnx setex append 
227. #    incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd 
228. #    sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby 
229. #    zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby 
230. #    getset mset msetnx exec sort 
231. # 
232. # The default is: 
233. # 
234. # maxmemory-policy volatile-lru 
235.   
236. # LRU and minimal TTL algorithms are not precise algorithms but approximated 
237. # algorithms (in order to save memory), so you can select as well the sample 
238. # size to check. For instance for default Redis will check three keys and 
239. # pick the one that was used less recently, you can change the sample size 
240. # using the following configuration directive. 
241. # 
242. # maxmemory-samples 3 
243.   
244. ############################## APPEND ONLY MODE ############################### 
245.   
246. # By default Redis asynchronously dumps the dataset on disk. If you can live 
247. # with the idea that the latest records will be lost if something like a crash 
248. # happens this is the preferred way to run Redis. If instead you care a lot 
249. # about your data and don't want to that a single record can get lost you should 
250. # enable the append only mode: when this mode is enabled Redis will append 
251. # every write operation received in the file appendonly.aof. This file will 
252. # be read on startup in order to rebuild the full dataset in memory. 
253. # 
254. # Note that you can have both the async dumps and the append only file if you 
255. # like (you have to comment the "save" statements above to disable the dumps). 
256. # Still if append only mode is enabled Redis will load the data from the 
257. # log file at startup ignoring the dump.rdb file. 
258. # 
259. # IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append 
260. # log file in background when it gets too big. 
261.   
262. appendonly no 
263.   
264. # The name of the append only file (default: "appendonly.aof") 
265. # appendfilename appendonly.aof 
266.   
267. # The fsync() call tells the Operating System to actually write data on disk 
268. # instead to wait for more data in the output buffer. Some OS will really flush  
269. # data on disk, some other OS will just try to do it ASAP. 
270. # 
271. # Redis supports three different modes: 
272. # 
273. # no: don't fsync, just let the OS flush the data when it wants. Faster. 
274. # always: fsync after every write to the append only log . Slow, Safest. 
275. # everysec: fsync only if one second passed since the last fsync. Compromise. 
276. # 
277. # The default is "everysec" that's usually the right compromise between 
278. # speed and data safety. It's up to you to understand if you can relax this to 
279. # "no" that will will let the operating system flush the output buffer when 
280. # it wants, for better performances (but if you can live with the idea of 
281. # some data loss consider the default persistence mode that's snapshotting), 
282. # or on the contrary, use "always" that's very slow but a bit safer than 
283. # everysec. 
284. # 
285. # If unsure, use "everysec". 
286.   
287. # appendfsync always 
288. appendfsync everysec 
289. # appendfsync no 
290.   
291. # When the AOF fsync policy is set to always or everysec, and a background 
292. # saving process (a background save or AOF log background rewriting) is 
293. # performing a lot of I/O against the disk, in some Linux configurations 
294. # Redis may block too long on the fsync() call. Note that there is no fix for 
295. # this currently, as even performing fsync in a different thread will block 
296. # our synchronous write(2) call. 
297. # 
298. # In order to mitigate this problem it's possible to use the following option 
299. # that will prevent fsync() from being called in the main process while a 
300. # BGSAVE or BGREWRITEAOF is in progress. 
301. # 
302. # This means that while another child is saving the durability of Redis is 
303. # the same as "appendfsync none", that in pratical terms means that it is 
304. # possible to lost up to 30 seconds of log in the worst scenario (with the 
305. # default Linux settings). 
306. #  
307. # If you have latency problems turn this to "yes". Otherwise leave it as 
308. # "no" that is the safest pick from the point of view of durability. 
309. no-appendfsync-on-rewrite no 
310.   
311. # Automatic rewrite of the append only file. 
312. # Redis is able to automatically rewrite the log file implicitly calling 
313. # BGREWRITEAOF when the AOF log size will growth by the specified percentage. 
314. #  
315. # This is how it works: Redis remembers the size of the AOF file after the 
316. # latest rewrite (or if no rewrite happened since the restart, the size of 
317. # the AOF at startup is used). 
318. # 
319. # This base size is compared to the current size. If the current size is 
320. # bigger than the specified percentage, the rewrite is triggered. Also 
321. # you need to specify a minimal size for the AOF file to be rewritten, this 
322. # is useful to avoid rewriting the AOF file even if the percentage increase 
323. # is reached but it is still pretty small. 
324. # 
325. # Specify a precentage of zero in order to disable the automatic AOF 
326. # rewrite feature. 
327.   
328. auto-aof-rewrite-percentage 100 
329. auto-aof-rewrite-min-size 64mb 
330.   
331. ################################## SLOW LOG ################################### 
332.   
333. # The Redis Slow Log is a system to log queries that exceeded a specified 
334. # execution time. The execution time does not include the I/O operations 
335. # like talking with the client, sending the reply and so forth, 
336. # but just the time needed to actually execute the command (this is the only 
337. # stage of command execution where the thread is blocked and can not serve 
338. # other requests in the meantime). 
339. #  
340. # You can configure the slow log with two parameters: one tells Redis 
341. # what is the execution time, in microseconds, to exceed in order for the 
342. # command to get logged, and the other parameter is the length of the 
343. # slow log. When a new command is logged the oldest one is removed from the 
344. # queue of logged commands. 
345.   
346. # The following time is expressed in microseconds, so 1000000 is equivalent 
347. # to one second. Note that a negative number disables the slow log, while 
348. # a value of zero forces the logging of every command. 
349. slowlog-log-slower-than 10000 
350.   
351. # There is no limit to this length. Just be aware that it will consume memory. 
352. # You can reclaim memory used by the slow log with SLOWLOG RESET. 
353. slowlog-max-len 1024 
354.   
355. ################################ VIRTUAL MEMORY ############################### 
356.   
357. ### WARNING! Virtual Memory is deprecated in Redis 2.4 
358. ### The use of Virtual Memory is strongly discouraged. 
359.   
360. ### WARNING! Virtual Memory is deprecated in Redis 2.4 
361. ### The use of Virtual Memory is strongly discouraged. 
362.   
363. # Virtual Memory allows Redis to work with datasets bigger than the actual 
364. # amount of RAM needed to hold the whole dataset in memory. 
365. # In order to do so very used keys are taken in memory while the other keys 
366. # are swapped into a swap file, similarly to what operating systems do 
367. # with memory pages. 
368. # 
369. # To enable VM just set 'vm-enabled' to yes, and set the following three 
370. # VM parameters accordingly to your needs. 
371.   
372. vm-enabled no 
373. # vm-enabled yes 
374.   
375. # This is the path of the Redis swap file. As you can guess, swap files 
376. # can't be shared by different Redis instances, so make sure to use a swap 
377. # file for every redis process you are running. Redis will complain if the 
378. # swap file is already in use. 
379. # 
380. # The best kind of storage for the Redis swap file (that's accessed at random)  
381. # is a Solid State Disk (SSD). 
382. # 
383. # *** WARNING *** if you are using a shared hosting the default of putting 
384. # the swap file under /tmp is not secure. Create a dir with access granted 
385. # only to Redis user and configure Redis to create the swap file there. 
386. vm-swap-file /tmp/redis.swap 
387.   
388. # vm-max-memory configures the VM to use at max the specified amount of 
389. # RAM. Everything that deos not fit will be swapped on disk *if* possible, that 
390. # is, if there is still enough contiguous space in the swap file. 
391. # 
392. # With vm-max-memory 0 the system will swap everything it can. Not a good 
393. # default, just specify the max amount of RAM you can in bytes, but it's 
394. # better to leave some margin. For instance specify an amount of RAM 
395. # that's more or less between 60 and 80% of your free RAM. 
396. vm-max-memory 0 
397.   
398. # Redis swap files is split into pages. An object can be saved using multiple 
399. # contiguous pages, but pages can't be shared between different objects. 
400. # So if your page is too big, small objects swapped out on disk will waste 
401. # a lot of space. If you page is too small, there is less space in the swap 
402. # file (assuming you configured the same number of total swap file pages). 
403. # 
404. # If you use a lot of small objects, use a page size of 64 or 32 bytes. 
405. # If you use a lot of big objects, use a bigger page size. 
406. # If unsure, use the default :) 
407. vm-page-size 32 
408.   
409. # Number of total memory pages in the swap file. 
410. # Given that the page table (a bitmap of free/used pages) is taken in memory, 
411. # every 8 pages on disk will consume 1 byte of RAM. 
412. # 
413. # The total swap size is vm-page-size * vm-pages 
414. # 
415. # With the default of 32-bytes memory pages and 134217728 pages Redis will 
416. # use a 4 GB swap file, that will use 16 MB of RAM for the page table. 
417. # 
418. # It's better to use the smallest acceptable value for your application, 
419. # but the default is large in order to work in most conditions. 
420. vm-pages 134217728 
421.   
422. # Max number of VM I/O threads running at the same time. 
423. # This threads are used to read/write data from/to swap file, since they 
424. # also encode and decode objects from disk to memory or the reverse, a bigger 
425. # number of threads can help with big objects even if they can't help with 
426. # I/O itself as the physical device may not be able to couple with many 
427. # reads/writes operations at the same time. 
428. # 
429. # The special value of 0 turn off threaded I/O and enables the blocking 
430. # Virtual Memory implementation. 
431. vm-max-threads 4 
432.   
433. ############################### ADVANCED CONFIG ############################### 
434.   
435. # Hashes are encoded in a special way (much more memory efficient) when they 
436. # have at max a given numer of elements, and the biggest element does not 
437. # exceed a given threshold. You can configure this limits with the following 
438. # configuration directives. 
439. hash-max-zipmap-entries 512 
440. hash-max-zipmap-value 64 
441.   
442. # Similarly to hashes, small lists are also encoded in a special way in order 
443. # to save a lot of space. The special representation is only used when 
444. # you are under the following limits: 
445. list-max-ziplist-entries 512 
446. list-max-ziplist-value 64 
447.   
448. # Sets have a special encoding in just one case: when a set is composed 
449. # of just strings that happens to be integers in radix 10 in the range 
450. # of 64 bit signed integers. 
451. # The following configuration setting sets the limit in the size of the 
452. # set in order to use this special memory saving encoding. 
453. set-max-intset-entries 512 
454.   
455. # Similarly to hashes and lists, sorted sets are also specially encoded in 
456. # order to save a lot of space. This encoding is only used when the length and 
457. # elements of a sorted set are below the following limits: 
458. zset-max-ziplist-entries 128 
459. zset-max-ziplist-value 64 
460.   
461. # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in 
462. # order to help rehashing the main Redis hash table (the one mapping top-level 
463. # keys to values). The hash table implementation redis uses (see dict.c) 
464. # performs a lazy rehashing: the more operation you run into an hash table 
465. # that is rhashing, the more rehashing "steps" are performed, so if the 
466. # server is idle the rehashing is never complete and some more memory is used 
467. # by the hash table. 
468. #  
469. # The default is to use this millisecond 10 times every second in order to 
470. # active rehashing the main dictionaries, freeing memory when possible. 
471. # 
472. # If unsure: 
473. # use "activerehashing no" if you have hard latency requirements and it is 
474. # not a good thing in your environment that Redis can reply form time to time 
475. # to queries with 2 milliseconds delay. 
476. # 
477. # use "activerehashing yes" if you don't have such hard requirements but 
478. # want to free memory asap when possible. 
479. activerehashing yes 
480.   
481. ################################## INCLUDES ################################### 
482.   
483. # Include one or more other config files here. This is useful if you 
484. # have a standard template that goes to all redis server but also need 
485. # to customize a few per-server settings. Include files can include 
486. # other files, so use this wisely. 
487. # 
488. # include /path/to/local.conf 
489. # include /path/to/other.conf 

解析过的配置文件：

1. #是否以后台守护进程运行，默认为no, 取值yes, no  
2. daemonize no           
3.   
4. #pid文件存放路径 
5. pidfile /var/run/redis.pid   
6.   
7. #配置redis端口，默认6379 
8. port 6379          
9.   
10. #绑定ip。默认绑定所有本机ip，一般用在服务器多ip下，可以只监听内网服务器ip，保证服务安全 
11. bind 127.0.0.1       
12.   
13. #sock文件  
14. unixsocket /tmp/redis.sock  
15.   
16. #客户端超时时间，单位秒  
17. timeout 300        
18.   
19. #log级别，支持四个级别，debug，notice，verbose，warning  
20. loglevel verbose       
21.   
22. #log文件路径 
23. logfile           
24.   
25. #log输出到标准设备，logs不写文件，输出到空设备，/deb/null 
26. logfile stdout         
27.   
28. #保存快照的频率，在多长时间内执行一定数量的写操作时，保存快照的频率，可以设置多个条件。如果都注释掉，则不做内存数据持久化。如果只是把redis只用作cache，不开启持久化功能 
29. save <seconds> <changes>  
30. save 900 1 
31.   
32. #是否使用压缩 
33. rdbcompression       
34.   
35. #快照数据库名称  
36. dbfilename         
37.   
38. #数据库存放路径  
39. dir             
40.   
41. #redis主从 做法 在从上填上主的IP和端口号 主上不用做任何设置 
42. slaveof <masterip> <masterport>   
43.   
44. #主库服务器口令，如果主服务器未打开requirepass，则不需要此项 
45. masterauth <master-password>    
46.   
47. #在master服务器挂掉或者同步失败时，从服务器是否继续提供服务 
48. slave-serve-stale-data yes      
49.   
50. #设置redis服务密码，如果开启，则客户端连接时需要 -a 指定密码，否则操作会提示无权限 
51. requirepass foobared         
52.   
53. #命令改名，相当于linux alias，可以用改功能屏蔽一些危险命令 
54. rename-command           
55.   
56. #最大连接数；0 表示不限制 
57. maxclients 128          
58.   
59. #最大使用内存(分配的内存)，推荐生产环境下做相应调整，我们用的是只用来做高速缓存，限制2G。默认情况下，redis会占用可用的所有内存 
60. maxmemory <bytes>         
61.   
62. #过期策略，提供六种策略  
63. maxmemory-policy volatile-lru   
64. volatile-lru  //删除过期和lru 的key(默认值)  
65. allkeys-lru   //删除lru算法的key  
66. volatile-random //随机删除即将过期key  
67. allkeys->random //随机删除  
68. volatile-ttl  //删除即将过期的  
69. noeviction   //永不过期，返回错误  
70.   
71. #是否开启appendonlylog，开启的话每次写操作会记一条log。相当于mysql的binlog；不同的是，每次redis启动都会读此文件构建完整数据。即使删除rdb文件，数据也是安全的  
72. appendonly   
73.   
74. #日志文件的名称，默认appendonly.aof 
75. appendfilename appendonly.aof   
76.   
77. #异步写append file 的策略。类似mysql事物log写方式。三种 
78. appendfsync             
79. appendfsync always        //同步，每次写都要flush到磁盘，安全，速度慢。  
80. appendfsync everysec       //每秒写（默认值，推荐值）同mysql  
81. appendfsync no          //交给操作系统去做flush的动作  
82.   
83. #虚拟内存开关  
84. vm-enabled no         
85.   
86. #swap文件，不同redis swap文件不能共享。而且生产环境下，不建议放在tmp目录 
87. vm-swap-file /tmp/redis.swap    
88.   
89. #vm大小限制。0：不限制，建议60-80% 可用内存大小 
90. vm-max-memory 0         
91.   
92. #根据缓存内容大小调整，默认32字节 
93. vm-page-size 32        
94.   
95. #page数。每 8 page，会占用1字节内存。vm-page-size * vm-pages 等于 swap 文件大小 
96. vm-pages 134217728       
97.   
98. #vm 最大io线程数。注意： 0 标志禁止使用vm  
99. vm-max-threads 4  

以上就是Windows环境下使用Redis缓存工具的图文详细方法，希望对大家的学习有所帮助。