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

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

前言

原因：服务器同时接受到的重复请求
现象：数据重复插入 / 修改操作

解决方案 ： 分布式锁

对请求报文生成 摘要信息 + 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<String, String> getRequstMap(HttpServletRequest req){
        Map<String,String> params = new HashMap<String,String>();
        Map<String, String[]> requestParams = req.getParameterMap();
        for (Iterator<String> 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.length; 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