Sequenzimplementierungsmethode basierend auf MySQL

CREATE TABLE `t_sequence` (
`sequence_name` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'Sequenzname' ,
`Wert` int(11) NULL DEFAULT NULL COMMENT 'Aktueller Wert' ,
PRIMÄRSCHLÜSSEL (`Sequenzname`)
)
ENGINE=InnoDB
STANDARDZEICHENSATZ=utf8 COLLATE=utf8_general_ci
ROW_FORMAT=KOMPAKT
;

CREATE DEFINER = `root`@`localhost` FUNCTION `nextval`(Sequenzname varchar(64))
 Gibt int(11) zurück.
BEGINNEN
 aktuelle Ganzzahl deklarieren;
 Strom einstellen = 0;
 
 Aktualisiere t_Sequenz t setze t.Wert = t.Wert + 1, wobei t.Sequenzname = Sequenzname;
 Wählen Sie t.value in current aus t_sequence t, wobei t.sequence_name = sequence_name;

 Rückstrom;
Ende;

CREATE TABLE `t_pub_sequence` (
 `SEQ_NAME` varchar(128) CHARACTER SET utf8 NOT NULL COMMENT 'Sequenzname',
 `SEQ_VALUE` bigint(20) NOT NULL COMMENT 'Aktueller Sequenzwert',
 `MIN_VALUE` bigint(20) NOT NULL COMMENT 'Minimalwert',
 `MAX_VALUE` bigint(20) NOT NULL COMMENT 'Maximaler Wert',
 `STEP` bigint(20) NOT NULL COMMENT 'Die Anzahl der Werte, die jedes Mal übernommen werden',
 `TM_CREATE` datetime NOT NULL COMMENT 'Erstellungszeit',
 `TM_SMP` datetime NICHT NULL STANDARD CURRENT_TIMESTAMP BEI UPDATE CURRENT_TIMESTAMP KOMMENTAR 'Änderungszeitpunkt',
 PRIMÄRSCHLÜSSEL (`SEQ_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='Tabelle zur Seriennummerngenerierung';

/**
 * <p></p>
 * @Autor Coderzl
 * @Titel MysqlSequence
 * @Description Sequenz basierend auf MySQL-Datenbank * @date 2017/6/6 23:03
 */
öffentliche Schnittstelle MysqlSequence {
 /**
  * <p>
  * Holen Sie sich die Seriennummer der angegebenen Sequenz * </p>
  * @param seqName Sequenzname* @return String Sequenznummer*/
 öffentliche Zeichenfolge nextVal (Zeichenfolgename);
}

/**
 * <p></p>
 *
 * @Autor Coderzl
 * @Titelsequenzbereich
 * @Description Sequenzintervall, das zum Zwischenspeichern der Sequenz verwendet wird * @date 2017/6/6 22:58
 */
 @Daten
öffentliche Klasse SequenceRange {
 privates letztes langes min;
 privates endgültiges langes Maximum;
 /** */
 privater endgültiger AtomicLong-Wert;
 /** Liegt es über dem Limit? */
 privater flüchtiger Boolescher Wert über = false;

 /**
  * Konstruktion.
  *
  * @param min 
  * @param max 
  */
 öffentlicher Sequenzbereich(lang min, lang max) {
  dies.min = min;
  dies.max = max;
  dieser.Wert = neues AtomicLong(min);
 }

 /**
  * <p>Ruft ab und erhöht</p>
  *
  * @zurückkehren 
  */
 öffentliche lange getAndIncrement() {
  langer aktuellerWert = Wert.getAndIncrement();
  wenn (aktuellerWert > max) {
   über = wahr;
   Rückgabe -1;
  }

  aktuelleWert zurückgeben;
 }

}

@Daten
öffentliche Klasse MysqlSequenceBo {
 /**
  * Sequenzname */
 privater String-Sequenzname;
 /**
  * Aktueller Wert */
 privater langer Sequenzwert;
 /**
  * Mindestwert */
 privater langer Mindestwert;
 /**
  * Maximalwert */
 privater langer Maximalwert;
 /**
  * Die Anzahl der jeweils erfassten Werte */
 privat Langer Schritt;
 /** */
 privates Datum tmCreate;
 /** */
 privates Datum tmSmp;

 öffentliches Boolean validieren(){
  //Einige einfache Prüfungen. Beispielsweise muss der aktuelle Wert zwischen dem Maximal- und Minimalwert liegen. Schrittwert kann nicht größer sein als die Differenz zwischen Max und Minif (StringUtil.isBlank(seqName) || minValue < 0 || maxValue <= 0 || Schritt <= 0 || minValue >= maxValue || maxValue - minValue <= Schritt ||seqValue < minValue || seqValue > maxValue ) {
   gibt false zurück;
  }
  gibt true zurück; 
 }
}

öffentliche Schnittstelle MysqlSequenceDAO {
 /**
 * 
 */
 öffentliche int createSequence(MysqlSequenceBo bo);

 öffentliche int updSequence(@Param("seqName") String seqName, @Param("alterWert") langer alterWert ,@Param("neuerWert") langer neuerWert);

 öffentliche int delSequence(@Param("seqName") String seqName);

 öffentliche MysqlSequenceBo getSequence(@Param("seqName") String seqName);

 öffentliche Liste<MysqlSequenceBo> getAll();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xxxxx.core.sequence.impl.dao.MysqlSequenceDAO" >
 <resultMap id="BaseResultMap" Typ="com.xxxxx.core.sequence.impl.MysqlSequenceBo" >
  <Ergebnisspalte="SEQ_NAME" Eigenschaft="seqName" jdbcType="VARCHAR" />
  <Ergebnisspalte="SEQ_VALUE" Eigenschaft="seqValue" jdbcType="BIGINT" />
  <Ergebnis Spalte="MIN_VALUE" Eigenschaft="minValue" jdbcType="BIGINT" />
  <Ergebnis Spalte="MAX_VALUE" Eigenschaft="maxValue" jdbcType="BIGINT" />
  <Ergebnis Spalte="SCHRITT" Eigenschaft="Schritt" jdbcType="BIGINT" />
  <Ergebnisspalte="TM_CREATE" Eigenschaft="tmCreate" jdbcType="TIMESTAMP" />
  <Ergebnisspalte="TM_SMP" Eigenschaft="tmSmp" jdbcType="TIMESTAMP" />
 </resultMap>
 <delete id="delSequence" parameterType="java.lang.String" >
  aus t_pub_sequence löschen
  wobei SEQ_NAME = #{seqName,jdbcType=VARCHAR}
 </löschen>
 <insert id="createSequence" parameterType="com.xxxxx.core.sequence.impl.MysqlSequenceBo" >
  einfügen in t_pub_sequence (SEQ_NAME,SEQ_VALUE,MIN_VALUE,MAX_VALUE,STEP,TM_CREATE)
  Werte (#{seqName,jdbcType=VARCHAR}, #{seqValue,jdbcType=BIGINT},
  #{minValue,jdbcType=BIGINT}, #{maxValue,jdbcType=BIGINT}, #{Schritt,jdbcType=BIGINT},
  Jetzt())
 </einfügen>
 <update id="updSequence" parameterType="com.xxxxx.core.sequence.impl.MysqlSequenceBo" >
  t_pub_sequence aktualisieren
  setze SEQ_VALUE = #{newValue,jdbcType=BIGINT}
  wobei SEQ_NAME = #{seqName,jdbcType=VARCHAR} und SEQ_VALUE = #{oldValue,jdbcType=BIGINT}
 </Aktualisieren>

 <select id="getAll" resultMap="BaseResultMap" >
  Wählen Sie SEQ_NAME, SEQ_VALUE, MIN_VALUE, MAX_VALUE, STEP
  von t_pub_sequence
 </Auswählen>

 <select id="getSequence" resultMap="BaseResultMap" >
  Wählen Sie SEQ_NAME, SEQ_VALUE, MIN_VALUE, MAX_VALUE, STEP
  von t_pub_sequence
  wobei SEQ_NAME = #{seqName,jdbcType=VARCHAR}
 </Auswählen>
</mapper>

@Repository("mysqlSequenz")
öffentliche Klasse MysqlSequenceImpl implementiert MysqlSequence{

 @Autowired
 private MysqlSequenceFactory mysqlSequenceFactory;
 /**
  * <p>
  * Holen Sie sich die Seriennummer der angegebenen Sequenz * </p>
  *
  * @param seqName Sequenzname * @return String Sequenznummer * @author coderzl
  */
 @Überschreiben
 öffentliche Zeichenfolge nextVal(Zeichenfolgename) {
  gibt Objects.toString zurück (mysqlSequenceFactory.getNextVal (seqName));
 }
}

@Komponente
öffentliche Klasse MysqlSequenceFactory {

 privates endgültiges Lock-Lock = neues ReentrantLock();

 /** */
 private Map<String,MysqlSequenceHolder> holderMap = neue ConcurrentHashMap<>();

 @Autowired
 privates MysqlSequenceDAO msqlSequenceDAO;
 /** Die Anzahl der Wiederholungsversuche für die fehlgeschlagene Initialisierung eines optimistischen Sperrupdates für eine einzelne Sequenz*/
 @Wert("${seq.init.retry:5}")
 private int initRetryNum;
 /** Die Anzahl der Wiederholungsversuche für fehlgeschlagene optimistische Sperraktualisierungen eines einzelnen Sequenzintervalls*/
 @Wert("${seq.get.retry:20}")
 private int getRetryNum;

 @PostKonstrukt
 private void init(){
  //Alle Sequenzen initialisieren
  initAll();
 }


 /**
  * <p>Alle Sequenzen in die Tabelle laden und Initialisierung abschließen</p>
  * @return ungültig
  * @Autor Coderzl
  */
 private void initAll(){
  versuchen {
   sperre.sperre();
   Liste<MysqlSequenceBo> boList = msqlSequenceDAO.getAll();
   wenn (boList == null) {
    throw new IllegalArgumentException("Der Sequenzdatensatz ist null!");
   }
   für (MysqlSequenceBo bo : boList) {
    MysqlSequenceHolder-Inhaber = neuer MysqlSequenceHolder (msqlSequenceDAO, bo, initRetryNum, getRetryNum);
    halter.init();
    holderMap.put(bo.getSeqName(), Inhaber);
   }
  }Endlich {
   sperren.entsperren();
  }
 }


 /**
  * <p> </p>
  * @param Sequenzname
  * @return lang
  * @Autor Coderzl
  */
 öffentliche lange getNextVal(String seqName){
  MysqlSequenceHolder-Inhaber = holderMap.get(seqName);
  wenn (Inhaber == null) {
   versuchen {
    sperre.sperre();
    Inhaber = InhaberMap.get(seqName);
    wenn (Inhaber != null){
     gibt holder.getNextVal() zurück;
    }
    MysqlSequenceBo bo = msqlSequenceDAO.getSequence(seqName);
    Halter = neuer MysqlSequenceHolder(msqlSequenceDAO, bo,initRetryNum,getRetryNum);
    halter.init();
    holderMap.put(seqName, Inhaber);
   }Endlich {
    sperren.entsperren();
   }
  }
  gibt holder.getNextVal() zurück;
 }

}

öffentliche Klasse MysqlSequenceHolder {

 privates endgültiges Lock-Lock = neues ReentrantLock();

 /** Sequenzname */
 privater String-Sequenzname;

 /** SequenzDao */
 private MysqlSequenceDAO-SequenzDAO;

 private MysqlSequenceBo-SequenzBo;
 /** */
 privater SequenceRange-Sequenzbereich;
 /** Ob initialisiert werden soll */
 privater flüchtiger Boolescher Wert ist Initialisieren = false;
 /**Wiederholungsversuche für die Sequenzinitialisierung*/
 private int initRetryNum;
 /**Sequenz erhält die Anzahl der Wiederholungsversuche*/
 private int getRetryNum;

 /**
  * <p>Konstruktor</p>
  * @Titel MysqlSequenceHolder
  * @param sequenceDAO 
  * @param sequenceBo
  * @param initRetryNum Die Anzahl der Wiederholungsversuche, nachdem eine Datenbankaktualisierung während der Initialisierung fehlgeschlagen ist. * @param getRetryNum Die Anzahl der Wiederholungsversuche, nachdem eine Datenbankaktualisierung beim Abrufen von nextVal fehlgeschlagen ist. * @return
  * @Autor Coderzl
  */
 öffentliche MysqlSequenceHolder(MysqlSequenceDAO sequenceDAO, MysqlSequenceBo sequenceBo, int initRetryNum, int getRetryNum) {
  dies.sequenceDAO = sequenceDAO;
  diese.sequenzBo = sequenzBo;
  this.initRetryNum = initRetryNum;
  Dies.getRetryNum = getRetryNum;
  wenn(SequenzBo != null)
   this.seqName = sequenceBo.getSeqName();
 }

 /**
  * <p> Initialisierung </p>
  * @Title init
  * @param
  * @return ungültig
  * @Autor Coderzl
  */
 öffentliche void init(){
  wenn (istInitialisieren == wahr) {
   throw new SequenceException("[" + seqName + "] der MysqlSequenceHolder wurde initialisiert");
  }
  wenn (sequenceDAO == null) {
   throw new SequenceException("[" + seqName + "] das sequenceDao ist null");
  }
  wenn (seqName == null || seqName.trim().length() == 0) {
   throw new SequenceException("[" + seqName + "] der Sequenzname ist null");
  }
  wenn (SequenzBo == null) {
   throw new SequenceException("[" + seqName + "] die sequenceBo ist null");
  }
  wenn (!sequenceBo.validate()){
   throw new SequenceException("[" + seqName + "] die Validierung von sequenceBo ist fehlgeschlagen. BO:"+sequenceBo);
  }
  // Initialisiere die Sequenz
  versuchen {
   initSequenceRecord(sequenceBo);
  } Fang (Sequenzausnahme e) {
   werfen e;
  }
  istInitialisieren = wahr;
 }

 /**
  * <p>Holen Sie sich die nächste Sequenznummer</p>
  * @Title getNextVal
  * @param
  * @return lang
  * @Autor Coderzl
  */
 öffentliche lange getNextVal(){
  wenn(istInitialisieren == false){
   throw new SequenceException("[" + seqName + "] der MysqlSequenceHolder nicht initialisiert");
  }
  wenn (Sequenzbereich == null) {
   throw new SequenceException("[" + seqName + "] der sequenceRange ist null");
  }
  langer aktueller Wert = sequenceRange.getAndIncrement();

  wenn(aktuellerWert == -1){
   versuchen{
    sperre.sperre();
    aktuellerWert = sequenceRange.getAndIncrement();
    wenn(aktuellerWert != -1){
     gibt aktuellen Wert zurück;
    }
    Sequenzbereich = Wiederholungsbereich();
    aktuellerWert = sequenceRange.getAndIncrement();
   }Endlich {
    sperren.entsperren();
   }
  }
  gibt aktuellen Wert zurück;
 }

 /**
  * <p> Initialisieren Sie den aktuellen Datensatz </p>
  * @Title initSequenceRecord
  * @Beschreibung
  * @param sequenceBo
  * @return ungültig
  * @Autor Coderzl
  */
 private void initSequenceRecord(MysqlSequenceBo sequenceBo){
  //Optimistische Sperre aktualisiert Datenbankeinträge innerhalb einer begrenzten Anzahl von Malen for(int i = 1; i < initRetryNum; i++){
   //Abfrage bo
   MysqlSequenceBo curBo = sequenceDAO.getSequence(sequenceBo.getSeqName());
   wenn(curBo == null){
    throw new SequenceException("[" + seqName + "] die aktuelle sequenceBo ist null");
   }
   wenn (!curBo.validate()){
    throw new SequenceException("[" + seqName + "] die Validierung der aktuellen sequenceBo ist fehlgeschlagen");
   }
   //Ändern Sie den aktuellen Wert long newValue = curBo.getSeqValue()+curBo.getStep();
   //Überprüfe den aktuellen Wert if(!checkCurrentValue(newValue,curBo)){
    neuerWert = ResetAktuellerWert(curBo);
   }
   int Ergebnis = sequenceDAO.updSequence(sequenceBo.getSeqName(),curBo.getSeqValue(),newValue);
   wenn(Ergebnis > 0){
    Sequenzbereich = neuer Sequenzbereich (curBo.getSeqValue(), neuerWert - 1);
    curBo.setSeqValue(neuerWert);
    diese.sequenceBo = curBo;
    zurückkehren;
   }anders{
    weitermachen;
   }
  }
  //Wenn das Update innerhalb der angegebenen Anzahl von Malen fehlschlägt, wird eine Ausnahme ausgelöst. throw new SequenceException("[" + seqName + "] sequenceBo update error");
 }

 /**
  * <p>Überprüfen Sie, ob der neue Wert zulässig ist und ob der neue aktuelle Wert zwischen den Maximal- und Minimalwerten liegt.</p>
  * @param aktueller Wert
  * @param curBo
  * @return Boolescher Wert
  * @Autor Coderzl
  */
 privater Boolescher Wert checkCurrentValue(langer aktuellerWert,MysqlSequenceBo aktuellerWert){
  wenn(aktuellerWert > curBo.getMinValue() und aktuellerWert <= curBo.getMaxValue()){
   gibt true zurück;
  }
  gibt false zurück;
 }

 /**
  * <p> Aktuellen Wert der Sequenz zurücksetzen: Wenn die aktuelle Sequenz den Maximalwert erreicht, beginnt sie wieder beim Minimalwert.</p>
  * @Titel setzt aktuellen Wert zurück
  * @param curBo
  * @return lang
  * @Autor Coderzl
  */
 private long resetCurrentValue(MysqlSequenceBo curBo){
  gibt curBo.getMinValue() zurück;
 }

 /**
  * <p>Wenn das Cache-Intervall aufgebraucht ist, lesen Sie die Datenbankeinträge erneut und speichern Sie das neue Sequenzsegment im Cache.</p>
  * @Title Wiederholungsbereich
  * @param SequenceRange
  * @Autor Coderzl
  */
 privater Sequenzbereich retryRange(){
  für(int i = 1; i < getRetryNum; i++){
   //Abfrage bo
   MysqlSequenceBo curBo = sequenceDAO.getSequence(sequenceBo.getSeqName());
   wenn(curBo == null){
    throw new SequenceException("[" + seqName + "] die aktuelle sequenceBo ist null");
   }
   wenn (!curBo.validate()){
    throw new SequenceException("[" + seqName + "] die Validierung der aktuellen sequenceBo ist fehlgeschlagen");
   }
   //Ändern Sie den aktuellen Wert long newValue = curBo.getSeqValue()+curBo.getStep();
   //Überprüfe den aktuellen Wert if(!checkCurrentValue(newValue,curBo)){
    neuerWert = ResetAktuellerWert(curBo);
   }
   int Ergebnis = sequenceDAO.updSequence(sequenceBo.getSeqName(),curBo.getSeqValue(),newValue);
   wenn(Ergebnis > 0){
    Sequenzbereich = neuer Sequenzbereich (curBo.getSeqValue(), neuerWert - 1);
    curBo.setSeqValue(neuerWert);
    diese.sequenceBo = curBo;
    Sequenzbereich zurückgeben;
   }anders{
    weitermachen;
   }
  }
  neue SequenceException werfen("[" + seqName + "] sequenceBo-Aktualisierungsfehler");

 }
}

@Service
öffentliche Klasse JrnGeneratorService {
 private statische endgültige Zeichenfolge SEQ_NAME = "T_SEQ_TEST";

 /** Sequenzdienst */
 @Autowired
 private MySqlSequence mySqlSequence;
 
 öffentliche Zeichenfolge generierenJrn() {
  versuchen {
   Zeichenfolgensequenz = mySqlSequence.getNextValue(SEQ_NAME);
   Sequenz = linkeAuffüllung(Sequenz,8);
   Kalender Kalender = Kalender.getInstance();
   SimpleDateFormat sDateFormat = neues SimpleDateFormat("yyyyMMddHHmmss");
   Zeichenfolge nowdate = sDateFormat.format(calendar.getTime());
   nowdate.substring(4, nowdate.length());
   String jrn = nowdate + sequence + RandomUtil.getFixedLengthRandom(6); //10-stellige Zeit + 8-stellige Sequenz + 6-stellige Zufallszahl = 24-stellige Seriennummer return jrn;
  } Fang (Ausnahme e) {
   //ZU TUN
  }
 }
 
 private String leftPadding(String seq,int len){
  Zeichenfolge res = "";
  Zeichenfolge str = "";
  wenn(seq.length()<len){
   für(int i=0;i<len-seq.length();i++){
    str +="0"; 
   }   
  }
  res = str + seq;
  Rückgabewert;
  
 }

}