详解java解决分布式环境中高并发环境下数据插入重复问题

详解java解决分布式环境中高并发环境下数据插入重复问题

java 解决分布式环境中 高并发环境下数据插入重复问题

前言

原因：服务器同时接受到的重复请求

现象：数据重复插入 / 修改操作

解决方ogcRZN案 ： 分布式锁

对请求报文生成 摘要信息 + redis 实现分布式锁

工具类

分布式锁的应用

package com.nursling.web.filter.context;

import com.nursling.nosql.redis.RedisUtil;

import com.nursling.sign.SignType;

import com.nursling.sign.SignUtil;

import redis.clients.jedis.Jedis;

import javax.servlet.ServletRequest;

import javax.servlet.http.HttpServletRequest;

import java.util.HashMap;

import java.util.Map;

/**

* 并发拦截

* 高并发下 过滤掉 相同请求的工具

* @author 杨.

*

*/

public class ContextLJ {

private static final Integer JD = 0;

/**

* 上锁 使用redis 为分布式项目 加锁

* @param sign

* @param tiD

* @return

* @throws Exception

*/

public static boolean lock(String sign, String tiD) {

synchronized (JD) { // 加锁

Jedis jedis = RedisUtil.getJedis();

String uTid = jedis.get(sign);

if (uTid == null) {

jedis.set(sign, tiD);

jedis.expire(sign, 36);

return true;

}

return false;

}

}

/**

* 锁验证

* @param sign

* @param tiD

* @return

*/

public static boolean checklock(String sign, String tiD){

Jedis jedis = RedisUtil.getJedis();

String uTid = jedis.get(sign);

return tiD.equals(uTid);

}

/**

* 去掉锁

* @param sign

* @param tiD

*/

public static void clent (String sign, String tiD){

if (checklock(sign, tiD)) {

Jedis jedis = RedisUtil.getJedis();

jedis.del(sign);

}

}

/**

* 获取摘要

* @param request

* @return

*/

public static String getSign(ServletRequest request){

// 此工具是将 request中的请求内容 拼装成 key=value&key=value2 的形式 源码在线面

Map map = SignUtil.getRequstMap((HttpServletRequest) request);

String sign = null;

try {

// 这里使用md5方法生成摘要 SignUtil.getRequstMap 方法源码就不贴了

sign = SignUtil.buildRequest(map, SignType.MD5);

} catch (Exception e) {

e.printStackTrace();

}

return sign;

}

}

public static Map getRequstMap(HttpServletRequest req){

Map params = new HashMap();

Map requestParams = req.getParameterMap();

for (Iterator iter = requestParams.keySet().iterator(); iter.hasNext();) {

String name = (String) iter.next();

String[] values = (String[]) requestParams.get(name);

String valueStr = "";

for (int i = 0; i < values.lenhttp://gth; i++) {

valueStr = (i == values.length - 1) ? valueStr + values[i]

: valueStr + values[i] + ",";

}

params.put(name, valueStr);

}

return params;

}

下面是过滤器代码

对分布式锁的利用

package com.nursling.web.filter.transaction;

import com.google.gson.Gson;

import com.nursling.common.RandomUtil;

import com.nursling.dao.util.TransactionUtils;

import com.nursling.model.ApiResult;

import com.nursling.model.ApiRtnCode;

import com.nursling.web.filter.context.ContextLJ;

import org.apache.log4j.Logger;

import javax.servlet.*;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

/**

* 对事物进行控制 并且 避免接口 直接报漏异常信息

* 并且过滤频繁请求

* Created by yangchao on 2016/11/4.

*/

public class TransactionFilter implements Filter {

Logger log = Logger.getLogger(this.getClass());

@Override

public void init(FilterConfig filterConfig) throws ServletException {

}

@Override

public void doFilter(ServletRequest request, ServletResponse myResp, FilterChain chain) throws IOException, ServletException {

String sign = "sign_" + ContextLJ.getSign(request); // 生成摘要

String tiD = RandomUtil.getRandomString(3) + "_" + Thread.currentThread().getId(); // 当前线程的身份

try {

if (!ContextLJ.lock(sign, tiD)) {

log.warn("放弃相同 并发请求" + sign);

frequentlyError(myResp);

return;

}

if (!ContextLJ.checklock(sign, tiD)) {

log.warn("加锁验证失败 " + sign + " " + tiD);

frequentlyError(myResp);

return;

}

chain.doFilter(request, myResp); // 放行

} catch (Exception e) { // 捕获到异常 进行异常过滤

log.error("", e);

retrunErrorInfo(myResp);

} finally {

ContextLJ.clent(sign, tiD);

}

}

/**

* 频繁请求

* @param myResp

*/

private void frequentlyError(ServletResponse myResp) throws IOException {

ApiResult

((HttpServletResponse) myResp).setHeader("Content-type", "text/html;charset=UTF-8");

re.setMsg("稍安勿躁，不要频繁请求");

re.setCode(ApiRtnCode.API_VERIFY_FAIL);

myResp.getWriter().write(new Gson().tojson(re));

}

/**

* 返回异常信息

* @param myResp

*/

private void retrunErrorInfo(ServletResponse myResp) throws IOException {

ApiResult

re.setMsg("server error");

// 这里不必理会

re.setCode(ApiRtnCode.SERVICE_ERROR);

myResp.getWriter().write(new Gson().toJson(re));

}

@Override

public void destroy() {

}

}

程序本身应该还有需要完善的地方， 不过经过一段时间的测试。 这个解决方案还是比较可靠的 并发测试 + 生产环境上 也没有再出现 重复请求的问题

非极端情况下 还是很可靠的

以上所述是给大家介绍的java解决分布式环境中高并发环境下数据插入重复问题详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，会及时回复大家的。在此也非常感谢大家对我们网站的支持！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。