memcached的使用
1. 下载memcached客户端文件把下载文件放在文件目录下
2. 安装 memcached
命令： c:/memcached/memcached.exe-d install
3. 启动 memcached
c:/memcached/memcached.exe -dstart
4. 连接到 memcached
telnet localhost 11211
5:客户端使用的基本命令
启动/结束
memcached -d -m 10 -u root -l 127.0.0.1 -p 11200 -c 256 -P /tmp/memcached.pid
-d 选项是启动一个守护进程
-m 是分配给Memcache使用的内存数量，单位是MB，这里是10MB
-u 是运行Memcache的用户，这里是root
-l 是监听的服务器IP地址，如果有多个地址的话，这里指定了服务器的IP地址127.0.0.1
-p 是设置Memcache监听的端口，这里设置了12000，最好是1024以上的端口
-c 选项是最大运行的并发连接数，默认是1024，这里设置了256，按照你服务器的负载量来设定
-P 是设置保存Memcache的pid文件
kill `cat /tmp/memcached.pid`关闭memcached
6：在项目中使用（与Spring集成）
获取Memcached API 地址 ：
创建接口MemcachedClient
1import java.util.Collection;
2 import java.util.Map;
3 import java.util.concurrent.TimeoutException;
4
5 /**
6* 提供通用的memcached访问接口
7*/
8 public interface MemcachedClient {
9 /**
10 * 不管数据存在不存在都会将目前设置的数据存储的memcached
11 *
12 * @param key
13 * 不要超过250字节
14 * @param exp
15 * 以秒为单位，如果超过30天的值，将会用unix timestamp来制定截止有效时间
16 * @param value
17 * @return
18 * @throws TimeoutException
19 * @throws InterruptedException
20 * @throws MemcachedClientException
21 */
22 boolean set(String key, int exp, Object value) throws TimeoutException,
23 InterruptedException, MemcachedClientException;
24
25 /**
26 * 不管数据存在不存在都会将目前设置的数据存储的memcached,自行制定超时时间
27 *
28 * @see #set(String, int, Object)
29 * @param key
30 * @param exp
31 * @param value
32 * @param timeout
33 * @return
34 * @throws TimeoutException
35 * @throws InterruptedException
36 * @throws MemcachedClientException
37 */
38 boolean set(String key, int exp, Object value, long timeout)
39 throws TimeoutException, InterruptedException,
40 MemcachedClientException;
41
42 /**
43 * 不管数据存在不存在都会将目前设置的数据存储的memcached，但不等待返回确认
44 *
45 * @see #set(String, int, Object)
46 * @param key
47 * @param exp
48 * @param value
49 * @throws InterruptedException
50 * @throws MemcachedClientException
51 */
52 void setWithNoReply(String key, int exp, Object value)
53 throws InterruptedException, MemcachedClientException;
54
55 /**
56 * 只有数据不存在时进行添加
57 *
58 * @param key
59 * 不要超过250字节
60 * @param exp
61 * 以秒为单位，如果超过30天的值，将会用unix timestamp来制定截止有效时间
62 * @param value
63 * @return
64 * @throws TimeoutException
65 * @throws InterruptedException
66 * @throws MemcachedClientException
67 */
68 boolean add(String key, int exp, Object value) throws TimeoutException,
69 InterruptedException, MemcachedClientException;
70
71 /**
72 * 只有数据不存在时进行添加
73 *
74 * @param key
75 * @param exp
76 * 以秒为单位，如果超过30天的值，将会用unix timestamp来制定截止有效时间
77 * @param value
78 * @param timeout
79 * 1/1000秒为单位，在制定的时间段内没有响应就抛出TimeoutException
80 * @return
81 * @throws TimeoutException
82 * @throws InterruptedException
83 * @throws MemcachedClientException
84 */
85 boolean add(String key, int exp, Object value, long timeout)
86 throws TimeoutException, InterruptedException,
87 MemcachedClientException;
88
89 /**
90 * 只有数据不存在时进行添加，不需要返回具体的确认信息，大多数情况下可以用此方法来提升效率，毕竟我们对Memcached的理解是假设数据不是持久的
91 *
92 * @param key
93 * @param exp
94 * @param value
95 * @throws InterruptedException
96 * @throws MemcachedClientException
97 */
98 void addWithNoReply(String key, int exp, Object value)
99 throws InterruptedException, MemcachedClientException;
100
101 /**
102 * 只有数据存在才进行覆盖
103 *
104 * @param key
105 * @param exp
106 * @param value
107 * @return
108 * @throws TimeoutException
109 * @throws InterruptedException
110 * @throws MemcachedClientException
111 */
112 boolean replace(String key, int exp, Object value) throws TimeoutException,
113 InterruptedException, MemcachedClientException;
114
115 /**
116 * 只有数据存在才进行覆盖
117 *
118 * @param key
119 * @param exp
120 * @param value
121 * @param timeout
122 * @return
123 * @throws TimeoutException
124 * @throws InterruptedException
125 * @throws MemcachedClientException
126 */
127 boolean replace(String key, int exp, Object value, long timeout)
128 throws TimeoutException, InterruptedException,
129 MemcachedClientException;
130
131 /**
132 * 只有数据存在才进行覆盖，不等返回确认
133 *
134 * @param key
135 * @param exp
136 * @param value
137 * @throws InterruptedException
138 * @throws MemcachedClientException
139 */
140 void replaceWithNoReply(String key, int exp, Object value)
141 throws InterruptedException, MemcachedClientException;
142
143 /**
144 * 追加到当前数据的后面
145 *
146 * @param key
147 * @param value
148 * @return
149 * @throws TimeoutException
150 * @throws InterruptedException
151 * @throws MemcachedClientException
152 */
153 boolean append(String key, Object value) throws TimeoutException,
154 InterruptedException, MemcachedClientException;
155
156 /**
157 * 追加到当前数据的后面
158 *
159 * @param key
160 * @param value
161 * @param timeout
162 * @return
163 * @throws TimeoutException
164 * @throws InterruptedException
165 * @throws MemcachedClientException
166 */
167 boolean append(String key, Object value, long timeout)
168 throws TimeoutException, InterruptedException,
169 MemcachedClientException;
170
171 /**
172 * 追加到当前数据的后面,不等待响应
173 *
174 * @param key
175 * @param value
176 * @throws InterruptedException
177 * @throws MemcachedClientException
178 */
179 void appendWithNoReply(String key, Object value)
180 throws InterruptedException, MemcachedClientException;
181
182 /**
183 * 追加到当前数据的前面
184 *
185 * @param key
186 * @param value
187 * @return
188 * @throws TimeoutException
189 * @throws InterruptedException
190 * @throws MemcachedClientException
191 */
192 boolean prepend(String key, Object value) throws TimeoutException,
193 InterruptedException, MemcachedClientException;
194
195 /**
196 * 追加到当前数据的前面
197 *
198 * @param key
199 * @param value
200 * @param timeout
201 * @return
202 * @throws TimeoutException
203 * @throws InterruptedException
204 * @throws MemcachedClientException
205 */
206 boolean prepend(String key, Object value, long timeout)
207 throws TimeoutException, InterruptedException,
208 MemcachedClientException;
209
210 /**
211 * 追加到当前数据的前面,不等待返回
212 *
213 * @param key
214 * @param value
215 * @throws InterruptedException
216 * @throws MemcachedClientException
217 */
218 void prependWithNoReply(String key, Object value)
219 throws InterruptedException, MemcachedClientException;
220
221 long incr(String key, long delta, long initValue) throws TimeoutException,
222 InterruptedException, MemcachedClientException;
223
224 long incr(String key, long delta, long initValue, long timeout)
225 throws TimeoutException, InterruptedException,
226 MemcachedClientException;
227
228 void incrWithNoReply(String key, long delta) throws InterruptedException,
229 MemcachedClientException;
230
231 long decr(String key, long delta, long initValue) throws TimeoutException,
232 InterruptedException, MemcachedClientException;
233
234 long decr(String key, long delta, long initValue, long timeout)
235 throws TimeoutException, InterruptedException,
236 MemcachedClientException;
237
238 void decrWithNoReply(String key, long delta) throws InterruptedException,
239 MemcachedClientException;
240
241 boolean delete(String key) throws TimeoutException, InterruptedException,
242 MemcachedClientException;
243
244 boolean delete(String key, long opTimeout) throws TimeoutException,
245 InterruptedException, MemcachedClientException;
246
247 boolean delete(String key, long cas, long opTimeout)
248 throws TimeoutException, InterruptedException,
249 MemcachedClientException;
250
251 void deleteWithNoReply(String key) throws InterruptedException,
252 MemcachedClientException;
253
254 <T> T get(String key) throws TimeoutException, InterruptedException,
255 MemcachedClientException;
256
257 <T> T get(String key, long timeout) throws TimeoutException,
258 InterruptedException, MemcachedClientException;
259
260 <T> Map<String, T> get(Collection<String> keyCollections)
261 throws TimeoutException, InterruptedException,
262 MemcachedClientException;
263
264 <T> Map<String, T> get(Collection<String> keyCollections, long timeout)
265 throws TimeoutException, InterruptedException,
266 MemcachedClientException;
267
268 <T> GetsResponse<T> gets(String key) throws TimeoutException,
269 InterruptedException, MemcachedClientException;
270
271 <T> GetsResponse<T> gets(String key, long timeout) throws TimeoutException,
272 InterruptedException, MemcachedClientException;
273
274 <T> Map<String, GetsResponse<T>> gets(Collection<String> keyCollections)
275 throws TimeoutException, InterruptedException,
276 MemcachedClientException;
277
278 <T> Map<String, GetsResponse<T>> gets(Collection<String> keyCollections,
279 long timeout) throws TimeoutException, InterruptedException,
280 MemcachedClientException;
281
282
283
284 boolean isEnabled();
285 }
创建接口实现类MemcachedClientWrapper
1 package cn.edu.jszg.cache;
2
3 import java.util.Collection;
4 import java.util.HashMap;
5 import java.util.Map;
6 import java.util.Set;
7 import java.util.concurrent.TimeoutException;
8
9 import net.rubyeye.xmemcached.exception.MemcachedException;
10
11 public class MemcachedClientWrapper implements MemcachedClient {
12 private net.rubyeye.xmemcached.MemcachedClient client;
13 private boolean enabled = false;
14
15 public MemcachedClientWrapper() {
16 super();
17 }
18
19 public void setMemcachedClient(net.rubyeye.xmemcached.MemcachedClient client) {
20 this.client = client;
21 }
22
23 public net.rubyeye.xmemcached.MemcachedClient getXMemcachedClient() {
24 return client;
25 }
26
27 @Override
28 public boolean set(String key, int exp, Object value) throws TimeoutException, InterruptedException,
29 MemcachedClientException {
30 try {
31 return client.set(key, exp, value);
32 } catch (MemcachedException e) {
33 throw new MemcachedClientException(e);
34 }
35 }
36
37 @Override
38 public boolean set(String key, int exp, Object value, long timeout) throws TimeoutException,
39 InterruptedException, MemcachedClientException {
40 try {
41 return client.set(key, exp, value, timeout);
42 } catch (MemcachedException e) {
43 throw new MemcachedClientException(e);
44 }
45 }
46
47 @Override
48 public void setWithNoReply(String key, int exp, Object value) throws InterruptedException,
49 MemcachedClientException {
50 try {
51 client.setWithNoReply(key, exp, value);
52 } catch (MemcachedException e) {
53 throw new MemcachedClientException(e);
54 }
55 }
56
57 @Override
58 public boolean add(String key, int exp, Object value) throws TimeoutException, InterruptedException,
59 MemcachedClientException {
60 try {
61 return client.add(key, exp, value);
62 } catch (MemcachedException e) {
63 throw new MemcachedClientException(e);
64 }
65 }
66
67 @Override
68 public boolean add(String key, int exp, Object value, long timeout) throws TimeoutException,
69 InterruptedException, MemcachedClientException {
70 try {
71 return client.add(key, exp, value, timeout);
72 } catch (MemcachedException e) {
73 throw new MemcachedClientException(e);
74 }
75 }
76
77 @Override
78 public void addWithNoReply(String key, int exp, Object value) throws InterruptedException,
79 MemcachedClientException {
80 try {
81 client.addWithNoReply(key, exp, value);
82 } catch (MemcachedException e) {
83 throw new MemcachedClientException(e);
84 }
85 }
86
87 @Override
88 public boolean replace(String key, int exp, Object value) throws TimeoutException, InterruptedException,
89 MemcachedClientException {
90 try {
91 return client.replace(key, exp, value);
92 } catch (MemcachedException e) {
93 throw new MemcachedClientException(e);
94 }
95 }
96
97 @Override
98 public boolean replace(String key, int exp, Object value, long timeout) throws TimeoutException,
99 InterruptedException, MemcachedClientException {
100 try {
101 return client.replace(key, exp, value, timeout);
102 } catch (MemcachedException e) {
103 throw new MemcachedClientException(e);
104 }
105 }
106
107 @Override
108 public void replaceWithNoReply(String key, int exp, Object value) throws InterruptedException,
109 MemcachedClientException {
110 try {
111 client.replaceWithNoReply(key, exp, value);
112 } catch (MemcachedException e) {
113 throw new MemcachedClientException(e);
114 }
115 }
116
117 @Override
118 public boolean append(String key, Object value) throws TimeoutException, InterruptedException,
119 MemcachedClientException {
120 try {
121 return client.append(key, value);
122 } catch (MemcachedException e) {
123 throw new MemcachedClientException(e);
124 }
125 }
126
127 @Override
128 public boolean append(String key, Object value, long timeout) throws TimeoutException, InterruptedException,
129 MemcachedClientException {
130 try {
131 return client.append(key, value, timeout);
132 } catch (MemcachedException e) {
133 throw new MemcachedClientException(e);
134 }
135 }
136
137 @Override
138 public void appendWithNoReply(String key, Object value) throws InterruptedException, MemcachedClientException {
139 try {
140 client.appendWithNoReply(key, value);
141 } catch (MemcachedException e) {
142 throw new MemcachedClientException(e);
143 }
144 }
145
146 @Override
147 public boolean prepend(String key, Object value) throws TimeoutException, InterruptedException,
148 MemcachedClientException {
149 try {
150 return client.prepend(key, value);
151 } catch (MemcachedException e) {
152 throw new MemcachedClientException(e);
153 }
154 }
155
156 @Override
157 public boolean prepend(String key, Object value, long timeout) throws TimeoutException, InterruptedException,
158 MemcachedClientException {
159 try {
160 return client.prepend(key, value, timeout);
161 } catch (MemcachedException e) {
162 throw new MemcachedClientException(e);
163 }
164 }
165
166 @Override
167 public void prependWithNoReply(String key, Object value) throws InterruptedException, MemcachedClientException {
168 try {
169 client.prependWithNoReply(key, value);
170 } catch (MemcachedException e) {
171 throw new MemcachedClientException(e);
172 }
173 }
174
175 @Override
176 public long incr(String key, long delta, long initValue) throws TimeoutException, InterruptedException,
177 MemcachedClientException {
178 try {
179 return client.incr(key, delta, initValue);
180 } catch (MemcachedException e) {
181 throw new MemcachedClientException(e);
182 }
183 }
184
185 @Override
186 public long incr(String key, long delta, long initValue, long timeout) throws TimeoutException,
187 InterruptedException, MemcachedClientException {
188 try {
189 return client.incr(key, delta, initValue, timeout);
190 } catch (MemcachedException e) {
191 throw new MemcachedClientException(e);
192 }
193 }
194
195 @Override
196 public void incrWithNoReply(String key, long delta) throws InterruptedException, MemcachedClientException {
197 try {
198 client.incrWithNoReply(key, delta);
199 } catch (MemcachedException e) {
200 throw new MemcachedClientException(e);
201 }
202 }
203
204 @Override
205 public long decr(String key, long delta, long initValue) throws TimeoutException, InterruptedException,
206 MemcachedClientException {
207 try {
208 return client.decr(key, delta, initValue);
209 } catch (MemcachedException e) {
210 throw new MemcachedClientException(e);
211 }
212 }
213
214 @Override
215 public long decr(String key, long delta, long initValue, long timeout) throws TimeoutException,
216 InterruptedException, MemcachedClientException {
217 try {
218 return client.decr(key, delta, initValue, timeout);
219 } catch (MemcachedException e) {
220 throw new MemcachedClientException(e);
221 }
222 }
223
224 @Override
225 public void decrWithNoReply(String key, long delta) throws InterruptedException, MemcachedClientException {
226 try {
227 client.decrWithNoReply(key, delta);
228 } catch (MemcachedException e) {
229 throw new MemcachedClientException(e);
230 }
231 }
232
233 @Override
234 public boolean delete(String key) throws TimeoutException, InterruptedException, MemcachedClientException {
235 try {
236 return client.delete(key);
237 } catch (MemcachedException e) {
238 throw new MemcachedClientException(e);
239 }
240 }
241
242 @Override
243 public boolean delete(String key, long opTimeout) throws TimeoutException, InterruptedException,
244 MemcachedClientException {
245 try {
246 return client.delete(key, opTimeout);
247 } catch (MemcachedException e) {
248 throw new MemcachedClientException(e);
249 }
250 }
251
252 @Override
253 public boolean delete(String key, long cas, long opTimeout) throws TimeoutException, InterruptedException,
254 MemcachedClientException {
255 try {
256 return client.delete(key, cas, opTimeout);
257 } catch (MemcachedException e) {
258 throw new MemcachedClientException(e);
259 }
260 }
261
262 @Override
263 public void deleteWithNoReply(String key) throws InterruptedException, MemcachedClientException {
264 try {
265 client.deleteWithNoReply(key);
266 } catch (MemcachedException e) {
267 throw new MemcachedClientException(e);
268 }
269 }
270
271 @SuppressWarnings("unchecked")
272 @Override
273 public <T> T get(String key) throws TimeoutException, InterruptedException, MemcachedClientException {
274 try {
275 return (T)client.get(key);
276 } catch (MemcachedException e) {
277 throw new MemcachedClientException(e);
278 }
279 }
280
281 @SuppressWarnings("unchecked")
282 @Override
283 public <T> T get(String key, long timeout) throws TimeoutException, InterruptedException,
284 MemcachedClientException {
285 try {
286 return (T)client.get(key, timeout);
287 } catch (MemcachedException e) {
288 throw new MemcachedClientException(e);
289 }
290 }
291
292 @Override
293 public <T> Map<String, T> get(Collection<String> keyCollections) throws TimeoutException,
294 InterruptedException, MemcachedClientException {
295 try {
296 return client.get(keyCollections);
297 } catch (MemcachedException e) {
298 throw new MemcachedClientException(e);
299 }
300 }
301
302 @Override
303 public <T> Map<String, T> get(Collection<String> keyCollections, long timeout) throws TimeoutException,
304 InterruptedException, MemcachedClientException {
305 try {
306 return client.get(keyCollections, timeout);
307 } catch (MemcachedException e) {
308 throw new MemcachedClientException(e);
309 }
310 }
311
312 @SuppressWarnings("unchecked")
313 @Override
314 public <T> GetsResponse<T> gets(String key) throws TimeoutException, InterruptedException,
315 MemcachedClientException {
316 try {
317 return new GetsResponse<T>((net.rubyeye.xmemcached.GetsResponse<T>) client.gets(key));
318 } catch (MemcachedException e) {
319 throw new MemcachedClientException(e);
320 }
321 }
322
323 @SuppressWarnings("unchecked")
324 @Override
325 public <T> GetsResponse<T> gets(String key, long timeout) throws TimeoutException, InterruptedException,
326 MemcachedClientException {
327 try {
328 return new GetsResponse<T>((net.rubyeye.xmemcached.GetsResponse<T>) client.gets(key, timeout));
329 } catch (MemcachedException e) {
330 throw new MemcachedClientException(e);
331 }
332 }
333
334 @Override
335 public <T> Map<String, GetsResponse<T>> gets(Collection<String> keyCollections) throws TimeoutException,
336 InterruptedException, MemcachedClientException {
337 try {
338 Map<String, GetsResponse<T>> results = new HashMap<String, GetsResponse<T>>();
339 Map<String, net.rubyeye.xmemcached.GetsResponse<T>> tmps = client.gets(keyCollections);
340 if (tmps != null) {
341 Set<String> keys = tmps.keySet();
342 for (String key : keys) {
343 results.put(key, new GetsResponse<T>((net.rubyeye.xmemcached.GetsResponse<T>) tmps.get(key)));
344 }
345 }
346 return results;
347 } catch (MemcachedException e) {
348 throw new MemcachedClientException(e);
349 }
350 }
351
352 @Override
353 public <T> Map<String, GetsResponse<T>> gets(Collection<String> keyCollections, long timeout)
354 throws TimeoutException, InterruptedException, MemcachedClientException {
355 try {
356 Map<String, GetsResponse<T>> results = new HashMap<String, GetsResponse<T>>();
357 Map<String, net.rubyeye.xmemcached.GetsResponse<T>> tmps = client.gets(keyCollections, timeout);
358 if (tmps != null) {
359 Set<String> keys = tmps.keySet();
360 for (String key : keys) {
361 results.put(key, new GetsResponse<T>((net.rubyeye.xmemcached.GetsResponse<T>) tmps.get(key)));
362 }
363 }
364 return results;
365 } catch (MemcachedException e) {
366 throw new MemcachedClientException(e);
367 }
368 }
369
370 @Override
371 public boolean isEnabled() {
372 return enabled;
373 }
374
375 public void setEnabled(boolean enabled) {
376 this.enabled = enabled;
377 }
378
379 }
经验总结：
缓存数据的一致性问题
缓存数据尽量只读，因此缓存本身是不适合大量写和更新操作的数据场景的。对于读的情况下，如果存在数据变化，一种是同时更新缓存和数据库。一种是直接对缓存数据进行失效处理。敲命令行的时候换行的时候要跟空格.
另附：memcached的常用命令
参考：http://www.cnblogs.com/jeffwongishandsome/archive/2011/11/06/2238265.html
页:
[1]