IdGenerator

多进程多线程,全局唯一的id自增


public class IdGenerator {
	private final static String SELECT_ALL_ID_INFO = "SELECT Name FROM IDGenInfo";
	private final static String SELECT_ID_INFO = "SELECT Current, Step FROM IDGenInfo WHERE Name = ? FOR UPDATE";
	private final static String UPDATE_ID_INFO = "UPDATE IDGenInfo SET Current = Current + Step WHERE Name = ?";

	private ConcurrentHashMap<String, IdInfo> counters = new ConcurrentHashMap<String, IdInfo>();
	private boolean enabled = true;

	private IdGenerator() {
		ArrayList<String> names = DbManager.instance().executeQuery_ObjectList(
				SELECT_ALL_ID_INFO, ScalarResultBuilder.stringResultBuilder);
		for (String name : names) {
			counters.put(name, new IdInfo(name, 0, 0));
		}
	}

	private final static IdGenerator _instance = new IdGenerator();

	public static IdGenerator instance() {
		return _instance;
	}
	
	private long genNewId(String name) {
		if (!enabled){
			ApplicationLocal.instance().error("invalid operation:can Not gen new id after persist!");
			return -1;
		}
		
		IdInfo ii = counters.get(name);
		if (ii == null) {
			return -1;
		}

		synchronized (ii) {
			if (ii.count == 0) {
				fillIdInfo(ii, name);
				if (ii.count == 0) {
					return -1;
				}
			}
			ii.count--;
			ii.val++;
			return ii.val;
		}
	}
	
	public int next(String name) {
		return (int)genNewId(name);
	}
	
	public long nextBigId(String name){
		return genNewId(name);
	}

	private void fillIdInfo(IdInfo ii, String name) {
		Connection conn = null;
		PreparedStatement stmt = null;
		ResultSet rs = null;
		try {
			conn = DbManager.instance().getConnection();
			conn.setAutoCommit(false);

			stmt = conn.prepareStatement(SELECT_ID_INFO);
			stmt.setString(1, name);
			rs = stmt.executeQuery();
			rs.next();

			ii.val = rs.getLong("Current");
			ii.count = rs.getInt("Step");

			stmt.close();

			stmt = conn.prepareStatement(UPDATE_ID_INFO);
			stmt.setString(1, name);
			stmt.execute();

			conn.commit();
		} catch (Exception ex) {
			try {
				conn.rollback();
			} catch (Exception e) {

			}

			ii.reset();
			ApplicationLocal.instance().error("fill id info error :", ex);
		} finally {
			DbManager.releaseDbResource(rs, stmt, conn);
		}
	}	

	static class IdInfo {
		public String name;
		public long val;
		public int count;

		public IdInfo(String name, long val, int count) {
			this.name = name;
			this.val = val;
			this.count = count;
		}

		public void reset() {
			this.val = -1;
			this.count = 0;
		}
	}
}



表结构:

CREATE TABLE `IDGenInfo` (
`Name` VARCHAR(45) NOT NULL,
`Current` BIGINT(10) UNSIGNED NOT NULL,
`Step` MEDIUMINT(8) UNSIGNED NOT NULL,
PRIMARY KEY (`Name`)
)
COLLATE='utf8_general_ci'
ENGINE=InnoDB;



<think>我们参考了引用[1]、[3]和[4],这些引用展示了在JPA中使用雪花算法生成ID的不同实现方式。用户的问题是如何在JPA中正确使用SnowflakeIdGenerator生成ID。下面我们将结合这些引用,提供一个清晰的步骤指南。###步骤1:创建雪花算法ID生成器类首先,我们需要实现一个雪花算法ID生成器。这里我们可以参考引用[1]和[3]中的实现,但要注意,在JPA中,我们需要实现Hibernate的`IdentifierGenerator`接口。```javaimportorg.hibernate.engine.spi.SharedSessionContractImplementor;importorg.hibernate.id.IdentifierGenerator;importjava.io.Serializable;publicclassSnowflakeIdGeneratorimplementsIdentifierGenerator{//这里使用hutool的雪花算法,也可以自己实现privatefinalcn.hutool.core.lang.Snowflakesnowflake=newcn.hutool.core.lang.Snowflake(1,1);@OverridepublicSerializablegenerate(SharedSessionContractImplementorsession,Objectobject){returnsnowflake.nextId();}}```注意:这里使用了Hutool工具包的雪花算法,需要添加依赖:```xml<dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.8.5</version></dependency>```###步骤2:在实体类中配置ID生成策略接下来,在实体类中,我们需要使用JPA的注解来指定使用自定义的ID生成器。参考引用[4],我们可以通过`@GenericGenerator`和`@GeneratedValue`注解来指定。####方式一:直接在实体类的ID字段上配置```javaimportjavax.persistence.*;importorg.hibernate.annotations.GenericGenerator;@EntitypublicclassUser{@Id@GeneratedValue(generator="snowflakeIdGenerator")@GenericGenerator(name="snowflakeIdGenerator",strategy="com.example.SnowflakeIdGenerator")privateLongid;//注意:这里使用Long类型//其他字段...}```####方式二:使用基类(推荐,避免重复配置)参考引用[4],我们可以创建一个基类,所有需要雪花ID的实体都继承这个基类。```javaimportjavax.persistence.*;importjava.io.Serializable;@MappedSuperclasspublicabstractclassBaseEntityimplementsSerializable{@Id@GeneratedValue(generator="snowflakeIdGenerator")@GenericGenerator(name="snowflakeIdGenerator",strategy="com.example.SnowflakeIdGenerator")privateLongid;publicLonggetId(){returnid;}publicvoidsetId(Longid){this.id=id;}}```然后实体类继承基类:```java@EntitypublicclassUserextendsBaseEntity{//其他字段...}```###步骤3:解决前端Long类型精度丢失问题由于雪花算法生成的ID是Long类型(64位),而JavaScript只能精确表示53位以内的整数(Number类型),所以返回给前端时可能会出现精度丢失。我们可以参考引用[4]中使用的`@JsonFormat`注解将ID转换为字符串返回。在基类中,对id字段添加注解:```javaimportcom.fasterxml.jackson.annotation.JsonFormat;@MappedSuperclasspublicabstractclassBaseEntityimplementsSerializable{@Id@GeneratedValue(generator="snowflakeIdGenerator")@GenericGenerator(name="snowflakeIdGenerator",strategy="com.example.SnowflakeIdGenerator")@JsonFormat(shape=JsonFormat.Shape.STRING)//将Long类型的id转换为字符串返回给前端privateLongid;//...getterandsetter}```###注意事项1.**确保生成器单例**:雪花算法要求同一个生成器实例在同一机器上保持单例,否则可能生成重复ID。在上述实现中,我们每次生成ID时都使用同一个Snowflake实例(因为SnowflakeIdGenerator在Hibernate中会被创建为单例)。2.**分布式环境**:在分布式环境中,需要确保每个实例的workerId和datacenterId唯一。可以通过配置文件或数据库来分配这两个参数。3.**Hibernate版本**:上述注解适用于Hibernate5.x和6.x,但注意Hibernate6.x中包路径有变化(如`org.hibernate.engine.spi.SharedSessionContractImplementor`在6.x中变为`org.hibernate.engine.spi.SharedSessionContract`)。###示例:配置不同的workerId和datacenterId如果我们需要动态配置workerId和datacenterId,可以修改生成器,从Spring容器中获取配置的Bean。参考引用[3]中的做法:```javapublicclassSnowflakeIdGeneratorimplementsIdentifierGenerator{//通过SpringUtil获取,需要确保SpringUtil能获取到Spring上下文privateSnowflakesnowflake=SpringUtil.getBean(Snowflake.class);@OverridepublicSerializablegenerate(SharedSessionContractImplementorsession,Objectobject){returnsnowflake.nextId();}}```然后配置SnowflakeBean:```java@ConfigurationpublicclassSnowflakeConfig{@Value("${snowflake.worker-id:0}")privatelongworkerId;@Value("${snowflake.datacenter-id:0}")privatelongdatacenterId;@BeanpublicSnowflakesnowflake(){returnnewSnowflake(workerId,datacenterId);}}```在application.properties中配置:```propertiessnowflake.worker-id=1snowflake.datacenter-id=1```###总结在JPA中使用雪花算法生成ID的关键步骤:1.实现`IdentifierGenerator`接口的自定义ID生成器。2.在实体类或基类中通过`@GenericGenerator`和`@GeneratedValue`注解指定自定义生成器。3.考虑前端精度问题,使用`@JsonFormat`将Long类型ID转为字符串。4.分布式环境下确保workerId和datacenterId唯一。§§相关问题§§1.如何在SpringBoot中配置Hutool的雪花算法参数?2.分布式环境下如何保证workerId和datacenterId的唯一性?3.如何解决Hibernate6.x中自定义ID生成器的兼容性问题?4.除了雪花算法,JPA还支持哪些分布式ID生成策略?5.如何测试自定义ID生成器在高并发下的唯一性?</think>### JPA中正确使用SnowflakeIdGenerator生成ID的完整指南 在JPA中使用雪花算法生成ID需要实现Hibernate的`IdentifierGenerator`接口并配置相关注解。以下是具体步骤: --- #### 1. 创建雪花算法ID生成器类 参考引用[1]和[3],实现`IdentifierGenerator`接口: ```java import cn.hutool.core.lang.Snowflake; import cn.hutool.core.util.IdUtil; import org.hibernate.HibernateException; import org.hibernate.engine.spi.SharedSessionContractImplementor; import org.hibernate.id.IdentifierGenerator; import java.io.Serializable; public class SnowflakeIdGenerator implements IdentifierGenerator { // 配置数据中心ID和机器ID(可从配置文件读取) private static final long DATACENTER_ID = 1; private static final long WORKER_ID = 1; private final Snowflake snowflake = IdUtil.createSnowflake(WORKER_ID, DATACENTER_ID); @Override public Serializable generate(SharedSessionContractImplementor session, Object object) { return snowflake.nextId(); // 生成Long类型ID } } ``` > **关键点**: > - 使用Hutool的`Snowflake`实现(需添加依赖) > - `DATACENTER_ID`和`WORKER_ID`应通过`@Value`注入[^1][^3] --- #### 2. 在实体类中配置ID生成策略 参考引用[4],使用JPA注解配置生成策略: ```java import javax.persistence.*; import org.hibernate.annotations.GenericGenerator; @Entity public class User { @Id @GeneratedValue(generator = "snowflake") @GenericGenerator( name = "snowflake", strategy = "com.yourpackage.SnowflakeIdGenerator" ) @JsonFormat(shape = JsonFormat.Shape.STRING) // 防止前端精度丢失 private Long id; // 使用Long类型接收ID // 其他字段... } ``` > **关键注解**: > - `@GenericGenerator`:声明自定义生成器 > - `@JsonFormat`:解决JavaScript精度问题(Long转String)[^4] --- #### 3. 配置基类(可选,推荐) 参考引用[4],创建公共基类简化配置: ```java @MappedSuperclass public abstract class BaseEntity { @Id @GeneratedValue(generator = "snowflake") @GenericGenerator( name = "snowflake", strategy = "com.yourpackage.SnowflakeIdGenerator" ) @JsonFormat(shape = JsonFormat.Shape.STRING) private Long id; // getter/setter } ``` 实体类继承基类: ```java @Entity public class Product extends BaseEntity { // 无需再声明ID字段 } ``` --- #### 4. 添加Maven依赖 ```xml <!-- Hutool工具包(含雪花算法) --> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.8.16</version> </dependency> <!-- Jackson(处理JSON序列化) --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.14.2</version> </dependency> ``` --- #### 5. 配置文件参数化(推荐) 在`application.yml`中配置参数: ```yaml snowflake: datacenter-id: 2 worker-id: 3 ``` 修改生成器类: ```java public class SnowflakeIdGenerator implements IdentifierGenerator { @Value("${snowflake.datacenter-id}") private long datacenterId; @Value("${snowflake.worker-id}") private long workerId; @Override public Serializable generate(...) { Snowflake snowflake = IdUtil.createSnowflake(workerId, datacenterId); return snowflake.nextId(); } } ``` --- ### 常见问题解决 1. **前端精度丢失** 添加`@JsonFormat(shape = JsonFormat.Shape.STRING)`将Long转为字符串[^4] 2. **分布式ID冲突** 确保每个服务的`workerId`唯一(可通过ZK/DB分配) 3. **Hibernate兼容性** 在Hibernate 6.x中使用: ```java public class SnowflakeGenerator implements IdentifierGenerator, Configurable { // 需额外实现configure方法 } ``` 4. **时钟回拨问题** 在Snowflake实现中添加异常处理: ```java try { return snowflake.nextId(); } catch (ClockBackwardException e) { // 等待时钟同步或使用备用ID } ``` --- ### 最佳实践建议 1. **ID类型选择** - 数据库使用`BIGINT`类型存储 - Java实体类使用`Long`类型 - API返回时转为`String`避免精度丢失 2. **性能优化** ```java // 预初始化Snowflake实例(非线程安全需同步) private static Snowflake INSTANCE; public synchronized Snowflake getInstance() { if(INSTANCE == null) { INSTANCE = IdUtil.getSnowflake(workerId, datacenterId); } return INSTANCE; } ``` 3. **监控指标** 添加ID生成速率和异常计数监控: ```java @Override public Serializable generate(...) { metrics.counter("id.generated").increment(); return getInstance().nextId(); } ``` --- ### 方案对比 | 方案 | 优点 | 缺点 | |--------------------|--------------------------|--------------------------| | 数据库自增 | 简单可靠 | 分布式扩展困难 | | 雪花算法 | 分布式友好,高性能 | 时钟回拨问题 | | 号段分配 | 减少DB压力 | 需要预分配机制 | > **结论**:在分布式系统中,雪花算法是JPA生成Long类型ID的最佳选择,结合`@GenericGenerator`配置可无缝集成[^2][^4]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值