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

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<string, string> 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<object> re = new 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<object> re = new apiresult<>();

     re.setmsg( "server error" );

     // 这里不必理会

     re.setcode(apirtncode.service_error);

     myresp.getwriter().write( new gson().tojson(re));

   }

   @override

   public void destroy() {

   }

}