雪花算法代码替换，以及dev的application配置

src/main/java/com/emato/cuspay/common/core/db/IdWorker.java

@@ -1,45 +1,68 @@
 package com.emato.cuspay.common.core.db;
 
 /**
- * 雪花算法自造全局自增ID
- * 
- * @ClassName: IdWorker
- * @author twitter
- * @date 2017年2月22日 下午5:48:32
- * @Description: TODO自造全局自增ID，适合大数据环境的分布式场景 每秒能够产生26万ID左右
- * 
- * 
- * @ClassName: IdWorker
- * @author yechao
- * @date 2017年5月6日 下午5:44:19
- * @Description: TODO
+ * Twitter_Snowflake<br>
+ * SnowFlake的结构如下(每部分用-分开):<br>
+ * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
+ * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
+ * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
+ * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
+ * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
+ * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
+ * 加起来刚好64位，为一个Long型。<br>
+ * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
  */
 public class IdWorker {
+	// ==============================Fields===========================================
+	/** 开始时间截 (2015-01-01) */
+	private final long twepoch = 1420041600000L;
+
+	/** 机器id所占的位数 */
+	private final long workerIdBits = 5L;
+
+	/** 数据标识id所占的位数 */
+	private final long datacenterIdBits = 5L;
+
+	/** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
+	private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
+
+	/** 支持的最大数据标识id，结果是31 */
+	private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
+
+	/** 序列在id中占的位数 */
+	private final long sequenceBits = 12L;
+
+	/** 机器ID向左移12位 */
+	private final long workerIdShift = sequenceBits;
+
+	/** 数据标识id向左移17位(12+5) */
+	private final long datacenterIdShift = sequenceBits + workerIdBits;
+
+	/** 时间截向左移22位(5+5+12) */
+	private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
+
+	/** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
+	private final long sequenceMask = -1L ^ (-1L << sequenceBits);
+
+	/** 工作机器ID(0~31) */
 	private long workerId;
+
+	/** 数据中心ID(0~31) */
 	private long datacenterId;
+
+	/** 毫秒内序列(0~4095) */
 	private long sequence = 0L;
-	// 基准时间2010
-	private static long twepoch = 1288834974657L;
-	// 机器标识位数
-	private static long workerIdBits = 5;
-	// 数据中心标识位数
-	private static long datacenterIdBits = 5L;
-	// 机器标识最大值
-	private static long maxWorkerId = -1L ^ (-1L << (int) workerIdBits);
-	// 数据中心标识最大值
-	private static long maxDatacenterId = -1L ^ (-1L << (int) datacenterIdBits);
-	// 毫秒内序列号识位数
-	private static long sequenceBits = 12L;
-
-	private long workerIdShift = sequenceBits;
-	private long datacenterIdShift = sequenceBits + workerIdBits;
-	private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
-	private long sequenceMask = -1L ^ (-1L << (int) sequenceBits);
 
+	/** 上次生成ID的时间截 */
 	private long lastTimestamp = -1L;
 
+	//==============================Constructors=====================================
+	/**
+	 * 构造函数
+	 * @param workerId 工作ID (0~31)
+	 * @param datacenterId 数据中心ID (0~31)
+	 */
 	public IdWorker(long workerId, long datacenterId) {
-		// sanity check for workerId
 		if (workerId > maxWorkerId || workerId < 0) {
 			throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
 		}
@@ -50,29 +73,49 @@ public class IdWorker {
 		this.datacenterId = datacenterId;
 	}
 
+	// ==============================Methods==========================================
+	/**
+	 * 获得下一个ID (该方法是线程安全的)
+	 * @return SnowflakeId
+	 */
 	public synchronized long nextId() {
 		long timestamp = timeGen();
 
+		//如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
 		if (timestamp < lastTimestamp) {
 			throw new RuntimeException(
 					String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
 		}
 
+		//如果是同一时间生成的，则进行毫秒内序列
 		if (lastTimestamp == timestamp) {
 			sequence = (sequence + 1) & sequenceMask;
+			//毫秒内序列溢出
 			if (sequence == 0) {
+				//阻塞到下一个毫秒,获得新的时间戳
 				timestamp = tilNextMillis(lastTimestamp);
 			}
-		} else {
+		}
+		//时间戳改变，毫秒内序列重置
+		else {
 			sequence = 0L;
 		}
 
+		//上次生成ID的时间截
 		lastTimestamp = timestamp;
 
-		return ((timestamp - twepoch) << (int) timestampLeftShift) | (datacenterId << (int) datacenterIdShift) | (workerId << (int) workerIdShift)
+		//移位并通过或运算拼到一起组成64位的ID
+		return ((timestamp - twepoch) << timestampLeftShift) //
+				| (datacenterId << datacenterIdShift) //
+				| (workerId << workerIdShift) //
 				| sequence;
 	}
 
+	/**
+	 * 阻塞到下一个毫秒，直到获得新的时间戳
+	 * @param lastTimestamp 上次生成ID的时间截
+	 * @return 当前时间戳
+	 */
 	protected long tilNextMillis(long lastTimestamp) {
 		long timestamp = timeGen();
 		while (timestamp <= lastTimestamp) {
@@ -81,8 +124,24 @@ public class IdWorker {
 		return timestamp;
 	}
 
+	/**
+	 * 返回以毫秒为单位的当前时间
+	 * @return 当前时间(毫秒)
+	 */
 	protected long timeGen() {
-
 		return System.currentTimeMillis();
 	}
+
+	//==============================Test=============================================
+	/** 测试 */
+	public static void main(String[] args) {
+        /*IdWorker idWorker = new IdWorker(0, 0);
+        for (int i = 0; i < 100; i++) {
+            long id = idWorker.nextId();
+            System.out.println(Long.toBinaryString(id));
+            System.out.println(id);
+        }*/
+
+	}
+
 }

src/main/java/com/emato/cuspay/common/core/db/IdWorkerAide.java

@@ -1,15 +1,17 @@
 package com.emato.cuspay.common.core.db;
 
-
 import com.emato.cuspay.manager.redis.jedis.cluster.mgt.JedisClusterManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class IdWorkerAide {
+	private static final Logger logger = LoggerFactory.getLogger(IdWorkerAide.class);
 
 	private static IdWorker idWorker;
 
 	public static long nextId() {
 		if (idWorker == null) {
-			initIdWorker();
+			idWorker = initIdWorker();
 		}
 		return idWorker.nextId();
 	}
@@ -17,7 +19,7 @@ public class IdWorkerAide {
 	/**
 	 * 实例化idWorker
 	 */
-	private static void initIdWorker() {
+	public static IdWorker initIdWorker() {
 		String workerIdKey = "sequence-workerId";
 		// 机器id
 		Integer workerId = (Integer) JedisClusterManager.instance().getObject(workerIdKey);
@@ -28,6 +30,7 @@ public class IdWorkerAide {
 
 		// 数据中心id
 		Integer datacenterId = (Integer) JedisClusterManager.instance().getObject(datacenterIdKey);
+
 		if (datacenterId == null) {
 			datacenterId = 0;
 		} else {
@@ -47,7 +50,7 @@ public class IdWorkerAide {
 			JedisClusterManager.instance().setObject(datacenterIdKey, datacenterId);
 		}
 
-		idWorker = new IdWorker(workerId, datacenterId);
+		return new IdWorker(workerId, datacenterId);
 	}
 
 }

src/main/resources/application-dev.yml

@@ -1,7 +1,77 @@
+#---------- Spring Boot 项目 ----------#
+# 测试环境服务配置
+server:
+    address: 192.168.1.68
+    port: 8080
 
-# 当前环境
+
+# 使用环境
 spring:
-  profiles: dev
+    profiles: dev
+
+
+    # 测试环境rabbitmq配置
+    rabbitmq:
+        host: 192.168.1.248
+        port: 5672
+        username: guest
+        password: guest
+        virtual-host: /
+        # Requested heartbeat timeout, in seconds; zero for none.
+        requested-heartbeat: 50
+        cache:
+            channel:
+                size: 50
+
+
+    # 数据源
+    datasource:
+        primary:
+            # 数据源zaxxer HikariCP
+            type: com.zaxxer.hikari.HikariDataSource
+            driver-class-name: org.mariadb.jdbc.Driver
+            url: jdbc:mysql://120.76.84.45:3306/cuspay?useSSL=false&useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&autoReconnect=true&failOverReadOnly=false&zeroDateTimeBehavior=convertToNull
+            username: ceshi
+            password: abc-123
+            # hikari连接池配置
+            hikari:
+                connection-timeout: 10000
+                validation-timeout: 5000
+                idle-timeout: 600000
+                max-lifetime: 1200000
+                maximum-pool-size: 3
+                minimum-idle: 3
+
 
+redis:
+    # JedisCluster
+    jedis-cluster:
+        # Redis Cluster 主机列表
+        redis-cluster-host-list:
+            - host: 192.168.1.248
+              port: 7000
+            - host: 192.168.1.248
+              port: 7001
+            - host: 192.168.1.248
+              port: 7002
+            - host: 192.168.1.249
+              port: 7003
+            - host: 192.168.1.249
+              port: 7004
+            - host: 192.168.1.249
+              port: 7005
+        # 连接超时时间(秒), 默认 2*1000
+        connection-timeout: 5000
+        # so-timeout:
+        # 最大重试次数
+        max-attempts: 5
+        # password:
+        pool-config:
+            # 连接池管理的对象实例最大数, 默认 8
+            max-total: 8
+            # 连接池中最大闲置连接数, 默认 8
+            max-idle: 8
+            # 连接池中最小闲置连接数, 默认 0
+            min-idle: 0
 
 

src/main/resources/application.yml

@@ -8,8 +8,8 @@ app:
 
 # 服务配置
 server:
-    address: 127.0.0.1
-    port: 8080
+    address: 120.76.26.84
+    port: 9999
     servlet:
       context-path: /
 
@@ -20,7 +20,7 @@ ds:
 # 使用环境
 spring:
     profiles:
-        active:
+        active: dev
 
     # 使用CGLIB实现AOP
     aop:
@@ -33,9 +33,9 @@ spring:
             # 数据源zaxxer HikariCP
             type: com.zaxxer.hikari.HikariDataSource
             driver-class-name: org.mariadb.jdbc.Driver
-            url: jdbc:mysql://120.76.84.45:3306/cuspay?useSSL=false&useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&autoReconnect=true&failOverReadOnly=false&zeroDateTimeBehavior=convertToNull
-            username: ceshi
-            password: abc-123
+            url: jdbc:mysql://rm-wz9rps8173a1nx63g.mysql.rds.aliyuncs.com:3306/cuspay?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true
+            username: qh_cus
+            password: Ci*&k89Cf
             # hikari连接池配置
             hikari:
                 connection-timeout: 10000
@@ -50,42 +50,19 @@ redis:
     jedis-cluster:
         # Redis Cluster 主机列表
         redis-cluster-host-list:
-            - host: 192.168.1.248
+            - host: 120.76.84.45
               port: 7000
-            - host: 192.168.1.248
+            - host: 120.76.84.45
               port: 7001
-            - host: 192.168.1.248
+            - host: 120.76.84.45
               port: 7002
-            - host: 192.168.1.249
+            - host: 120.76.26.84
               port: 7003
-            - host: 192.168.1.249
+            - host: 120.76.26.84
               port: 7004
-            - host: 192.168.1.249
+            - host: 120.76.26.84
               port: 7005
-#            - host: 127.0.0.1
-#              port: 7000
-#            - host: 127.0.0.1
-#              port: 7001
-#            - host: 127.0.0.1
-#              port: 7002
-#            - host: 127.0.0.1
-#              port: 7003
-#            - host: 127.0.0.1
-#              port: 7004
-#            - host: 127.0.0.1
-#              port: 7005
-#            - host: qhdswl.f3322.net
-#              port: 7000
-#            - host: qhdswl.f3322.net
-#              port: 7001
-#            - host: qhdswl.f3322.net
-#              port: 7002
-#            - host: qhdswl.f3322.net
-#              port: 7003
-#            - host: qhdswl.f3322.net
-#              port: 7004
-#            - host: qhdswl.f3322.net
-#              port: 7005
+        password: Abc-123#*.-
 
         # 连接超时时间(秒), 默认 2*1000
         connection-timeout: 5000