在專案中經常有生成唯一ID的業務需求。作為唯一標識方便後續查詢和追蹤。網上也有很多實現方案。比如：資料庫自增主鍵，資料庫批次生成ID，UUID，時間戳方法，zookeeper生成ID，redis生成唯一ID，snowflake演算法等等。這些解決方案各有優缺點。我在遊戲專案常用的解決方案是：預分配法生成唯一ID。其原理簡單，利於擴充套件，具有較強的適用性。

預分配法生成唯一ID原理：資料庫中儲存每種型別最後的預分配dbUniqueId值。資料庫實體物件上增加當前分配的
useDbUniqueId。預分配步長DBUNIQUEID_M可根據型別和業務量自定義。當useDbUniqueId大於等於dbUniqueId時就預分配出DBUNIQUEID_M個唯一ID。

角色ID生成：要求7位連續的唯一ID。則DBUNIQUEID_M=1。1000000+dbUniqueId格式化成7位數字。

本服唯一ID：則DBUNIQUEID_M=10000。(1000000+dbUniqueId)*10000+serverId格式化而成。其中serverId遊戲服ID定義為4位

全域性唯一ID：則DBUNIQUEID_M=10000。((100000000000L+dbUniqueId)*100+gameCode*10000+workerId;格式化而成。其中gameCode遊戲編碼定義為2位。

具體實現請參閱程式碼。非常方便的移植到專案工程中。

IdWorkerEnum.java

```java
package com.game.common.db;

import java.util.List;

import com.core.enums.LLIndexedEnum;

/**
 * ID列舉型別
 * @author Thinker
 */
public enum IdWorkerEnum implements LLIndexedEnum
{
	/** 角色ID */
	IDWORKER_HUMANID(1,"角色ID"),
	/** 資料庫ID */
	IDWORKER_DBID(2,"資料庫ID"),
	/** 工會ID */
	IDWORKER_CLUBID(3,"工會ID"),
	/** 收集ID */
	IDWORKER_COLLECTID(4,"收集ID"),;
	/** 列舉的索引 */
	public final int index;
	/** 名稱的key */
	private final String nameKey;
    
	/** 按索引順序存放的列舉陣列 */
	private static final List<idworkerenum> indexes=LLIndexedEnum.IndexedEnumUtil.toIndexes(IdWorkerEnum.values());

private IdWorkerEnum(int index,String nameKey)
	{
		this.index=index;
		this.nameKey=nameKey;
	}

/**
	 * 獲取索引
	 */
	@Override
	public int getIndex()
	{
		return index;
	}

/**
	 * 取得名稱key
	 */
	public String getNameKey()
	{
		return this.nameKey;
	}

/**
	 * 根據指定的索引獲取列舉的定義
	 */
	public static IdWorkerEnum valueOf(final int index)
	{
		return LLIndexedEnum.IndexedEnumUtil.valueOf(indexes,index);
	}
}
```

DbUniqueIdEntity.java

```java
package com.game.common.db;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import org.eclipse.persistence.annotations.HashPartitioning;
import org.eclipse.persistence.annotations.Partitioned;
import com.game.common.db.dao.BaseDbBean;

/**
 * 資料庫唯一KEY實體類
 * @author Thinker
 */
@Entity(name="t_dbUniqueId")
@HashPartitioning(name="HashPartitionByDbUniqueCacheId",partitionColumn=@Column(name="dbUniqueCacheId"))
@Partitioned("HashPartitionByDbUniqueCacheId")
public class DbUniqueIdEntity extends BaseDbBean
{
	/** 資料庫唯一快取ID **/
	@Id
	@Column(length=20)
	private long dbUniqueCacheId;

/** 資料庫唯一ID **/
	@Column(length=20)
	private long dbUniqueId;

/** 最後更新的時間 **/
	@Column(length=20)
	private long createTime;

// ////////////////內部資料//////////////////
	/** 已經使用過的資料庫唯一ID(唯一ID) */
	@Column(length=20)
	private long useDbUniqueId;

@Override
	public long getId()
	{
		return dbUniqueCacheId;
	}

@Override
	public void setId(long id)
	{
	}

public long getDbUniqueCacheId()
	{
		return dbUniqueCacheId;
	}

public void setDbUniqueCacheId(long dbUniqueCacheId)
	{
		this.dbUniqueCacheId=dbUniqueCacheId;
	}

public long getDbUniqueId()
	{
		return dbUniqueId;
	}

public void setDbUniqueId(long dbUniqueId)
	{
		this.dbUniqueId=dbUniqueId;
	}

public long getCreateTime()
	{
		return createTime;
	}

public void setCreateTime(long createTime)
	{
		this.createTime=createTime;
	}

public long getUseDbUniqueId()
	{
		return useDbUniqueId;
	}

public void setUseDbUniqueId(long useDbUniqueId)
	{
		this.useDbUniqueId=useDbUniqueId;
	}
}
```

IdWorker.java

```java
package com.game.common.db;

import com.game.common.Globals;
import com.game.common.entityProxy.EntityProxy;
import com.game.core.appConfig.AppConfigServ;
import com.game.core.utils.LoggerUtils;

/**
 * 唯一ID生成器
 * 
 * @author Thinker
 */
public class IdWorker
{
	public final static IdWorker OBJ=new IdWorker(AppConfigServ.OBJ.getAppConfigBean().getServerNo());
	private int DBUNIQUEID_M=2000;
	private final long workerId;
	/** 資料庫連線池 */
	private DbUniqueIdEntity[] szDbUniqueIdEntity=new DbUniqueIdEntity[5];

public IdWorker(long workerId)
	{
		this.workerId=workerId;
	}

/**
	 * 生成系統唯一ID:採用隱性鎖方式
	 */
	public synchronized long nextId()
	{
		IdWorkerEnum idWorkerEnum=IdWorkerEnum.IDWORKER_DBID;
		int dbUniqueCacheId=idWorkerEnum.getIndex();

loadDbUniqueId(idWorkerEnum);
		DbUniqueIdEntity dbUniqueIdEntity=szDbUniqueIdEntity[dbUniqueCacheId];
		long dbUniqueId=0;
		// 需要重新分配Id:每次分配 M個
		if(dbUniqueIdEntity.getUseDbUniqueId()>=dbUniqueIdEntity.getDbUniqueId())
		{
			dbUniqueIdEntity.setDbUniqueId(dbUniqueIdEntity.getDbUniqueId()+DBUNIQUEID_M);
			EntityProxy.OBJ.update((long) dbUniqueCacheId,dbUniqueIdEntity);
			LoggerUtils.serverLogger.info("IdWorker DbId:update dbUniqueId="+dbUniqueIdEntity.getDbUniqueId());
		}
		dbUniqueId=dbUniqueIdEntity.getUseDbUniqueId()+1;
		dbUniqueIdEntity.setUseDbUniqueId(dbUniqueId);
		// 11位UUID
		return (1000000+dbUniqueId)*10000+workerId;
	}

/**
	 * 生成系統唯一HumanID:採用隱性鎖方式
	 */
	public synchronized long nextHumanId()
	{
		IdWorkerEnum idWorkerEnum=IdWorkerEnum.IDWORKER_HUMANID;
		int dbUniqueCacheId=idWorkerEnum.getIndex();

loadDbUniqueId(idWorkerEnum);
		DbUniqueIdEntity dbUniqueIdEntity=szDbUniqueIdEntity[dbUniqueCacheId];
		long dbUniqueId=0;
		// 需要重新分配Id:每次分配 M個
		if(dbUniqueIdEntity.getUseDbUniqueId()>=dbUniqueIdEntity.getDbUniqueId())
		{
			dbUniqueIdEntity.setDbUniqueId(dbUniqueIdEntity.getDbUniqueId()+1);
			EntityProxy.OBJ.update((long) dbUniqueCacheId,dbUniqueIdEntity);
			LoggerUtils.serverLogger.info("IdWorker HumanId:update dbUniqueId="+dbUniqueIdEntity.getDbUniqueId());
		}
		dbUniqueId=dbUniqueIdEntity.getUseDbUniqueId()+1;
		dbUniqueIdEntity.setUseDbUniqueId(dbUniqueId);
		// 7位UUID
		return (1000000+dbUniqueId);
	}

/**
	 * 生成系統唯一ClubID:採用隱性鎖方式
	 */
	public synchronized long nextClubId()
	{
		IdWorkerEnum idWorkerEnum=IdWorkerEnum.IDWORKER_CLUBID;
		int dbUniqueCacheId=idWorkerEnum.getIndex();

loadDbUniqueId(idWorkerEnum);
		DbUniqueIdEntity dbUniqueIdEntity=szDbUniqueIdEntity[dbUniqueCacheId];
		long dbUniqueId=0;
		// 需要重新分配Id:每次分配 M個
		if(dbUniqueIdEntity.getUseDbUniqueId()>=dbUniqueIdEntity.getDbUniqueId())
		{
			dbUniqueIdEntity.setDbUniqueId(dbUniqueIdEntity.getDbUniqueId()+1);
			EntityProxy.OBJ.update((long) dbUniqueCacheId,dbUniqueIdEntity);
			LoggerUtils.serverLogger.info("IdWorker clubId:update dbUniqueId="+dbUniqueIdEntity.getDbUniqueId());
		}
		dbUniqueId=dbUniqueIdEntity.getUseDbUniqueId()+1;
		dbUniqueIdEntity.setUseDbUniqueId(dbUniqueId);
		// 5位UUID
		return (10000+dbUniqueId);
	}

/**
	 * 生成系統唯一ID:採用隱性鎖方式
	 */
	public synchronized long nextCollectId()
	{
		IdWorkerEnum idWorkerEnum=IdWorkerEnum.IDWORKER_COLLECTID;
		int dbUniqueCacheId=idWorkerEnum.getIndex();

loadDbUniqueId(idWorkerEnum);
		DbUniqueIdEntity dbUniqueIdEntity=szDbUniqueIdEntity[dbUniqueCacheId];
		long dbUniqueId=0;
		// 需要重新分配Id:每次分配 M個
		if(dbUniqueIdEntity.getUseDbUniqueId()>=dbUniqueIdEntity.getDbUniqueId())
		{
			dbUniqueIdEntity.setDbUniqueId(dbUniqueIdEntity.getDbUniqueId()+DBUNIQUEID_M);
			EntityProxy.OBJ.update((long) dbUniqueCacheId,dbUniqueIdEntity);
			LoggerUtils.serverLogger.info("IdWorker DbId:update dbUniqueId="+dbUniqueIdEntity.getDbUniqueId());
		}
		dbUniqueId=dbUniqueIdEntity.getUseDbUniqueId()+1;
		dbUniqueIdEntity.setUseDbUniqueId(dbUniqueId);
		// 18位UUID:遊戲ID+伺服器ID。確保支援多遊戲不重複的ID。便於相容統計
		return ((100000000000L+dbUniqueId)*100+AppConfigServ.OBJ.getAppConfigBean().getGameCode())*10000+workerId;
	}

/**
	 * 載入唯一ID
	 */
	public void loadDbUniqueId(IdWorkerEnum idWorkerEnum)
	{
		int dbUniqueCacheId=idWorkerEnum.getIndex();
		if(szDbUniqueIdEntity[dbUniqueCacheId]!=null) return;
		DbUniqueIdEntity dbUniqueIdEntity=EntityProxy.OBJ.get((long) dbUniqueCacheId,(long) dbUniqueCacheId,DbUniqueIdEntity.class);
		if(dbUniqueIdEntity==null)
		{
			dbUniqueIdEntity=new DbUniqueIdEntity();
			dbUniqueIdEntity.setDbUniqueCacheId(dbUniqueCacheId);
			dbUniqueIdEntity.setDbUniqueId(0);
			dbUniqueIdEntity.setCreateTime(Globals.getTimeService().now());
			dbUniqueIdEntity.setUseDbUniqueId(0);
			EntityProxy.OBJ.insert((long) dbUniqueCacheId,dbUniqueIdEntity);
		}
		dbUniqueIdEntity.setUseDbUniqueId(dbUniqueIdEntity.getDbUniqueId());
		szDbUniqueIdEntity[dbUniqueCacheId]=dbUniqueIdEntity;
		LoggerUtils.serverLogger.info("IdWorker:load dbUniqueId="+dbUniqueIdEntity.getDbUniqueId());
	}
}
```</idworkerenum>

預分配法生成唯一ID

相關文章