第260集使用MySQL，实现一个高性能，分布式ID生成器架构实战：分布式ID设计、MySQL优化与企业级ID生成方案

/**
 * 基于MySQL的分布式ID生成器
 */
@Service
public class MySQLDistributedIdGenerator {

    @Autowired
    private IdGeneratorMapper idGeneratorMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private final Map<String, IdRange> localCache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    /**
     * 获取分布式ID
     */
    public Long generateId(String businessType) {
        // 1. 尝试从本地缓存获取
        IdRange idRange = localCache.get(businessType);
        if (idRange != null && idRange.hasNext()) {
            return idRange.next();
        }

        // 2. 从Redis缓存获取
        idRange = getFromRedisCache(businessType);
        if (idRange != null && idRange.hasNext()) {
            localCache.put(businessType, idRange);
            return idRange.next();
        }

        // 3. 从数据库获取新的ID段
        idRange = getNewIdRange(businessType);
        localCache.put(businessType, idRange);

        // 4. 异步更新Redis缓存
        updateRedisCache(businessType, idRange);

        return idRange.next();
    }

    /**
     * 批量获取分布式ID
     */
    public List<Long> generateIds(String businessType, int count) {
        List<Long> ids = new ArrayList<>();

        for (int i = 0; i < count; i++) {
            ids.add(generateId(businessType));
        }

        return ids;
    }

    /**
     * 从数据库获取新的ID段
     */
    private IdRange getNewIdRange(String businessType) {
        return idGeneratorMapper.getNewIdRange(businessType);
    }

    /**
     * 从Redis缓存获取ID段
     */
    private IdRange getFromRedisCache(String businessType) {
        String cacheKey = "id_range:" + businessType;
        return (IdRange) redisTemplate.opsForValue().get(cacheKey);
    }

    /**
     * 更新Redis缓存
     */
    private void updateRedisCache(String businessType, IdRange idRange) {
        CompletableFuture.runAsync(() -> {
            String cacheKey = "id_range:" + businessType;
            redisTemplate.opsForValue().set(cacheKey, idRange, Duration.ofMinutes(30));
        });
    }

    /**
     * ID段类
     */
    public static class IdRange {
        private long start;
        private long end;
        private long current;

        public IdRange(long start, long end) {
            this.start = start;
            this.end = end;
            this.current = start;
        }

        public boolean hasNext() {
            return current <= end;
        }

        public long next() {
            if (!hasNext()) {
                throw new IllegalStateException("ID段已用完");
            }
            return current++;
        }

        // getter和setter方法
        public long getStart() { return start; }
        public void setStart(long start) { this.start = start; }
        public long getEnd() { return end; }
        public void setEnd(long end) { this.end = end; }
        public long getCurrent() { return current; }
        public void setCurrent(long current) { this.current = current; }
    }
}

/**
 * ID生成器Mapper
 */
@Mapper
public interface IdGeneratorMapper {

    /**
     * 获取新的ID段
     */
    @Select("SELECT business_type, step_size, current_max_id FROM id_generator WHERE business_type = #{businessType}")
    IdGeneratorInfo getById(@Param("businessType") String businessType);

    /**
     * 更新ID段（使用乐观锁）
     */
    @Update("UPDATE id_generator SET current_max_id = current_max_id + step_size, version = version + 1, updated_time = NOW() WHERE business_type = #{businessType} AND version = #{version}")
    int updateIdRange(@Param("businessType") String businessType, @Param("version") int version);

    /**
     * 获取新的ID段（使用悲观锁）
     */
    @Select("SELECT business_type, step_size, current_max_id FROM id_generator WHERE business_type = #{businessType} FOR UPDATE")
    IdGeneratorInfo getByIdForUpdate(@Param("businessType") String businessType);

    /**
     * 更新ID段（悲观锁）
     */
    @Update("UPDATE id_generator SET current_max_id = current_max_id + step_size, updated_time = NOW() WHERE business_type = #{businessType}")
    int updateIdRangeForUpdate(@Param("businessType") String businessType);

    /**
     * 获取新的ID段（原子操作）
     */
    default MySQLDistributedIdGenerator.IdRange getNewIdRange(String businessType) {
        // 使用乐观锁重试机制
        int maxRetries = 3;
        for (int i = 0; i < maxRetries; i++) {
            IdGeneratorInfo info = getById(businessType);
            if (info == null) {
                throw new IllegalArgumentException("业务类型不存在: " + businessType);
            }

            long start = info.getCurrentMaxId() + 1;
            long end = info.getCurrentMaxId() + info.getStepSize();

            int updated = updateIdRange(businessType, info.getVersion());
            if (updated > 0) {
                return new MySQLDistributedIdGenerator.IdRange(start, end);
            }

            // 重试前等待一小段时间
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("线程被中断", e);
            }
        }

        throw new RuntimeException("获取ID段失败，重试次数已用完");
    }
}

/**
 * 基于MySQL的序列生成器
 */
@Service
public class MySQLSequenceGenerator {

    @Autowired
    private SequenceMapper sequenceMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private final Map<String, SequenceRange> localCache = new ConcurrentHashMap<>();

    /**
     * 获取下一个序列值
     */
    public Long nextValue(String sequenceName) {
        // 1. 尝试从本地缓存获取
        SequenceRange range = localCache.get(sequenceName);
        if (range != null && range.hasNext()) {
            return range.next();
        }

        // 2. 从Redis缓存获取
        range = getFromRedisCache(sequenceName);
        if (range != null && range.hasNext()) {
            localCache.put(sequenceName, range);
            return range.next();
        }

        // 3. 从数据库获取新的序列段
        range = getNewSequenceRange(sequenceName);
        localCache.put(sequenceName, range);

        // 4. 异步更新Redis缓存
        updateRedisCache(sequenceName, range);

        return range.next();
    }

    /**
     * 批量获取序列值
     */
    public List<Long> nextValues(String sequenceName, int count) {
        List<Long> values = new ArrayList<>();

        for (int i = 0; i < count; i++) {
            values.add(nextValue(sequenceName));
        }

        return values;
    }

    /**
     * 获取新的序列段
     */
    private SequenceRange getNewSequenceRange(String sequenceName) {
        return sequenceMapper.getNewSequenceRange(sequenceName);
    }

    /**
     * 从Redis缓存获取序列段
     */
    private SequenceRange getFromRedisCache(String sequenceName) {
        String cacheKey = "sequence_range:" + sequenceName;
        return (SequenceRange) redisTemplate.opsForValue().get(cacheKey);
    }

    /**
     * 更新Redis缓存
     */
    private void updateRedisCache(String sequenceName, SequenceRange range) {
        CompletableFuture.runAsync(() -> {
            String cacheKey = "sequence_range:" + sequenceName;
            redisTemplate.opsForValue().set(cacheKey, range, Duration.ofMinutes(30));
        });
    }

    /**
     * 序列段类
     */
    public static class SequenceRange {
        private long start;
        private long end;
        private long current;
        private int incrementBy;

        public SequenceRange(long start, long end, int incrementBy) {
            this.start = start;
            this.end = end;
            this.current = start;
            this.incrementBy = incrementBy;
        }

        public boolean hasNext() {
            return current <= end;
        }

        public long next() {
            if (!hasNext()) {
                throw new IllegalStateException("序列段已用完");
            }
            long value = current;
            current += incrementBy;
            return value;
        }

        // getter和setter方法
        public long getStart() { return start; }
        public void setStart(long start) { this.start = start; }
        public long getEnd() { return end; }
        public void setEnd(long end) { this.end = end; }
        public long getCurrent() { return current; }
        public void setCurrent(long current) { this.current = current; }
        public int getIncrementBy() { return incrementBy; }
        public void setIncrementBy(int incrementBy) { this.incrementBy = incrementBy; }
    }
}

/**
 * 基于MySQL的分段ID生成器
 */
@Service
public class MySQLSegmentIdGenerator {

    @Autowired
    private IdSegmentMapper idSegmentMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private final Map<String, SegmentInfo> localCache = new ConcurrentHashMap<>();

    /**
     * 获取分段ID
     */
    public Long generateId(String businessType) {
        // 1. 尝试从本地缓存获取
        SegmentInfo segment = localCache.get(businessType);
        if (segment != null && segment.hasNext()) {
            return segment.next();
        }

        // 2. 从Redis缓存获取
        segment = getFromRedisCache(businessType);
        if (segment != null && segment.hasNext()) {
            localCache.put(businessType, segment);
            return segment.next();
        }

        // 3. 从数据库获取新的分段
        segment = getNewSegment(businessType);
        localCache.put(businessType, segment);

        // 4. 异步更新Redis缓存
        updateRedisCache(businessType, segment);

        return segment.next();
    }

    /**
     * 获取新的分段
     */
    private SegmentInfo getNewSegment(String businessType) {
        return idSegmentMapper.getAvailableSegment(businessType);
    }

    /**
     * 从Redis缓存获取分段
     */
    private SegmentInfo getFromRedisCache(String businessType) {
        String cacheKey = "segment:" + businessType;
        return (SegmentInfo) redisTemplate.opsForValue().get(cacheKey);
    }

    /**
     * 更新Redis缓存
     */
    private void updateRedisCache(String businessType, SegmentInfo segment) {
        CompletableFuture.runAsync(() -> {
            String cacheKey = "segment:" + businessType;
            redisTemplate.opsForValue().set(cacheKey, segment, Duration.ofMinutes(30));
        });
    }

    /**
     * 分段信息类
     */
    public static class SegmentInfo {
        private long segmentId;
        private long startId;
        private long endId;
        private long currentId;

        public SegmentInfo(long segmentId, long startId, long endId, long currentId) {
            this.segmentId = segmentId;
            this.startId = startId;
            this.endId = endId;
            this.currentId = currentId;
        }

        public boolean hasNext() {
            return currentId <= endId;
        }

        public long next() {
            if (!hasNext()) {
                throw new IllegalStateException("分段已用完");
            }
            return currentId++;
        }

        // getter和setter方法
        public long getSegmentId() { return segmentId; }
        public void setSegmentId(long segmentId) { this.segmentId = segmentId; }
        public long getStartId() { return startId; }
        public void setStartId(long startId) { this.startId = startId; }
        public long getEndId() { return endId; }
        public void setEndId(long endId) { this.endId = endId; }
        public long getCurrentId() { return currentId; }
        public void setCurrentId(long currentId) { this.currentId = currentId; }
    }
}

/**
 * 乐观锁ID生成器
 */
@Service
public class OptimisticLockIdGenerator {

    @Autowired
    private IdGeneratorMapper idGeneratorMapper;

    private final int MAX_RETRIES = 3;

    /**
     * 使用乐观锁获取ID段
     */
    public IdRange getNewIdRangeWithOptimisticLock(String businessType) {
        for (int i = 0; i < MAX_RETRIES; i++) {
            try {
                // 1. 获取当前版本信息
                IdGeneratorInfo info = idGeneratorMapper.getById(businessType);
                if (info == null) {
                    throw new IllegalArgumentException("业务类型不存在: " + businessType);
                }

                // 2. 计算新的ID段
                long start = info.getCurrentMaxId() + 1;
                long end = info.getCurrentMaxId() + info.getStepSize();

                // 3. 使用乐观锁更新
                int updated = idGeneratorMapper.updateIdRange(businessType, info.getVersion());
                if (updated > 0) {
                    return new IdRange(start, end);
                }

                // 4. 更新失败，等待后重试
                Thread.sleep(10 + i * 10); // 递增等待时间

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("线程被中断", e);
            }
        }

        throw new RuntimeException("获取ID段失败，重试次数已用完");
    }
}

/**
 * 悲观锁ID生成器
 */
@Service
public class PessimisticLockIdGenerator {

    @Autowired
    private IdGeneratorMapper idGeneratorMapper;

    /**
     * 使用悲观锁获取ID段
     */
    @Transactional
    public IdRange getNewIdRangeWithPessimisticLock(String businessType) {
        // 1. 使用FOR UPDATE锁定记录
        IdGeneratorInfo info = idGeneratorMapper.getByIdForUpdate(businessType);
        if (info == null) {
            throw new IllegalArgumentException("业务类型不存在: " + businessType);
        }

        // 2. 计算新的ID段
        long start = info.getCurrentMaxId() + 1;
        long end = info.getCurrentMaxId() + info.getStepSize();

        // 3. 更新ID段
        int updated = idGeneratorMapper.updateIdRangeForUpdate(businessType);
        if (updated == 0) {
            throw new RuntimeException("更新ID段失败");
        }

        return new IdRange(start, end);
    }
}

/**
 * 分布式锁ID生成器
 */
@Service
public class DistributedLockIdGenerator {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private IdGeneratorMapper idGeneratorMapper;

    private final String LOCK_PREFIX = "id_generator_lock:";
    private final int LOCK_TIMEOUT = 30; // 秒

    /**
     * 使用分布式锁获取ID段
     */
    public IdRange getNewIdRangeWithDistributedLock(String businessType) {
        String lockKey = LOCK_PREFIX + businessType;
        String lockValue = UUID.randomUUID().toString();

        try {
            // 1. 获取分布式锁
            boolean acquired = acquireLock(lockKey, lockValue, LOCK_TIMEOUT);
            if (!acquired) {
                throw new RuntimeException("获取分布式锁失败");
            }

            // 2. 获取ID段
            IdGeneratorInfo info = idGeneratorMapper.getById(businessType);
            if (info == null) {
                throw new IllegalArgumentException("业务类型不存在: " + businessType);
            }

            long start = info.getCurrentMaxId() + 1;
            long end = info.getCurrentMaxId() + info.getStepSize();

            // 3. 更新ID段
            int updated = idGeneratorMapper.updateIdRangeForUpdate(businessType);
            if (updated == 0) {
                throw new RuntimeException("更新ID段失败");
            }

            return new IdRange(start, end);

        } finally {
            // 4. 释放分布式锁
            releaseLock(lockKey, lockValue);
        }
    }

    /**
     * 获取分布式锁
     */
    private boolean acquireLock(String lockKey, String lockValue, int timeout) {
        return redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, Duration.ofSeconds(timeout));
    }

    /**
     * 释放分布式锁
     */
    private void releaseLock(String lockKey, String lockValue) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), 
                Collections.singletonList(lockKey), lockValue);
    }
}

/**
 * 多级缓存ID生成器
 */
@Service
public class MultiLevelCacheIdGenerator {

    @Autowired
    private IdGeneratorMapper idGeneratorMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private final Map<String, IdRange> localCache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    /**
     * 多级缓存获取ID
     */
    public Long generateId(String businessType) {
        // 1. 本地缓存
        IdRange range = localCache.get(businessType);
        if (range != null && range.hasNext()) {
            return range.next();
        }

        // 2. Redis缓存
        range = getFromRedisCache(businessType);
        if (range != null && range.hasNext()) {
            localCache.put(businessType, range);
            return range.next();
        }

        // 3. 数据库
        range = getNewIdRange(businessType);
        localCache.put(businessType, range);

        // 4. 异步更新缓存
        updateCacheAsync(businessType, range);

        return range.next();
    }

    /**
     * 从Redis缓存获取
     */
    private IdRange getFromRedisCache(String businessType) {
        String cacheKey = "id_range:" + businessType;
        return (IdRange) redisTemplate.opsForValue().get(cacheKey);
    }

    /**
     * 异步更新缓存
     */
    private void updateCacheAsync(String businessType, IdRange range) {
        CompletableFuture.runAsync(() -> {
            // 更新Redis缓存
            String cacheKey = "id_range:" + businessType;
            redisTemplate.opsForValue().set(cacheKey, range, Duration.ofMinutes(30));

            // 预热下一个ID段
            preloadNextIdRange(businessType);
        });
    }

    /**
     * 预热下一个ID段
     */
    private void preloadNextIdRange(String businessType) {
        try {
            IdRange nextRange = getNewIdRange(businessType);
            String cacheKey = "id_range:" + businessType;
            redisTemplate.opsForValue().set(cacheKey, nextRange, Duration.ofMinutes(30));
        } catch (Exception e) {
            log.warn("预热ID段失败: {}", e.getMessage());
        }
    }

    /**
     * 定期清理本地缓存
     */
    @PostConstruct
    public void startCacheCleanup() {
        scheduler.scheduleAtFixedRate(() -> {
            localCache.entrySet().removeIf(entry -> !entry.getValue().hasNext());
        }, 5, 5, TimeUnit.MINUTES);
    }
}

/**
 * 缓存预热服务
 */
@Service
public class CacheWarmupService {

    @Autowired
    private IdGeneratorMapper idGeneratorMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 预热缓存
     */
    @PostConstruct
    public void warmupCache() {
        // 获取所有业务类型
        List<String> businessTypes = idGeneratorMapper.getAllBusinessTypes();

        // 并行预热
        businessTypes.parallelStream().forEach(businessType -> {
            try {
                warmupBusinessType(businessType);
            } catch (Exception e) {
                log.error("预热业务类型失败: {}", businessType, e);
            }
        });
    }

    /**
     * 预热单个业务类型
     */
    private void warmupBusinessType(String businessType) {
        // 获取ID段
        IdRange range = getNewIdRange(businessType);

        // 存储到Redis
        String cacheKey = "id_range:" + businessType;
        redisTemplate.opsForValue().set(cacheKey, range, Duration.ofMinutes(30));

        log.info("预热业务类型完成: {}", businessType);
    }

    /**
     * 定期预热
     */
    @Scheduled(fixedRate = 300000) // 5分钟
    public void scheduledWarmup() {
        // 检查缓存使用情况
        checkCacheUsage();

        // 预热低使用率的缓存
        warmupLowUsageCache();
    }

    /**
     * 检查缓存使用情况
     */
    private void checkCacheUsage() {
        // 实现缓存使用情况检查逻辑
    }

    /**
     * 预热低使用率缓存
     */
    private void warmupLowUsageCache() {
        // 实现低使用率缓存预热逻辑
    }
}

/**
 * 读写分离ID生成器
 */
@Service
public class ReadWriteSplitIdGenerator {

    @Autowired
    @Qualifier("masterDataSource")
    private DataSource masterDataSource;

    @Autowired
    @Qualifier("slaveDataSource")
    private DataSource slaveDataSource;

    @Autowired
    private IdGeneratorMapper idGeneratorMapper;

    /**
     * 写操作使用主库
     */
    @Transactional
    public IdRange getNewIdRange(String businessType) {
        // 使用主库进行写操作
        return idGeneratorMapper.getNewIdRange(businessType);
    }

    /**
     * 读操作使用从库
     */
    public IdGeneratorInfo getById(String businessType) {
        // 使用从库进行读操作
        return idGeneratorMapper.getById(businessType);
    }

    /**
     * 健康检查
     */
    public boolean checkHealth() {
        try {
            // 检查主库
            boolean masterHealthy = checkDataSourceHealth(masterDataSource);

            // 检查从库
            boolean slaveHealthy = checkDataSourceHealth(slaveDataSource);

            return masterHealthy && slaveHealthy;
        } catch (Exception e) {
            log.error("健康检查失败", e);
            return false;
        }
    }

    /**
     * 检查数据源健康状态
     */
    private boolean checkDataSourceHealth(DataSource dataSource) {
        try (Connection connection = dataSource.getConnection()) {
            return connection.isValid(5);
        } catch (SQLException e) {
            return false;
        }
    }
}

/**
 * 分片ID生成器
 */
@Service
public class ShardedIdGenerator {

    @Autowired
    private List<IdGeneratorMapper> shardMappers;

    @Autowired
    private ShardRouter shardRouter;

    /**
     * 分片获取ID
     */
    public Long generateId(String businessType) {
        // 1. 计算分片
        int shardIndex = shardRouter.getShardIndex(businessType);

        // 2. 获取对应的Mapper
        IdGeneratorMapper mapper = shardMappers.get(shardIndex);

        // 3. 获取ID段
        IdRange range = mapper.getNewIdRange(businessType);

        return range.next();
    }

    /**
     * 分片路由器
     */
    @Component
    public static class ShardRouter {

        private final int shardCount;

        public ShardRouter(@Value("${id.generator.shard.count:4}") int shardCount) {
            this.shardCount = shardCount;
        }

        /**
         * 计算分片索引
         */
        public int getShardIndex(String businessType) {
            return Math.abs(businessType.hashCode()) % shardCount;
        }
    }
}

/**
 * 负载均衡ID生成器
 */
@Service
public class LoadBalancedIdGenerator {

    @Autowired
    private List<IdGeneratorService> idGeneratorServices;

    @Autowired
    private LoadBalancer loadBalancer;

    /**
     * 负载均衡获取ID
     */
    public Long generateId(String businessType) {
        // 1. 选择服务实例
        IdGeneratorService service = loadBalancer.select(idGeneratorServices);

        // 2. 获取ID
        return service.generateId(businessType);
    }

    /**
     * 负载均衡器
     */
    @Component
    public static class LoadBalancer {

        private final AtomicInteger counter = new AtomicInteger(0);

        /**
         * 轮询选择
         */
        public IdGeneratorService select(List<IdGeneratorService> services) {
            int index = counter.getAndIncrement() % services.size();
            return services.get(index);
        }

        /**
         * 随机选择
         */
        public IdGeneratorService selectRandom(List<IdGeneratorService> services) {
            int index = ThreadLocalRandom.current().nextInt(services.size());
            return services.get(index);
        }

        /**
         * 加权轮询选择
         */
        public IdGeneratorService selectWeighted(List<IdGeneratorService> services, List<Integer> weights) {
            // 实现加权轮询逻辑
            return services.get(0);
        }
    }
}

/**
 * 故障检测服务
 */
@Service
public class FailureDetectionService {

    @Autowired
    private List<IdGeneratorService> idGeneratorServices;

    private final Map<String, HealthStatus> healthStatus = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    /**
     * 启动故障检测
     */
    @PostConstruct
    public void startFailureDetection() {
        scheduler.scheduleAtFixedRate(this::detectFailures, 0, 30, TimeUnit.SECONDS);
    }

    /**
     * 检测故障
     */
    private void detectFailures() {
        idGeneratorServices.forEach(service -> {
            String serviceId = service.getServiceId();
            try {
                // 健康检查
                boolean healthy = service.healthCheck();
                updateHealthStatus(serviceId, healthy);
            } catch (Exception e) {
                updateHealthStatus(serviceId, false);
                log.warn("服务健康检查失败: {}", serviceId, e);
            }
        });
    }

    /**
     * 更新健康状态
     */
    private void updateHealthStatus(String serviceId, boolean healthy) {
        HealthStatus status = healthStatus.computeIfAbsent(serviceId, k -> new HealthStatus());
        status.setHealthy(healthy);
        status.setLastCheckTime(System.currentTimeMillis());

        if (!healthy) {
            status.incrementFailureCount();
        } else {
            status.resetFailureCount();
        }
    }

    /**
     * 获取健康服务
     */
    public List<IdGeneratorService> getHealthyServices() {
        return idGeneratorServices.stream()
                .filter(service -> {
                    HealthStatus status = healthStatus.get(service.getServiceId());
                    return status != null && status.isHealthy();
                })
                .collect(Collectors.toList());
    }

    /**
     * 健康状态类
     */
    public static class HealthStatus {
        private boolean healthy = true;
        private long lastCheckTime = System.currentTimeMillis();
        private int failureCount = 0;

        public void incrementFailureCount() {
            this.failureCount++;
        }

        public void resetFailureCount() {
            this.failureCount = 0;
        }

        // getter和setter方法
        public boolean isHealthy() { return healthy; }
        public void setHealthy(boolean healthy) { this.healthy = healthy; }
        public long getLastCheckTime() { return lastCheckTime; }
        public void setLastCheckTime(long lastCheckTime) { this.lastCheckTime = lastCheckTime; }
        public int getFailureCount() { return failureCount; }
    }
}

/**
 * 故障转移ID生成器
 */
@Service
public class FailoverIdGenerator {

    @Autowired
    private FailureDetectionService failureDetectionService;

    @Autowired
    private List<IdGeneratorService> idGeneratorServices;

    /**
     * 故障转移获取ID
     */
    public Long generateId(String businessType) {
        List<IdGeneratorService> healthyServices = failureDetectionService.getHealthyServices();

        if (healthyServices.isEmpty()) {
            throw new RuntimeException("没有可用的ID生成服务");
        }

        // 尝试获取ID
        for (IdGeneratorService service : healthyServices) {
            try {
                return service.generateId(businessType);
            } catch (Exception e) {
                log.warn("服务调用失败，尝试下一个服务: {}", service.getServiceId(), e);
            }
        }

        throw new RuntimeException("所有服务都不可用");
    }

    /**
     * 批量获取ID（故障转移）
     */
    public List<Long> generateIds(String businessType, int count) {
        List<Long> ids = new ArrayList<>();

        for (int i = 0; i < count; i++) {
            ids.add(generateId(businessType));
        }

        return ids;
    }
}

/**
 * ID生成器性能监控
 */
@Component
public class IdGeneratorMetrics {

    private final MeterRegistry meterRegistry;
    private final Counter idGenerationCounter;
    private final Timer idGenerationTimer;
    private final Gauge cacheHitRate;
    private final Gauge cacheMissRate;

    public IdGeneratorMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;

        // 初始化监控指标
        this.idGenerationCounter = Counter.builder("id.generator.count")
                .description("ID生成次数")
                .register(meterRegistry);

        this.idGenerationTimer = Timer.builder("id.generator.duration")
                .description("ID生成耗时")
                .register(meterRegistry);

        this.cacheHitRate = Gauge.builder("id.generator.cache.hit.rate")
                .description("缓存命中率")
                .register(meterRegistry, this, IdGeneratorMetrics::getCacheHitRate);

        this.cacheMissRate = Gauge.builder("id.generator.cache.miss.rate")
                .description("缓存未命中率")
                .register(meterRegistry, this, IdGeneratorMetrics::getCacheMissRate);
    }

    /**
     * 记录ID生成
     */
    public void recordIdGeneration(String businessType, long duration) {
        idGenerationCounter.increment(Tags.of("business_type", businessType));
        idGenerationTimer.record(duration, TimeUnit.MILLISECONDS);
    }

    /**
     * 记录缓存命中
     */
    public void recordCacheHit(String businessType) {
        Counter.builder("id.generator.cache.hit")
                .description("缓存命中次数")
                .tag("business_type", businessType)
                .register(meterRegistry)
                .increment();
    }

    /**
     * 记录缓存未命中
     */
    public void recordCacheMiss(String businessType) {
        Counter.builder("id.generator.cache.miss")
                .description("缓存未命中次数")
                .tag("business_type", businessType)
                .register(meterRegistry)
                .increment();
    }

    /**
     * 获取缓存命中率
     */
    private double getCacheHitRate() {
        // 实现缓存命中率计算逻辑
        return 0.95; // 示例值
    }

    /**
     * 获取缓存未命中率
     */
    private double getCacheMissRate() {
        // 实现缓存未命中率计算逻辑
        return 0.05; // 示例值
    }
}

/**
 * 性能分析服务
 */
@Service
public class PerformanceAnalysisService {

    @Autowired
    private IdGeneratorMetrics metrics;

    @Autowired
    private MeterRegistry meterRegistry;

    /**
     * 分析性能指标
     */
    public PerformanceAnalysisResult analyzePerformance() {
        PerformanceAnalysisResult result = new PerformanceAnalysisResult();

        // 分析ID生成性能
        analyzeIdGenerationPerformance(result);

        // 分析缓存性能
        analyzeCachePerformance(result);

        // 分析数据库性能
        analyzeDatabasePerformance(result);

        return result;
    }

    /**
     * 分析ID生成性能
     */
    private void analyzeIdGenerationPerformance(PerformanceAnalysisResult result) {
        // 获取ID生成计时器
        Timer idGenerationTimer = meterRegistry.find("id.generator.duration").timer();
        if (idGenerationTimer != null) {
            result.setAvgIdGenerationTime(idGenerationTimer.mean(TimeUnit.MILLISECONDS));
            result.setMaxIdGenerationTime(idGenerationTimer.max(TimeUnit.MILLISECONDS));
            result.setP95IdGenerationTime(idGenerationTimer.percentile(0.95, TimeUnit.MILLISECONDS));
            result.setP99IdGenerationTime(idGenerationTimer.percentile(0.99, TimeUnit.MILLISECONDS));
        }

        // 获取ID生成计数器
        Counter idGenerationCounter = meterRegistry.find("id.generator.count").counter();
        if (idGenerationCounter != null) {
            result.setTotalIdGenerationCount(idGenerationCounter.count());
        }
    }

    /**
     * 分析缓存性能
     */
    private void analyzeCachePerformance(PerformanceAnalysisResult result) {
        // 获取缓存命中率
        Gauge cacheHitRate = meterRegistry.find("id.generator.cache.hit.rate").gauge();
        if (cacheHitRate != null) {
            result.setCacheHitRate(cacheHitRate.value());
        }

        // 获取缓存未命中率
        Gauge cacheMissRate = meterRegistry.find("id.generator.cache.miss.rate").gauge();
        if (cacheMissRate != null) {
            result.setCacheMissRate(cacheMissRate.value());
        }
    }

    /**
     * 分析数据库性能
     */
    private void analyzeDatabasePerformance(PerformanceAnalysisResult result) {
        // 实现数据库性能分析逻辑
        result.setDatabaseConnectionCount(10);
        result.setDatabaseQueryTime(50.0);
        result.setDatabaseUpdateTime(30.0);
    }
}

/**
 * 批量ID生成器
 */
@Service
public class BatchIdGenerator {

    @Autowired
    private IdGeneratorMapper idGeneratorMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private final Map<String, BatchIdRange> batchCache = new ConcurrentHashMap<>();

    /**
     * 批量获取ID
     */
    public List<Long> generateBatchIds(String businessType, int count) {
        List<Long> ids = new ArrayList<>();

        // 1. 尝试从批量缓存获取
        BatchIdRange batchRange = batchCache.get(businessType);
        if (batchRange != null && batchRange.hasNext(count)) {
            return batchRange.next(count);
        }

        // 2. 从Redis批量缓存获取
        batchRange = getFromRedisBatchCache(businessType);
        if (batchRange != null && batchRange.hasNext(count)) {
            batchCache.put(businessType, batchRange);
            return batchRange.next(count);
        }

        // 3. 从数据库获取新的批量ID段
        batchRange = getNewBatchIdRange(businessType, count);
        batchCache.put(businessType, batchRange);

        // 4. 异步更新Redis缓存
        updateRedisBatchCache(businessType, batchRange);

        return batchRange.next(count);
    }

    /**
     * 获取新的批量ID段
     */
    private BatchIdRange getNewBatchIdRange(String businessType, int count) {
        // 计算需要的步长
        int stepSize = Math.max(count * 2, 1000); // 至少1000，或者count的2倍

        // 获取ID段
        IdRange range = idGeneratorMapper.getNewIdRange(businessType);

        return new BatchIdRange(range.getStart(), range.getEnd());
    }

    /**
     * 从Redis批量缓存获取
     */
    private BatchIdRange getFromRedisBatchCache(String businessType) {
        String cacheKey = "batch_id_range:" + businessType;
        return (BatchIdRange) redisTemplate.opsForValue().get(cacheKey);
    }

    /**
     * 更新Redis批量缓存
     */
    private void updateRedisBatchCache(String businessType, BatchIdRange batchRange) {
        CompletableFuture.runAsync(() -> {
            String cacheKey = "batch_id_range:" + businessType;
            redisTemplate.opsForValue().set(cacheKey, batchRange, Duration.ofMinutes(30));
        });
    }

    /**
     * 批量ID段类
     */
    public static class BatchIdRange {
        private long start;
        private long end;
        private long current;

        public BatchIdRange(long start, long end) {
            this.start = start;
            this.end = end;
            this.current = start;
        }

        public boolean hasNext(int count) {
            return current + count - 1 <= end;
        }

        public List<Long> next(int count) {
            if (!hasNext(count)) {
                throw new IllegalStateException("批量ID段不足");
            }

            List<Long> ids = new ArrayList<>();
            for (int i = 0; i < count; i++) {
                ids.add(current++);
            }

            return ids;
        }

        // getter和setter方法
        public long getStart() { return start; }
        public void setStart(long start) { this.start = start; }
        public long getEnd() { return end; }
        public void setEnd(long end) { this.end = end; }
        public long getCurrent() { return current; }
        public void setCurrent(long current) { this.current = current; }
    }
}