Memcached笔记——（四）应对高并发攻击

近半个月过得很痛苦，主要是产品上线后，引来无数机器用户恶意攻击，不停的刷新产品各个服务入口，制造垃圾数据，消耗资源。他们的最好成绩，1秒钟可以并发6次，赶在Database入库前，Cache进行Missing Loading前，强占这其中十几毫秒的时间，进行恶意攻击。

为了应对上述情况，做了如下调整：

1. 更新数据时，先写Cache，然后写Database，如果可以，写操作交给队列后续完成。
2. 限制统一帐号，同一动作，同一秒钟并发次数，超过1次不做做动作，返回操作失败。
3. 限制统一用户，每日动作次数，超限返回操作失败。

要完成上述操作，同事给我支招。用Memcached的add方法，就可以很快速的解决问题。不需要很繁琐的开发，也不需要依赖数据库记录，完全内存操作。

以下实现一个判定冲突的方法：

Java代码

1. /**
2. *冲突延时1秒
3. */
4. publicstaticfinalintMUTEX_EXP=1;
5. /**
6. *冲突键
7. */
8. publicstaticfinalStringMUTEX_KEY_PREFIX="MUTEX_";
10. /**
11. *冲突判定
12. *
13. *@paramkey
14. */
15. publicbooleanisMutex(Stringkey){
16. returnisMutex(key,MUTEX_EXP);
17. }
19. /**
20. *冲突判定
21. *
22. *@paramkey
23. *@paramexp
24. *@returntrue冲突
25. */
26. publicbooleanisMutex(Stringkey,intexp){
27. booleanstatus=true;
28. try{
29. if(memcachedClient.add(MUTEX_KEY_PREFIX+key,exp,"true")){
30. status=false;
31. }
32. }catch(Exceptione){
33. logger.error(e.getMessage(),e);
34. }
35. returnstatus;
36. }

做个说明：

选项	说明
add	仅当存储空间中不存在键相同的数据时才保存
replace	仅当存储空间中存在键相同的数据时才保存
set	与add和replace不同，无论何时都保存

也就是说，如果add操作返回为true，则认为当前不冲突！

回归场景，恶意用户1秒钟操作6次，遇到上述这个方法，只有乖乖地1秒后再来。别小看这1秒钟，一个数据库操作不过几毫秒。1秒延迟，足以降低系统负载，增加恶意用户成本。

附我用到的基于XMemcached实现：

Java代码

1. importnet.rubyeye.xmemcached.MemcachedClient;
3. importorg.apache.log4j.Logger;
4. importorg.springframework.beans.factory.annotation.Autowired;
5. importorg.springframework.stereotype.Component;
7. /**
8. *
9. *@authorSnowolf
10. *@version1.0
11. *@since1.0
12. */
13. @Component
14. publicclassMemcachedManager{
16. /**
17. *缓存时效1天
18. */
19. publicstaticfinalintCACHE_EXP_DAY=3600*24;
21. /**
22. *缓存时效1周
23. */
24. publicstaticfinalintCACHE_EXP_WEEK=3600*24*7;
26. /**
27. *缓存时效1月
28. */
29. publicstaticfinalintCACHE_EXP_MONTH=3600*24*30;
31. /**
32. *缓存时效永久
33. */
34. publicstaticfinalintCACHE_EXP_FOREVER=0;
36. /**
37. *冲突延时1秒
38. */
39. publicstaticfinalintMUTEX_EXP=1;
40. /**
41. *冲突键
42. */
43. publicstaticfinalStringMUTEX_KEY_PREFIX="MUTEX_";
44. /**
45. *Loggerforthisclass
46. */
47. privatestaticfinalLoggerlogger=Logger
48. .getLogger(MemcachedManager.class);
50. /**
51. *MemcachedClient
52. */
53. @Autowired
54. privateMemcachedClientmemcachedClient;
56. /**
57. *缓存
58. *
59. *@paramkey
60. *@paramvalue
61. *@paramexp
62. *失效时间
63. */
64. publicvoidcacheObject(Stringkey,Objectvalue,intexp){
65. try{
66. memcachedClient.set(key,exp,value);
67. }catch(Exceptione){
68. logger.error(e.getMessage(),e);
69. }
70. logger.info("CacheObject:["+key+"]");
71. }
73. /**
74. *ShutdowntheMemcachedCilent.
75. */
76. publicvoidfinalize(){
77. if(memcachedClient!=null){
78. try{
79. if(!memcachedClient.isShutdown()){
80. memcachedClient.shutdown();
81. logger.debug("ShutdownMemcachedManager...");
82. }
83. }catch(Exceptione){
84. logger.error(e.getMessage(),e);
85. }
86. }
87. }
89. /**
90. *清理对象
91. *
92. *@paramkey
93. */
94. publicvoidflushObject(Stringkey){
95. try{
96. memcachedClient.deleteWithNoReply(key);
97. }catch(Exceptione){
98. logger.error(e.getMessage(),e);
99. }
100. logger.info("FlushObject:["+key+"]");
101. }
103. /**
104. *冲突判定
105. *
106. *@paramkey
107. */
108. publicbooleanisMutex(Stringkey){
109. returnisMutex(key,MUTEX_EXP);
110. }
112. /**
113. *冲突判定
114. *
115. *@paramkey
116. *@paramexp
117. *@returntrue冲突
118. */
119. publicbooleanisMutex(Stringkey,intexp){
120. booleanstatus=true;
121. try{
122. if(memcachedClient.add(MUTEX_KEY_PREFIX+key,exp,"true")){
123. status=false;
124. }
125. }catch(Exceptione){
126. logger.error(e.getMessage(),e);
127. }
128. returnstatus;
129. }
131. /**
132. *加载缓存对象
133. *
134. *@paramkey
135. *@return
136. */
137. public<T>TloadObject(Stringkey){
138. Tobject=null;
139. try{
140. object=memcachedClient.<T>get(key);
141. }catch(Exceptione){
142. logger.error(e.getMessage(),e);
143. }
144. logger.info("LoadObject:["+key+"]");
145. returnobject;
146. }
148. }