Implementieren einer verteilten Sperre mit MySQL

TABELLE „globallocktable“ erstellen (
 `id` int(11) NICHT NULL AUTO_INCREMENT,
 `lockKey` varchar(60) NOT NULL COMMENT 'Sperrname',
 `createTime` datetime NICHT NULL KOMMENTAR 'Erstellungszeit',
 Primärschlüssel (`id`),
 EINZIGARTIGER SCHLÜSSEL `lockKey` (`lockKey`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='Globale Sperre';

@Komponente
öffentliche Klasse GlobalLockComponent {
 @Ressource
 GlobalLockTableDAO globalLockDAO;
 /**
  * Versuchen Sie, die Sperre zu erhalten. „true“ bei Erfolg, „false“ bei Fehlschlag
  */
 öffentliches Boolean tryLock(String-Schlüssel) {
  gibt GlobalLockUtil.tryLock(this.globalLockDAO, Schlüssel) zurück;
 }
 /**
  * Wenn ein anderes Programm die Sperre belegt hat und das Timeout (Millisekunden) überschritten wird, wird die Sperre zwangsweise aufgehoben. * Das heißt, zuerst den Datensatz entsprechend dem Schlüssel löschen und dann den Datensatz hinzufügen */
 öffentliche boolean tryLockWithClear(String-Schlüssel, Long timeoutMs) {
  gibt GlobalLockUtil.tryLockWithClear zurück (this.globalLockDAO, Schlüssel, TimeoutMs);
 }
 /**
  * Sperre aufheben und Datensatz laut Schlüssel löschen */
 public void releaseLock(String-Schlüssel) {
  GlobalLockUtil.releasLock(this.globalLockDAO, Schlüssel);
 }
}

öffentliche Klasse GlobalLockTable {

 private Integer-ID;
 private Zeichenfolge „lockKey“;
 privates Datum, Erstellungszeit;
 // Get- und Set-Methoden weglassen}

GlobalLockTableDAO ist wie folgt definiert: öffentliche Schnittstelle GlobalLockTableDAO {
 int deleteByPrimaryKey(Integer-ID);
 : In diesem Beispiel wird die Zeichenfolge deleteByLockKey als Schlüsselwert für die Anweisung deleteByLockKey verwendet.
 : GlobalLockTable selectByLockKey (String-Schlüssel);
 int insertSelectiveWithTest(GlobalLockTable-Datensatz);
}

öffentliche Klasse GlobalLockUtil {
 privater statischer Logger logger = LoggerFactory.getLogger(GlobalLockUtil.class);
 private static GlobalLockTable tryLockInternal(GlobalLockTableDAO lockDAO, String key) {
  GlobalLockTable einfügen = neue GlobalLockTable();
  einfügen.setCreateTime(neues Datum());
  einfügen.setLockKey(Schlüssel);
  // Anmerkung 1
  int count = lockDAO.insertSelectiveWithTest(einfügen);
  wenn (Anzahl == 0) {
   GlobalLockTable bereit = lockDAO.selectByLockKey(Schlüssel);
   logger.warn("kann den Schlüssel nicht sperren: {}, {}, {}", insert.getLockKey(), ready.getCreateTime(),
     bereit.getId());
   Rückkehr bereit;
  }
  logger.info("ja, habe das Schloss mit dem Schlüssel erhalten: {}", insert.getId(), insert.getLockKey());
  gibt null zurück;
 }
 /** Zeitüberschreitung zum Aufheben der Sperre und erneuten Sperren**/
 öffentliche statische Boolesche tryLockWithClear (GlobalLockTableDAO lockDAO, String-Schlüssel, Long timeoutMs) {
  GlobalLockTable-Sperre = tryLockInternal (lockDAO, Schlüssel);
  wenn (Sperre == null) true zurückgeben;
  wenn (System.currentTimeMillis() - lock.getCreateTime().getTime() <= timeoutMs) {
   logger.warn("Entschuldigung, kann den Schlüssel nicht abrufen. : {}, {}, {}", key, lock.getId(), lock.getCreateTime());
   gibt false zurück;
  }
  logger.warn("für den Schlüssel ist bereits vorher eine Zeitüberschreitung aufgetreten: {}, {}, wird gelöscht", key, timeoutMs);
  // Anmerkung 2
  : In diesem Fall ist lockDAO.deleteByPrimaryKey die einzige Funktion, die lock.getId() verwendet.
  wenn (Anzahl == 0) {
   logger.warn("Entschuldigung, der Schlüssel wurde bereits von anderen vorweggenommen: {}, {}", lock.getId(), lock.getLockKey());
   gibt false zurück;
  }
  Sperre = tryLockInternal(lockDAO, Schlüssel);
  Sperre zurückgeben != null? false : true;
 }
 /** Sperren **/
 öffentliche statische Boolesche tryLock (GlobalLockTableDAO lockDAO, String-Schlüssel) {
  returniere tryLockInternal(lockDAO, key) == null ? true : false;
 }
 /** Entsperren **/
 öffentliche statische Leere freigebenLock (GlobalLockTableDAO lockDAO, String-Schlüssel) {
  lockDAO.deleteByLockKey(Schlüssel);
 }
}

<insert id="insertSelectiveWithTest" useGeneratedKeys="true" keyProperty="id" parameterType="com.javashitang.middleware.lock.mysql.pojo.GlobalLockTable">
 einfügen in `globallocktable` (`id`,
 `Schlüsselsperre`, `Zeiterstellung` )
  wählen Sie #{id,jdbcType=INTEGER}, #{lockKey,jdbcType=VARCHAR}, #{createTime,jdbcType=TIMESTAMP}
  von dual, wo nicht existiert
  (Wählen Sie 1 aus der Globallock-Tabelle, wobei LockKey = #{lockKey,jdbcType=VARCHAR})
</einfügen>

wenn (!globalLockComponent.tryLock(name)) {
 //Zurück, wenn die Sperre nicht erworben wurde;
}
versuchen {
 // Schreiben Sie hier die Geschäftslogik} catch (Exception e) {
Endlich
 globalLockComponent.releasLock(Name)