package com.mic.synchrolock.util;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import com.mic.constants.Constants;
import com.mic.constants.InvestType;
/**
 * 分布式同步锁工具类
 * @author Administrator
 *
 */
public class SynchrolockUtil {
 private final Log logger = LogFactory.getLog(getClass());
 @Autowired
 private RedisClientTemplate redisClientTemplate;
 public final String RETRYTYPE_WAIT = "1";  //加锁方法当对象已加锁时，设置为等待并轮询
 public final String RETRYTYPE_NOWAIT = "0";  //加锁方法当对象已加锁时，设置为直接返回
 private String requestTimeOutName = "";  //投资同步锁请求超时时间
 private String retryIntervalName = "";   //投资同步锁轮询间隔
 private String keyTimeoutName = "";  //缓存中key的失效时间
 private String investProductSn = "";   //产品Sn
 private String uuid;    //对象唯一标识
 private Long startTime = System.currentTimeMillis(); //首次调用时间
 public Long getStartTime() {
  return startTime;
 }
 List<String> keyList = new ArrayList<String>(); //缓存key的保存集合
 public List<String> getKeyList() {
  return keyList;
 }
 public void setKeyList(List<String> keyList) {
  this.keyList = keyList;
 }
 @PostConstruct
 public void init() {
  uuid = UUID.randomUUID().toString();
 }
 @PreDestroy
 public void destroy() {
  this.unlock();
 }
 /**
  * 根据传入key值，判断缓存中是否存在该key
  * 存在-已上锁：判断retryType，轮询超时，或直接返回，返回ture
  * 不存在-未上锁：将该放入缓存，返回false
  * @param key
  * @param retryType 当遇到上锁情况时 1：轮询；0：直接返回
  * @return
  */
 public boolean islocked(String key,String retryType){
  boolean flag = true;
  logger.info("====投资同步锁设置轮询间隔、请求超时时长、缓存key失效时长====");
  //投资同步锁轮询间隔 毫秒
  Long retryInterval = Long.parseLong(Constants.getProperty(retryIntervalName));
  //投资同步锁请求超时时间 毫秒
  Long requestTimeOut = Long.parseLong(Constants.getProperty(requestTimeOutName));
  //缓存中key的失效时间 秒
  Integer keyTimeout = Integer.parseInt(Constants.getProperty(keyTimeoutName));
  //调用缓存获取当前产品锁
  logger.info("====当前产品key为："+key+"====");
  if(isLockedInRedis(key,keyTimeout)){
   if("1".equals(retryType)){
    //采用轮询方式等待
    while (true) {
     logger.info("====产品已被占用，开始轮询====");
     try {
      Thread.sleep(retryInterval);
     } catch (InterruptedException e) {
      logger.error("线程睡眠异常:"+e.getMessage(), e);
      return flag;
     }
     logger.info("====判断请求是否超时====");
     Long currentTime = System.currentTimeMillis(); //当前调用时间
     long Interval = currentTime - startTime;
     if (Interval > requestTimeOut) {
      logger.info("====请求超时====");
      return flag;
     }
     if(!isLockedInRedis(key,keyTimeout)){
      logger.info("====轮询结束，添加同步锁====");
      flag = false;
      keyList.add(key);
      break;
     }
    }
   }else{
    //不等待，直接返回
    logger.info("====产品已被占用，直接返回====");
    return flag;
   }
  }else{
   logger.info("====产品未被占用，添加同步锁====");
   flag = false;
   keyList.add(key);
  }
  return flag;
 }
 /**
  * 在缓存中查询key是否存在
  * 若存在则返回true;
  * 若不存在则将key放入缓存，设置过期时间，返回false
  * @param key
  * @param keyTimeout key超时时间单位是秒
  * @return
  */
 boolean isLockedInRedis(String key,int keyTimeout){
  logger.info("====在缓存中查询key是否存在====");
  boolean isExist = false;
  //与redis交互，查询对象是否上锁
  Long result = this.redisClientTemplate.setnx(key, uuid);
  logger.info("====上锁 result = "+result+"====");
  if(null != result && 1 == Integer.parseInt(result.toString())){
   logger.info("====设置缓存失效时长 = "+keyTimeout+"秒====");
   this.redisClientTemplate.expire(key, keyTimeout);
   logger.info("====上锁成功====");
   isExist = false;
  }else{
   logger.info("====上锁失败====");
   isExist = true;
  }
  return isExist;
 }
 /**
  * 根据传入key，对该产品进行解锁
  * @param key
  * @return
  */
 public void unlock(){
  //与redis交互，对产品解锁
  if(keyList.size()>0){
   for(String key : this.keyList){
    String value = this.redisClientTemplate.get(key);
    if(null != value && !"".equals(value)){
     if(uuid.equals(value)){
      logger.info("====解锁key:"+key+" value="+value+"====");
      this.redisClientTemplate.del(key);
     }else{
      logger.info("====待解锁集合中key:"+key+" value="+value+"与uuid不匹配====");
     }
    }else{
     logger.info("====待解锁集合中key="+key+"的value为空====");
    }
   }
  }else{
   logger.info("====待解锁集合为空====");
  }
 }
}

//获取同步锁工具类
　　SynchrolockUtil synchrolockUtil = SpringUtils.getBean("synchrolockUtil");
　　//获取需上锁资源的KEY
　　String key = "abc";
　　//查询是否上锁，上锁轮询，未上锁加锁
　　boolean isLocked = synchrolockUtil.islocked(key,synchrolockUtil.RETRYTYPE_WAIT);
　　//判断上锁结果
　　if(isLocked){
 　　logger.error("同步锁请求超时并返回 key ="+key);
　　}else{
 　　logger.info("====同步锁加锁陈功====");
　　}
　　try {
 　　//执行业务处理
　　} catch (Exception e) {
 　　logger.error("业务异常:"+e.getMessage(), e);
　　}finally{
 　　//解锁
 　　 synchrolockUtil.unlock();
　　}