#Strangler Fig 绞杀者模式

@Configuration
public class RoutingConfig {
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            // 用户模块：路由到新服务
            .route("user-service", r -> r
                .path("/api/user/**")
                .filters(f -> f.stripPrefix(0))
                .uri("lb://new-user-service"))
            // 订单模块：路由到新服务
            .route("order-service", r -> r
                .path("/api/order/**")
                .uri("lb://new-order-service"))
            // 商品模块：仍在旧系统
            .route("product-legacy", r -> r
                .path("/api/product/**")
                .uri("http://legacy-service:8080"))
            .build();
    }
}

public class FeatureToggleService {
    private final Map<String, Boolean> toggles = new ConcurrentHashMap<>();

    public void setToggle(String feature, boolean enabled) {
        toggles.put(feature, enabled);
        // 可以广播到所有服务实例
        broadcastToggleChange(feature, enabled);
    }

    public boolean isEnabled(String feature) {
        return toggles.getOrDefault(feature, false);
    }

    public <T> T route(String feature, Supplier<T> newService, Supplier<T> legacyService) {
        return isEnabled(feature) ? newService.get() : legacyService.get();
    }
}

// 使用示例
@Service
public class UserServiceClient {
    @Autowired
    private FeatureToggleService toggleService;

    public User getUser(Long userId) {
        return toggleService.route(
            "new-user-service",
            () -> newUserService.getUser(userId),    // 新服务
            () -> legacyUserService.getUser(userId) // 旧服务
        );
    }
}

public class PercentageToggle {
    private final double percentage;

    public PercentageToggle(double percentage) {
        this.percentage = percentage;
    }

    public boolean shouldRouteToNew(UserRequest request) {
        // 根据用户 ID 哈希，确保同一用户始终路由到同一版本
        int hash = Math.abs(request.getUserId().hashCode() % 100);
        return hash < percentage;
    }
}

// 灰度策略：先 5% 用户，观察无问题后逐步提升到 100%
// 5% -> 10% -> 30% -> 50% -> 100%

public class DualWriteService {
    private final LegacyRepository legacyRepo;
    private final NewRepository newRepo;
    private final boolean newEnabled;

    @Transactional
    public void createOrder(Order order) {
        // 1. 先写旧数据库（保证兼容性）
        legacyRepo.save(order);

        // 2. 如果新服务启用，再写新数据库
        if (newEnabled) {
            try {
                newRepo.save(order);
            } catch (Exception e) {
                // 新服务写入失败，记录日志但不阻塞业务
                log.error("双写失败，orderId={}", order.getId(), e);
                // 可以加入补偿队列，稍后重试
                compensateQueue.offer(order);
            }
        }
    }
}

public class DataMigration {
    private final LegacyRepository legacyRepo;
    private final NewRepository newRepo;
    private final long batchSize = 1000;

    public void migrateUsers() {
        long totalMigrated = 0;
        long lastId = 0;

        while (true) {
            // 分批读取旧数据
            List<User> batch = legacyRepo.findUsersAfter(lastId, batchSize);
            if (batch.isEmpty()) break;

            // 写入新数据库
            for (User user : batch) {
                try {
                    newRepo.save(user);
                    lastId = user.getId();
                } catch (DuplicateKeyException e) {
                    // 已存在，跳过
                    log.debug("用户已迁移，userId={}", user.getId());
                }
            }

            totalMigrated += batch.size();
            log.info("已迁移 {} 条记录，最后 ID: {}", totalMigrated, lastId);

            // 避免对旧数据库造成压力
            Thread.sleep(100);
        }
    }

    // 迁移完成后进行数据校验
    public void verifyData() {
        long legacyCount = legacyRepo.countUsers();
        long newCount = newRepo.countUsers();

        if (legacyCount != newCount) {
            throw new MigrationException(
                "数据校验失败：旧库 " + legacyCount + " 条，新库 " + newCount + " 条"
            );
        }

        // 抽样校验数据内容
        List<User> samples = legacyRepo.sampleUsers(100);
        for (User user : samples) {
            User newUser = newRepo.findById(user.getId());
            if (!user.equals(newUser)) {
                throw new MigrationException("数据不一致：userId=" + user.getId());
            }
        }
    }
}