Merge pull request #24 from hellojavaer/1.0.x

hellojavaer · web-flow · commit 1cd9cf8c029f · 2017-08-07T02:53:47.000+08:00
rename 'IdRange' to 'SequenceRange'
diff --git a/ddal-sequence/src/main/java/org/hellojavaer/ddal/sequence/DatabaseSequenceRangeGetter.java b/ddal-sequence/src/main/java/org/hellojavaer/ddal/sequence/DatabaseSequenceRangeGetter.java
@@ -192,7 +192,7 @@ public void init() {
     public SequenceRange get(String schemaName, String tableName, int step) throws Exception {
         init();
         int rows = 0;
-        SequenceRange idRange = null;
+        SequenceRange sequenceRange = null;
         Connection connection = this.connection;
         PreparedStatement selectStatement = null;
         PreparedStatement updateStatement = null;
@@ -231,17 +231,17 @@ public SequenceRange get(String schemaName, String tableName, int step) throws E
                 }
                 version = ((Number) selectResult.getLong(6)).longValue();
             } else {
-                throw new NoAvailableSequenceRangeFoundException("No available id rang was found for schemaName:'"
+                throw new NoAvailableSequenceRangeFoundException("No available sequence rang was found for schemaName:'"
                                                                  + schemaName + "', tableName:'" + tableName + "'");
             }
             // 数据库步长优先
             if (dbStep != null && dbStep > 0) {
                 step = dbStep;
             }
-            long idRangeBegin = nextValue;
-            long idRangeEnd = nextValue + step - 1;
-            if (endValue != null && idRangeEnd > endValue) {
-                idRangeEnd = endValue;
+            long rangeBegin = nextValue;
+            long rangeEnd = nextValue + step - 1;
+            if (endValue != null && rangeEnd > endValue) {
+                rangeEnd = endValue;
             }
             updateStatement = connection.prepareStatement(targetUpdateSql);
             boolean dirtyRow = false;
@@ -270,21 +270,21 @@ public SequenceRange get(String schemaName, String tableName, int step) throws E
             if (rows > 0) {
                 if (dirtyRow) {// 兼容异常数据
                     throw new IllegalSequenceRangeException(
-                                                      String.format("Illegal id range {id:%s, nextValue:%s, endValue:%s, version:%s, deleted:0}",
+                                                      String.format("Illegal sequence range {id:%s, nextValue:%s, endValue:%s, version:%s, deleted:0}",
                                                                     id, nextValue, endValue, version));
                 }
                 if (logger.isInfoEnabled()) {
-                    logger.info("[Get_Range]: " + idRange);
+                    logger.info("[Get_Range]: " + sequenceRange);
                 }
                 if (deleted == 1) {
                     if (logger.isInfoEnabled()) {
                         logger.info("Id range for schemaName:{},tableName:{} is used up. More detail information is step:{},"
                                             + "endValue:{},version:{},id:{} and actually allocated range is '{} ~ {}'",
                                     schemaName, tableName, step,//
-                                    endValue, version, id, idRangeBegin, idRangeEnd);
+                                    endValue, version, id, rangeBegin, rangeEnd);
                     }
                 }
-                return new SequenceRange(idRangeBegin, idRangeEnd);
+                return new SequenceRange(rangeBegin, rangeEnd);
             } else {
                 throw new ConcurrentModificationException();
             }
diff --git a/ddal-sequence/src/main/java/org/hellojavaer/ddal/sequence/SequenceCache.java b/ddal-sequence/src/main/java/org/hellojavaer/ddal/sequence/SequenceCache.java
@@ -87,7 +87,7 @@ public void run() {
                     }
                     //
                     try {
-                        SequenceRange range = getIdRange();
+                        SequenceRange range = getSequenceRange();
                         if (range == null) {
                             throw new NoAvailableSequenceRangeFoundException("No available id range was found");
                         }
@@ -115,17 +115,17 @@ public void run() {
                             }
                         }
                         if (e instanceof IllegalSequenceRangeException) {
-                            logger.error("[GetIdRange] " + e.getMessage());
+                            logger.error("[GetSequenceRange] " + e.getMessage());
                         } else if (e instanceof NoAvailableSequenceRangeFoundException) {
-                            logger.error("[GetIdRange] " + e.getMessage());
+                            logger.error("[GetSequenceRange] " + e.getMessage());
                         } else {
-                            logger.error("[GetIdRange]", e);
+                            logger.error("[GetSequenceRange]", e);
                         }
                         if (retryCount.get() >= delayRetryBaseLine) {
                             try {
                                 Thread.sleep(sleepTimes[(int) (retryCount.get() - delayRetryBaseLine)]);
                             } catch (InterruptedException e1) {
-                                logger.error("[GetIdRange]", e1);
+                                logger.error("[GetSequenceRange]", e1);
                             }
                         }
                         if (retryCount.get() < endCount) {
@@ -137,5 +137,5 @@ public void run() {
         }.start();
     }
 
-    public abstract SequenceRange getIdRange() throws Exception;
+    public abstract SequenceRange getSequenceRange() throws Exception;
 }
diff --git a/ddal-sequence/src/main/java/org/hellojavaer/ddal/sequence/SingleSequence.java b/ddal-sequence/src/main/java/org/hellojavaer/ddal/sequence/SingleSequence.java
@@ -34,44 +34,46 @@
  */
 public class SingleSequence implements Sequence {
 
-    private Logger           logger                        = LoggerFactory.getLogger(this.getClass());
+    private Logger                 logger                        = LoggerFactory.getLogger(this.getClass());
 
-    private static final int DEFAULT_DELAY_RETRY_BASE_LINE = 4;
+    private static final int       DEFAULT_DELAY_RETRY_BASE_LINE = 4;
 
-    private String              schemaName;
-    private String              tableName;
-    private Integer             step;                                                                    // 单节点步长
-    private Integer             cacheNSteps;                                                             // 缓存队列大小
-    private Integer             initTimeout;
-    private SequenceRangeGetter idRangeGetter;
-    private ExceptionHandler    exceptionHandler;
-    private Integer          delayRetryBaseLine            = DEFAULT_DELAY_RETRY_BASE_LINE;
+    private String                 schemaName;
+    private String                 tableName;
+    private Integer                step;                                                                    // 单节点步长
+    private Integer                cacheNSteps;                                                             // 缓存队列大小
+    private Integer                initTimeout;
+    private SequenceRangeGetter    sequenceRangeGetter;
+    private ExceptionHandler       exceptionHandler;
+    private Integer                delayRetryBaseLine            = DEFAULT_DELAY_RETRY_BASE_LINE;
 
-    private volatile SequenceCache idCache;
-    private boolean          initialized                   = false;
+    private volatile SequenceCache sequenceCache;
+    private boolean                initialized                   = false;
 
     public SingleSequence() {
     }
 
     public SingleSequence(String schemaName, String tableName, Integer step, Integer cacheNSteps, Integer initTimeout,
-                          SequenceRangeGetter idRangeGetter) {
-        this(schemaName, tableName, step, cacheNSteps, initTimeout, idRangeGetter, null, DEFAULT_DELAY_RETRY_BASE_LINE);
+                          SequenceRangeGetter sequenceRangeGetter) {
+        this(schemaName, tableName, step, cacheNSteps, initTimeout, sequenceRangeGetter, null,
+             DEFAULT_DELAY_RETRY_BASE_LINE);
     }
 
     public SingleSequence(String schemaName, String tableName, Integer step, Integer cacheNSteps, Integer initTimeout,
-                          SequenceRangeGetter idRangeGetter, ExceptionHandler exceptionHandler) {
-        this(schemaName, tableName, step, cacheNSteps, initTimeout, idRangeGetter, exceptionHandler,
+                          SequenceRangeGetter sequenceRangeGetter, ExceptionHandler exceptionHandler) {
+        this(schemaName, tableName, step, cacheNSteps, initTimeout, sequenceRangeGetter, exceptionHandler,
              DEFAULT_DELAY_RETRY_BASE_LINE);
     }
 
     public SingleSequence(String schemaName, String tableName, Integer step, Integer cacheNSteps, Integer initTimeout,
-                          SequenceRangeGetter idRangeGetter, ExceptionHandler exceptionHandler, Integer delayRetryBaseLine) {
+                          SequenceRangeGetter sequenceRangeGetter, ExceptionHandler exceptionHandler,
+                          Integer delayRetryBaseLine) {
         this.schemaName = schemaName;
         this.tableName = tableName;
         this.step = step;
         this.cacheNSteps = cacheNSteps;
         this.initTimeout = initTimeout;
-        this.idRangeGetter = idRangeGetter;
+        this.sequenceRangeGetter = sequenceRangeGetter;
         this.exceptionHandler = exceptionHandler;
         this.delayRetryBaseLine = delayRetryBaseLine;
         init();
@@ -89,28 +91,30 @@ public void init() {
                     Assert.isTrue(cacheNSteps > 0, "'cacheNSteps' must be greater than 0");
                     Assert.notNull(initTimeout, "'initTimeout' can't be null'");
                     Assert.isTrue(initTimeout > 0, "'initTimeout' must be greater than 0");
-                    Assert.notNull(idRangeGetter, "'idRangeGetter' can't be null'");
+                    Assert.notNull(sequenceRangeGetter, "'sequenceRangeGetter' can't be null'");
                     Assert.notNull(delayRetryBaseLine, "'delayRetryBaseLine' can't be null'");
                     Assert.isTrue(delayRetryBaseLine > 0, "'delayRetryBaseLine' must be greater than 0");
                     try {
-                        this.idCache = new SequenceCache(step, cacheNSteps, initTimeout, exceptionHandler, delayRetryBaseLine) {
+                        this.sequenceCache = new SequenceCache(step, cacheNSteps, initTimeout, exceptionHandler,
+                                                               delayRetryBaseLine) {
 
                             @Override
-                            public SequenceRange getIdRange() throws Exception {
-                                SequenceRange idRange = getIdRangeGetter().get(getSchemaName(), getTableName(), getStep());
-                                if (idRange == null) {
+                            public SequenceRange getSequenceRange() throws Exception {
+                                SequenceRange sequenceRange = getSequenceRangeGetter().get(getSchemaName(), getTableName(),
+                                                                                     getStep());
+                                if (sequenceRange == null) {
                                     throw new NoAvailableSequenceRangeFoundException(
-                                                                               "No available id rang was found for schemaName:'"
-                                                                                       + getSchemaName()
-                                                                                       + "', tableName:'"
-                                                                                       + getTableName() + "'");
+                                                                                     "No available sequence rang was found for schemaName:'"
+                                                                                             + getSchemaName()
+                                                                                             + "', tableName:'"
+                                                                                             + getTableName() + "'");
                                 }
-                                if (idRange.getBeginValue() > idRange.getEndValue()) {
-                                    throw new IllegalSequenceRangeException("Illegal id range " + idRange
+                                if (sequenceRange.getBeginValue() > sequenceRange.getEndValue()) {
+                                    throw new IllegalSequenceRangeException("Illegal sequence range " + sequenceRange
                                                                             + " for schemaName:'" + getSchemaName()
                                                                             + "', tableName:'" + getTableName() + "'");
                                 }
-                                return idRange;
+                                return sequenceRange;
                             }
                         };
                     } catch (InterruptedException e) {
@@ -128,7 +132,7 @@ public SequenceRange getIdRange() throws Exception {
     public long nextValue(long timeout, TimeUnit timeUnit) throws GetSequenceTimeoutException {
         try {
             init();
-            return idCache.get(timeout, timeUnit);
+            return sequenceCache.get(timeout, timeUnit);
         } catch (TimeoutException e1) {
             throw new GetSequenceTimeoutException(e1);
         } catch (SequenceException e0) {
@@ -178,12 +182,12 @@ public void setInitTimeout(Integer initTimeout) {
         this.initTimeout = initTimeout;
     }
 
-    public SequenceRangeGetter getIdRangeGetter() {
-        return idRangeGetter;
+    public SequenceRangeGetter getSequenceRangeGetter() {
+        return sequenceRangeGetter;
     }
 
-    public void setIdRangeGetter(SequenceRangeGetter idRangeGetter) {
-        this.idRangeGetter = idRangeGetter;
+    public void setSequenceRangeGetter(SequenceRangeGetter sequenceRangeGetter) {
+        this.sequenceRangeGetter = sequenceRangeGetter;
     }
 
     public ExceptionHandler getExceptionHandler() {
diff --git a/ddal-sequence/src/main/java/org/hellojavaer/ddal/sequence/SummedBlockingQueue.java b/ddal-sequence/src/main/java/org/hellojavaer/ddal/sequence/SummedBlockingQueue.java
@@ -85,11 +85,11 @@ public AtomicLong getCounter() {
         }
     }
 
-    public void put(SequenceRange idRange) throws InterruptedException {
-        if (idRange.getEndValue() < idRange.getBeginValue()) {
+    public void put(SequenceRange sequenceRange) throws InterruptedException {
+        if (sequenceRange.getEndValue() < sequenceRange.getBeginValue()) {
             throw new IllegalArgumentException("end value must be greater than or equal to begin value");
         }
-        Node node = new Node(new InnerSequenceRange(idRange.getBeginValue(), idRange.getEndValue()));
+        Node node = new Node(new InnerSequenceRange(sequenceRange.getBeginValue(), sequenceRange.getEndValue()));
         final ReentrantLock putLock = this.putLock;
         final AtomicInteger count = this.countForCapacity;
         putLock.lockInterruptibly();
@@ -100,7 +100,7 @@ public void put(SequenceRange idRange) throws InterruptedException {
             }
             enqueue(node);
             c = count.incrementAndGet();
-            long s = countForSum.addAndGet(idRange.getEndValue() - idRange.getBeginValue() + 1);
+            long s = countForSum.addAndGet(sequenceRange.getEndValue() - sequenceRange.getBeginValue() + 1);
             if (s < sum) {
                 notFull.signal();
             }
@@ -117,21 +117,21 @@ public long get(long timeout, TimeUnit unit) throws InterruptedException, Timeou
         if (unit == null) {
             throw new IllegalArgumentException("'unit' can't be null");
         }
-        InnerSequenceRange idRange = threadLocal.get();
-        if (idRange != null) {
-            long id = idRange.getCounter().getAndIncrement();
-            if (id <= idRange.getEndValue()) {
+        InnerSequenceRange range = threadLocal.get();
+        if (range != null) {
+            long id = range.getCounter().getAndIncrement();
+            if (id <= range.getEndValue()) {
                 long c = countForSum.decrementAndGet();
                 if (c == sum - 1) {
                     signalNotFull();
                 }
-                if (id == idRange.getEndValue()) {
-                    remove(idRange);
+                if (id == range.getEndValue()) {
+                    remove(range);
                     threadLocal.set(null);
                 }
                 return id;
             } else {
-                remove(idRange);
+                remove(range);
                 threadLocal.set(null);
                 return recursiveGetFromQueue(timeout, unit);
             }
@@ -144,24 +144,24 @@ private long recursiveGetFromQueue(long timeout, TimeUnit unit) throws TimeoutEx
         long nanoTimeout = unit.toNanos(timeout);
         while (true) {
             long now = System.nanoTime();
-            InnerSequenceRange idRange = get(nanoTimeout);
-            if (idRange == null) {
+            InnerSequenceRange sequenceRange = get(nanoTimeout);
+            if (sequenceRange == null) {
                 throw new TimeoutException(timeout + " " + unit);
             } else {
-                long id = idRange.getCounter().getAndIncrement();
-                if (id <= idRange.getEndValue()) {
+                long id = sequenceRange.getCounter().getAndIncrement();
+                if (id <= sequenceRange.getEndValue()) {
                     long c = countForSum.decrementAndGet();
                     if (c == sum - 1) {
                         signalNotFull();
                     }
-                    if (id == idRange.getEndValue()) {
-                        remove(idRange);
+                    if (id == sequenceRange.getEndValue()) {
+                        remove(sequenceRange);
                     } else {
-                        threadLocal.set(idRange);
+                        threadLocal.set(sequenceRange);
                     }
                     return id;
                 } else {
-                    remove(idRange);
+                    remove(sequenceRange);
                     nanoTimeout -= System.nanoTime() - now;
                     if (nanoTimeout <= 0) {
                         throw new TimeoutException(timeout + " " + unit);

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ public void run() {`
`87`	`87`	`}`
`88`	`88`	`//`
`89`	`89`	`try {`
`90`		`- SequenceRange range = getIdRange();`
	`90`	`+ SequenceRange range = getSequenceRange();`
`91`	`91`	`if (range == null) {`
`92`	`92`	`throw new NoAvailableSequenceRangeFoundException("No available id range was found");`
`93`	`93`	`}`
`@@ -115,17 +115,17 @@ public void run() {`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`	`if (e instanceof IllegalSequenceRangeException) {`
`118`		`- logger.error("[GetIdRange] " + e.getMessage());`
	`118`	`+ logger.error("[GetSequenceRange] " + e.getMessage());`
`119`	`119`	`} else if (e instanceof NoAvailableSequenceRangeFoundException) {`
`120`		`- logger.error("[GetIdRange] " + e.getMessage());`
	`120`	`+ logger.error("[GetSequenceRange] " + e.getMessage());`
`121`	`121`	`} else {`
`122`		`- logger.error("[GetIdRange]", e);`
	`122`	`+ logger.error("[GetSequenceRange]", e);`
`123`	`123`	`}`
`124`	`124`	`if (retryCount.get() >= delayRetryBaseLine) {`
`125`	`125`	`try {`
`126`	`126`	`Thread.sleep(sleepTimes[(int) (retryCount.get() - delayRetryBaseLine)]);`
`127`	`127`	`} catch (InterruptedException e1) {`
`128`		`- logger.error("[GetIdRange]", e1);`
	`128`	`+ logger.error("[GetSequenceRange]", e1);`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`	`if (retryCount.get() < endCount) {`
`@@ -137,5 +137,5 @@ public void run() {`
`137`	`137`	`}.start();`
`138`	`138`	`}`
`139`	`139`
`140`		`- public abstract SequenceRange getIdRange() throws Exception;`
	`140`	`+ public abstract SequenceRange getSequenceRange() throws Exception;`
`141`	`141`	`}`