分布式系统后台如何防止重复提交

2019独角兽企业重金招聘Python工程师标准>>>

分布式系统后台如何防止重复提交

分布式系统网络拓扑结构

场景描述

秒杀系统提交订单时,由于用户连续快速点击,并且前端没有针对性处理,导致连续发送两次请求,一次命中服务器A,另一次命中服务器B, 那么就生成了两个内容完全相同的订单,只是订单号不同而已.

重复提交的后果

1. 用户在界面看到两个一模一样的订单,不知道应该支付哪个;
2. 系统出现异常数据,影响正常的校验.

解决方法

解决思路:相同的请求在同一时间只能被处理一次.
如果是单体服务器,我们可以通过多线程并发的方式解决,但是目前大部分系统,采用了多机负载均衡.

分布式锁

1. 服务器A接收到请求之后,获取锁,获取成功 ,
2. 服务器A进行业务处理,订单提交成功;
3. 服务器B接收到相同的请求,获取锁,失败,
   因为锁被服务器A获取了,并且未释放
4. 服务器A处理完成,释放锁 实现采用redis ,
   
   参考:http://www.importnew.com/27477.html

利用数据库唯一性约束

实现思路: 对请求信息进行hash运算,得到一个hash值,
相同的请求信息得到相同的hash值(换成md5也可以) 步骤:

1. 接口A接收到请求之后,对请求信息hash运算,得到hash值hashCodeA;
2. 保存hashCodeA 到数据库,并且对应的数据库的列(column)满足unique约束;
3. 保存成功之后,才进行正常业务逻辑处理,比如提交订单;
4. 服务器B接收到相同的请求后,也得到相同的hash值,hashCodeA,
5. 服务器B 保存hashCodeA 到数据库,肯定失败,因为相同的hash值已经存在;
6. 因为保存失败,所以后面的业务逻辑不会执行.

示例代码: 控制器中:

Java代码 

 

1. // 使用数据库约束条件,防止重复提交  
2.         try {  
3.             Integer userId = getCurrentId();  
4.             String hashSource = WebServletUtil.buildHashSource(request, userId);  
5.             reqOrderLock(hashSource, houseInfo.getId());  
6.         } catch (IOException e) {  
7.             e.printStackTrace();  
8.         }  
9.           

 Service中:

Java代码 

 

1. /*** 
2.      * 利用数据库的唯一性约束 
3.      * 防止重复提交 
4.      * @param queryString 
5.      */  
6.     public void reqOrderLock(String queryString, Integer houseInfoId) {  
7.         long crc32Long = EncryptionUtil.getHash(queryString);  
8.         this.orderReqLockDao.addUnique(String.valueOf(crc32Long), houseInfoId, Constant2.Order_type_Label_VISIT_ORDER);  
9.     }  

 

dao 中:

Java代码 

 

1. public OrderReqLock addUnique(String crc32, Integer houseInfoId, String orderTypeLabel) {  
2.         OrderReqLock orderReqLock = new OrderReqLock();  
3.         orderReqLock.setCrc32(crc32);  
4.         if (null != houseInfoId) {  
5.             orderReqLock.setHouseInfoId(houseInfoId);  
6.         }  
7.   
8.         orderReqLock.setOrderTypeLabel(orderTypeLabel);  
9.         CreateTimeDto createTimeDto = TimeHWUtil.getCreateTimeDao();  
10.         orderReqLock.setCreateTime(createTimeDto.getCreateTime());  
11.         orderReqLock.setUpdateTime(createTimeDto.getUpdateTime());  
12.         try {  
13.             add(orderReqLock);  
14.         } catch (org.hibernate.exception.ConstraintViolationException e) {  
15.             e.printStackTrace();  
16.             LogicExc.throwEx(Constant2.ERROR_CODE_Repeat_Operation, "您重复提交了订单,订单类型" );  
17.         }   
18.         return orderReqLock;  
19.     }  

 当然有个隐患: 在增加完锁,即执行addUnique 方法之后,程序挂了,不管是网络原因还是数据库崩溃, 当服务恢复之后,相同的请求无法提交了,因为数据库已经保存了请求的hash(但是实际上,后面的业务逻辑还没有来得及执行). 原因:锁操作addUnique 和业务逻辑肯定不在同一个数据库事务中

前端的解决方法

思路: 进入添加页面时,获取服务器端的token,
提交时把token提交过去,判断token是否存在,
若存在,则进行后续正常业务逻辑,
如不存在,则报错重复提交.

流程图

添加页面接口 使用注解:@RepeatToken(save = true) 提交接口 使用注解 :@RepeatToken(remove = true) token 拦截器代码

Java代码 

 

1. package com.girltest.web.controller.intercept;  
2.   
3. import com.common.util.WebServletUtil;  
4. import org.apache.log4j.Logger;  
5. import org.springframework.web.method.HandlerMethod;  
6. import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;  
7.   
8. import javax.servlet.http.HttpServletRequest;  
9. import javax.servlet.http.HttpServletResponse;  
10. import java.lang.reflect.Method;  
11. import java.util.UUID;  
12.   
13. /** 
14.  * Created by 黄威 on 9/14/16. 
15.  */  
16. public class TokenInterceptor extends HandlerInterceptorAdapter {  
17.     private static final Logger LOG = Logger.getLogger(TokenInterceptor.class);  
18.   
19.     @Override  
20.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {  
21.         if (handler instanceof HandlerMethod) {  
22.             HandlerMethod handlerMethod = (HandlerMethod) handler;  
23.             Method method = handlerMethod.getMethod();  
24.             RepeatToken annotation = method.getAnnotation(RepeatToken.class);  
25.             if (annotation != null) {  
26.                 boolean needSaveSession = annotation.save();  
27.                 if (needSaveSession) {  
28.                     request.getSession(true).setAttribute("token", UUID.randomUUID().toString());  
29.                 }  
30.                 boolean needRemoveSession = annotation.remove();  
31.                 if (needRemoveSession) {  
32.                     if (isRepeatSubmit(request)) {  
33.                         LOG.warn("please don't repeat submit,url:" + request.getServletPath());  
34.                         //如果重复提交,则重定向到列表页面  
35.                         response.sendRedirect(WebServletUtil.getBasePath(request) + "test/list");  
36.                         return false;  
37.                     }  
38.                     request.getSession(true).removeAttribute("token");  
39.                 }  
40.             }  
41.             return true;  
42.         } else {  
43.             return super.preHandle(request, response, handler);  
44.         }  
45.     }  
46.   
47.     /*** 
48.      * 
49.      * @param request 
50.      * @return : true:报错需要重定向  
51.      * false: 处理后续的正常业务逻辑 
52.      */  
53.     private boolean isRepeatSubmit(HttpServletRequest request) {  
54.         String serverToken = (String) request.getSession(true).getAttribute("token");  
55.         if (serverToken == null) {  
56.             return true;  
57.         }  
58.         String clinetToken = request.getParameter("token");  
59.         if (clinetToken == null) {  
60.             return true;  
61.         }  
62.         if (!serverToken.equals(clinetToken)) {  
63.             return true;  
64.         }  
65.         return false;  
66.     }  
67. }  

 

总结

1. 第二种方法(利用数据库完整性约束)最简便,但是会访问(读写)数据库,给数据库造成一定的压力;
   但也有个隐患,程序执行中途故障了(网络垮了,服务宕了...),后面重复提交,就无法成功了.也有解决方法:定时器清理这个hash数据库表
2. 第一种方法最复杂,但是符合高性能,高可用

转载于:https://my.oschina.net/zzlzheng/blog/3018483