生成多应用实例无间隙序列号指南

import jakarta.persistence.*;

@Entity
@Table(name = "series_counter")
public class SeriesCounter {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "series_id", unique = true, nullable = false)
    private String seriesId; // 例如 "AA", "BB"

    @Column(name = "current_counter", nullable = false)
    private Long currentCounter; // 当前下一个可用的序列号

    // 构造函数
    public SeriesCounter() {}

    public SeriesCounter(String seriesId, Long currentCounter) {
        this.seriesId = seriesId;
        this.currentCounter = currentCounter;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getSeriesId() { return seriesId; }
    public void setSeriesId(String seriesId) { this.seriesId = seriesId; }
    public Long getCurrentCounter() { return currentCounter; }
    public void setCurrentCounter(Long currentCounter) { this.currentCounter = currentCounter; }

    // 递增计数器的方法
    public void incrementValue() {
        this.currentCounter++;
    }
}

@Entity
@Table(name = "device")
public class Device {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "series", nullable = false)
    private String series;

    @Column(name = "number", nullable = false)
    private Long number;

    // 构造函数
    public Device() {}

    public Device(String series, Long number) {
        this.series = series;
        this.number = number;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getSeries() { return series; }
    public void setSeries(String series) { this.series = series; }
    public Long getNumber() { return number; }
    public void setNumber(Long number) { this.number = number; }
}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Lock;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import jakarta.persistence.LockModeType;
import java.util.Optional;

public interface SeriesCounterRepository extends JpaRepository<SeriesCounter, Long> {

    /**
     * 根据seriesId获取并锁定对应的SeriesCounter记录。
     * 使用PESSIMISTIC_WRITE悲观锁，确保在当前事务中对该行的独占访问。
     *
     * @param seriesId 要锁定的系列ID
     * @return 包含SeriesCounter的Optional对象
     */
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT sc FROM SeriesCounter sc WHERE sc.seriesId = :seriesId")
    Optional<SeriesCounter> findBySeriesIdWithLock(@Param("seriesId") String seriesId);
}

public interface DeviceRepository extends JpaRepository<Device, Long> {
    // 基础的CRUD操作
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class DeviceNumberGeneratorService {

    private final SeriesCounterRepository seriesCounterRepository;
    private final DeviceRepository deviceRepository;

    public DeviceNumberGeneratorService(SeriesCounterRepository seriesCounterRepository, DeviceRepository deviceRepository) {
        this.seriesCounterRepository = seriesCounterRepository;
        this.deviceRepository = deviceRepository;
    }

    /**
     * 生成一个无间隙的设备序列号。
     * 整个操作在一个事务中完成，并对计数器进行悲观锁定。
     *
     * @param seriesId        要生成序列号的系列ID
     * @param maxNumForSeries 该系列允许的最大序列号（业务逻辑限制）
     * @return 生成的设备对象
     * @throws IllegalStateException 如果当前系列已达到最大数量
     */
    @Transactional // 确保整个方法在一个事务中执行
    public Device generateDeviceNumber(String seriesId, int maxNumForSeries) {
        // 1. 获取并锁定对应系列的计数器
        // 如果series_counter表中没有该seriesId的记录，则需要初始化。
        // 生产环境中，通常会在系统启动或首次使用时预先初始化所有series的计数器。
        // 这里简化处理，如果不存在则抛出异常，或根据实际需求添加初始化逻辑。
        SeriesCounter seriesCounter = seriesCounterRepository.findBySeriesIdWithLock(seriesId)
                .orElseThrow(() -> new IllegalArgumentException("SeriesCounter for seriesId " + seriesId + " not found. Please initialize it."));

        Long currentNumber = seriesCounter.getCurrentCounter();

        // 2. 检查是否达到当前系列的最大允许数量
        if (currentNumber > maxNumForSeries) {
            // 如果当前系列已满，根据业务需求可以抛出异常，
            // 或者实现切换到下一个系列的逻辑（例如，通过查找下一个可用的seriesId并递归调用）。
            throw new IllegalStateException("Series " + seriesId + " has reached its maximum number " + maxNumForSeries + ". Cannot generate more numbers for this series.");
        }

        // 3. 使用当前计数生成设备号
        Device newDevice = new Device();
        newDevice.setSeries(seriesId);
        newDevice.setNumber(currentNumber);
        // ... 设置其他设备属性，例如设备名称、型号等

        // 4. 保存新的设备记录
        deviceRepository.save(newDevice);

        // 5. 递增计数器，为下一个请求准备
        seriesCounter.incrementValue(); // currentCounter++
        seriesCounterRepository.save(seriesCounter); // 更新计数器，将递增后的值持久化

        return newDevice;
    }
}