<!--mongodo開始-->
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-mongodb</artifactId>
      <version>1.8.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-commons</artifactId>
      <version>1.10.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>mongo-java-driver</artifactId>
      <version>2.13.0-rc2</version>
    </dependency>
 <!--mongodo結(jié)束-->

import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class MongoDistributedLock {

  static MongoLockDao mongoLockDao;

  static {
    mongoLockDao = SpringBeanUtils.getBean("mongoLockDao");
  }

  /**
   * 獲得鎖的步驟：
   * 1、首先判斷鎖是否被其他請(qǐng)求獲得；如果沒被其他請(qǐng)求獲得則往下進(jìn)行；
   * 2、判斷鎖資源是否過期，如果過期則釋放鎖資源；
   * 3.1、嘗試獲得鎖資源，如果value=1，那么獲得鎖資源正常;（在當(dāng)前請(qǐng)求已經(jīng)獲得鎖的前提下，還可能有其他請(qǐng)求嘗試去獲得鎖，此時(shí)會(huì)導(dǎo)致當(dāng)前鎖的過期時(shí)間被延長(zhǎng)，由于延長(zhǎng)時(shí)間在毫秒級(jí)，可以忽略。）
   * 3.2、value>1,則表示當(dāng)前請(qǐng)求在嘗試獲取鎖資源過程中，其他請(qǐng)求已經(jīng)獲取了鎖資源，即當(dāng)前請(qǐng)求沒有獲得鎖；
   * ！?。∽⒁?，不需要鎖資源時(shí)，及時(shí)釋放鎖資源！??！。
   *
   * @param key
   * @param expire
   * @return
   */
  public static boolean getLock(String key, long expire) {
    List<MongoLock> mongoLocks = mongoLockDao.getByKey(key);
    //判斷該鎖是否被獲得,鎖已經(jīng)被其他請(qǐng)求獲得，直接返回
    if (mongoLocks.size() > 0 && mongoLocks.get(0).getExpire() >= System.currentTimeMillis()) {
      return false;
    }
    //釋放過期的鎖
    if (mongoLocks.size() > 0 && mongoLocks.get(0).getExpire() < System.currentTimeMillis()) {
      releaseLockExpire(key, System.currentTimeMillis());
    }
    //??！(在高并發(fā)前提下)在當(dāng)前請(qǐng)求已經(jīng)獲得鎖的前提下，還可能有其他請(qǐng)求嘗試去獲得鎖，此時(shí)會(huì)導(dǎo)致當(dāng)前鎖的過期時(shí)間被延長(zhǎng)，由于延長(zhǎng)時(shí)間在毫秒級(jí)，可以忽略。
    Map<String, Object> mapResult = mongoLockDao.incrByWithExpire(key, 1, System.currentTimeMillis() + expire);
    //如果結(jié)果是1，代表當(dāng)前請(qǐng)求獲得鎖
    if ((Integer) mapResult.get("value") == 1) {
      return true;
      //如果結(jié)果>1，表示當(dāng)前請(qǐng)求在獲取鎖的過程中，鎖已被其他請(qǐng)求獲得。
    } else if ((Integer) mapResult.get("value") > 1) {
      return false;
    }
    return false;
  }

  /**
   * 釋放鎖
   *
   * @param key
   */
  public static void releaseLock(String key) {
    Map<String, Object> condition = new HashMap<>();
    condition.put("key", key);
    mongoLockDao.remove(condition);
  }

  /**
   * 釋放過期鎖
   *
   * @param key
   * @param expireTime
   */
  private static void releaseLockExpire(String key, long expireTime) {
    mongoLockDao.removeExpire(key, expireTime);
  }
}

import org.springframework.data.mongodb.core.FindAndModifyOptions;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

import java.util.HashMap;
import java.util.List;
import java.util.Map;


@Repository
public class MongoLockDao <MongoLock> {
  private Class<?> clz;

  public Class<?> getClz() {
    if (clz == null) {
      //獲取泛型的Class對(duì)象
      clz = ((Class<?>)
          (((ParameterizedType) (this.getClass().getGenericSuperclass())).getActualTypeArguments()[0]));
    }
    return clz;
  }

  /**
   * 返回指定key的數(shù)據(jù)
   *
   * @param key
   * @return
   */
  public List<MongoLock> getByKey(String key) {
    Query query = new Query();
    query.addCriteria(Criteria.where("key").is(key));
    return (List<MongoLock>) mongoTemplate.find(query, getClz());
  }


  /**
   * 指定key自增increment(原子加),并設(shè)置過期時(shí)間
   *
   * @param key
   * @param increment
   * @param expire
   * @return
   */
  public Map<String, Object> incrByWithExpire(String key, double increment, long expire) {
    //篩選
    Query query = new Query();
    query.addCriteria(new Criteria("key").is(key));

    //更新
    Update update = new Update();
    update.inc("value", increment);
    update.set("expire", expire);
    //可選項(xiàng)
    FindAndModifyOptions options = FindAndModifyOptions.options();
    //沒有則新增
    options.upsert(true);
    //返回更新后的值
    options.returnNew(true);
    Map<String, Object> resultMap = new HashMap<>();
    resultMap.put("value", Double.valueOf(((MongoLock)
        mongoTemplate.findAndModify(query, update, options, getClz())).getValue()).intValue());
    resultMap.put("expire", Long.valueOf(((MongoLock)
        mongoTemplate.findAndModify(query, update, options, getClz())).getExpire()).longValue());
    return resultMap;
  }


  /**
   * 根據(jù)value刪除過期的內(nèi)容
   *
   * @param key
   * @param expireTime
   */
  public void removeExpire(String key, long expireTime) {
    Query query = new Query();
    query.addCriteria(Criteria.where("key").is(key));
    query.addCriteria(Criteria.where("expire").lt(expireTime));
    mongoTemplate.remove(query, getClz());
  }

  public void remove(Map<String, Object> condition) {
    Query query = new Query();
    Set<Map.Entry<String, Object>> set = condition.entrySet();
    int flag = 0;
    for (Map.Entry<String, Object> entry : set) {
      query.addCriteria(Criteria.where(entry.getKey()).is(entry.getValue()));
      flag = flag + 1;
    }
    if (flag == 0) {
      query = null;
    }
    mongoTemplate.remove(query, getClz());
  }

}

public class MongoLock {

  private String key;
  private double value;
  private long expire;

  public double getValue() {
    return value;
  }

  public void setValue(double value) {
    this.value = value;
  }

  public long getExpire() {
    return expire;
  }

  public void setExpire(long expire) {
    this.expire = expire;
  }

  public String getKey() {
    return key;
  }

  public void setKey(String key) {
    this.key = key;
  }
}