@Component
public class GlobalServiceRegistry {
    private final Map<String, DataCenterRegistry> dataCenterRegistries = new ConcurrentHashMap<>();
    private final Map<String, GlobalServiceInfo> globalServiceMap = new ConcurrentHashMap<>();
    
    public void registerInstance(String dataCenter, ServiceInstance instance) {
        // 在本地数据中心注册
        DataCenterRegistry localRegistry = dataCenterRegistries.computeIfAbsent(
            dataCenter, k -> new DataCenterRegistry());
        localRegistry.register(instance);
        
        // 更新全局服务信息
        updateGlobalServiceInfo(instance.getServiceId(), dataCenter, true);
    }
    
    public void unregisterInstance(String dataCenter, ServiceInstance instance) {
        // 在本地数据中心注销
        DataCenterRegistry localRegistry = dataCenterRegistries.get(dataCenter);
        if (localRegistry != null) {
            localRegistry.unregister(instance);
        }
        
        // 更新全局服务信息
        updateGlobalServiceInfo(instance.getServiceId(), dataCenter, false);
    }
    
    public List<ServiceInstance> getInstances(String serviceId, String preferredDataCenter) {
        List<ServiceInstance> instances = new ArrayList<>();
        
        // 优先返回同数据中心的实例
        DataCenterRegistry localRegistry = dataCenterRegistries.get(preferredDataCenter);
        if (localRegistry != null) {
            instances.addAll(localRegistry.getInstances(serviceId));
        }
        
        // 如果同数据中心实例不足，补充其他数据中心的实例
        if (instances.size() < 3) { // 假设最少需要3个实例
            for (Map.Entry<String, DataCenterRegistry> entry : dataCenterRegistries.entrySet()) {
                String dataCenter = entry.getKey();
                if (!dataCenter.equals(preferredDataCenter)) {
                    instances.addAll(entry.getValue().getInstances(serviceId));
                    if (instances.size() >= 3) {
                        break;
                    }
                }
            }
        }
        
        return instances;
    }
    
    private void updateGlobalServiceInfo(String serviceId, String dataCenter, boolean registered) {
        GlobalServiceInfo serviceInfo = globalServiceMap.computeIfAbsent(
            serviceId, k -> new GlobalServiceInfo(serviceId));
        
        if (registered) {
            serviceInfo.addDataCenterInstance(dataCenter);
        } else {
            serviceInfo.removeDataCenterInstance(dataCenter);
        }
    }
    
    private static class DataCenterRegistry {
        private final Map<String, Set<ServiceInstance>> serviceInstances = new ConcurrentHashMap<>();
        
        public void register(ServiceInstance instance) {
            serviceInstances.computeIfAbsent(instance.getServiceId(), k -> ConcurrentHashMap.newKeySet())
                .add(instance);
        }
        
        public void unregister(ServiceInstance instance) {
            Set<ServiceInstance> instances = serviceInstances.get(instance.getServiceId());
            if (instances != null) {
                instances.remove(instance);
            }
        }
        
        public List<ServiceInstance> getInstances(String serviceId) {
            Set<ServiceInstance> instances = serviceInstances.get(serviceId);
            return instances != null ? new ArrayList<>(instances) : Collections.emptyList();
        }
    }
    
    private static class GlobalServiceInfo {
        private final String serviceId;
        private final Set<String> dataCenters = ConcurrentHashMap.newKeySet();
        
        GlobalServiceInfo(String serviceId) {
            this.serviceId = serviceId;
        }
        
        public void addDataCenterInstance(String dataCenter) {
            dataCenters.add(dataCenter);
        }
        
        public void removeDataCenterInstance(String dataCenter) {
            dataCenters.remove(dataCenter);
        }
        
        public Set<String> getDataCenters() {
            return new HashSet<>(dataCenters);
        }
    }
}

2. 跨区域健康检查

@Component
public class CrossRegionHealthChecker {
    private final Map<String, Map<String, RegionalHealthStatus>> healthStatusMap = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
    
    @PostConstruct
    public void init() {
        // 定期执行跨区域健康检查
        scheduler.scheduleAtFixedRate(this::performCrossRegionHealthCheck, 0, 30, TimeUnit.SECONDS);
    }
    
    public boolean isInstanceHealthy(String dataCenter, String instanceId) {
        Map<String, RegionalHealthStatus> regionalStatusMap = healthStatusMap.get(dataCenter);
        if (regionalStatusMap == null) {
            return true; // 默认认为健康
        }
        
        RegionalHealthStatus status = regionalStatusMap.get(instanceId);
        return status != null ? status.isHealthy() : true;
    }
    
    private void performCrossRegionHealthCheck() {
        for (Map.Entry<String, Map<String, RegionalHealthStatus>> entry : healthStatusMap.entrySet()) {
            String dataCenter = entry.getKey();
            Map<String, RegionalHealthStatus> regionalStatusMap = entry.getValue();
            
            // 并行检查该数据中心的所有实例
            regionalStatusMap.entrySet().parallelStream().forEach(instanceEntry -> {
                String instanceId = instanceEntry.getKey();
                RegionalHealthStatus status = instanceEntry.getValue();
                
                // 执行跨区域健康检查
                boolean healthy = performHealthCheck(dataCenter, instanceId);
                status.updateHealth(healthy, System.currentTimeMillis());
            });
        }
    }
    
    private boolean performHealthCheck(String dataCenter, String instanceId) {
        try {
            // 实现具体的跨区域健康检查逻辑
            // 可能包括HTTP检查、TCP连接检查、业务逻辑检查等
            
            // 模拟检查逻辑
            URL url = new URL("http://" + getInstanceAddress(dataCenter, instanceId) + "/health");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setConnectTimeout(5000); // 5秒连接超时
            connection.setReadTimeout(10000);   // 10秒读取超时
            
            return connection.getResponseCode() == 200;
        } catch (Exception e) {
            return false;
        }
    }
    
    private String getInstanceAddress(String dataCenter, String instanceId) {
        // 根据数据中心和实例ID获取实例地址
        return "example.com"; // 简化实现
    }
    
    private static class RegionalHealthStatus {
        private volatile boolean healthy = true;
        private volatile long lastCheckTime = 0;
        private final AtomicInteger failureCount = new AtomicInteger(0);
        
        public boolean isHealthy() {
            return healthy;
        }
        
        public long getLastCheckTime() {
            return lastCheckTime;
        }
        
        public void updateHealth(boolean healthy, long checkTime) {
            this.lastCheckTime = checkTime;
            
            if (healthy) {
                this.healthy = true;
                failureCount.set(0);
            } else {
                int failures = failureCount.incrementAndGet();
                // 连续3次失败才标记为不健康
                if (failures >= 3) {
                    this.healthy = false;
                }
            }
        }
    }
}

智能路由策略

1. 基于地理位置的路由

@Component
public class GeoBasedRouter {
    private final Map<String, LocationInfo> clientLocations = new ConcurrentHashMap<>();
    private final Map<String, DataCenterInfo> dataCenterLocations = new ConcurrentHashMap<>();
    
    public String selectDataCenter(String clientId, String serviceId) {
        // 获取客户端地理位置
        LocationInfo clientLocation = getClientLocation(clientId);
        
        // 获取所有可用数据中心
        List<DataCenterInfo> availableDataCenters = getAvailableDataCenters(serviceId);
        
        // 选择最近的数据中心
        DataCenterInfo nearestDataCenter = findNearestDataCenter(clientLocation, availableDataCenters);
        
        return nearestDataCenter != null ? nearestDataCenter.getId() : getDefaultDataCenter();
    }
    
    private LocationInfo getClientLocation(String clientId) {
        LocationInfo location = clientLocations.get(clientId);
        if (location == null) {
            // 通过IP地理位置库获取客户端位置
            location = determineLocationByIP(clientId);
            if (location != null) {
                clientLocations.put(clientId, location);
            }
        }
        return location != null ? location : new LocationInfo(0, 0); // 默认位置
    }
    
    private LocationInfo determineLocationByIP(String clientId) {
        // 实现IP地理位置查询逻辑
        // 可以使用MaxMind GeoIP等服务
        return new LocationInfo(39.9042, 116.4074); // 北京坐标示例
    }
    
    private List<DataCenterInfo> getAvailableDataCenters(String serviceId) {
        // 获取包含指定服务的所有可用数据中心
        return new ArrayList<>(dataCenterLocations.values());
    }
    
    private DataCenterInfo findNearestDataCenter(LocationInfo clientLocation, 
                                               List<DataCenterInfo> dataCenters) {
        if (dataCenters.isEmpty()) {
            return null;
        }
        
        return dataCenters.stream()
            .min(Comparator.comparingDouble(dc -> calculateDistance(clientLocation, dc.getLocation())))
            .orElse(null);
    }
    
    private double calculateDistance(LocationInfo loc1, LocationInfo loc2) {
        // 使用Haversine公式计算两点间距离
        double lat1 = Math.toRadians(loc1.getLatitude());
        double lon1 = Math.toRadians(loc1.getLongitude());
        double lat2 = Math.toRadians(loc2.getLatitude());
        double lon2 = Math.toRadians(loc2.getLongitude());
        
        double dlat = lat2 - lat1;
        double dlon = lon2 - lon1;
        
        double a = Math.pow(Math.sin(dlat/2), 2) + 
                  Math.cos(lat1) * Math.cos(lat2) * Math.pow(Math.sin(dlon/2), 2);
        double c = 2 * Math.asin(Math.sqrt(a));
        
        // 地球半径（千米）
        double radius = 6371;
        return c * radius;
    }
    
    private String getDefaultDataCenter() {
        // 返回默认数据中心
        return "dc1";
    }
    
    @Data
    @AllArgsConstructor
    public static class LocationInfo {
        private final double latitude;
        private final double longitude;
    }
    
    @Data
    @AllArgsConstructor
    public static class DataCenterInfo {
        private final String id;
        private final LocationInfo location;
        private final boolean available;
    }
}

2. 基于延迟的路由优化

@Component
public class LatencyBasedRouter {
    private final Map<String, Map<String, LatencyMetrics>> latencyMap = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(3);
    
    @PostConstruct
    public void init() {
        // 定期测量和更新延迟数据
        scheduler.scheduleAtFixedRate(this::updateLatencyMetrics, 0, 60, TimeUnit.SECONDS);
    }
    
    public String selectOptimalDataCenter(String clientId, String serviceId) {
        // 获取客户端到各数据中心的延迟数据
        Map<String, LatencyMetrics> clientLatencies = latencyMap.get(clientId);
        if (clientLatencies == null || clientLatencies.isEmpty()) {
            // 如果没有延迟数据，使用默认选择策略
            return selectDefaultDataCenter(serviceId);
        }
        
        // 选择延迟最低的可用数据中心
        return clientLatencies.entrySet().stream()
            .filter(entry -> entry.getValue().isAvailable())
            .min(Map.Entry.comparingByValue(Comparator.comparing(LatencyMetrics::getAverageLatency)))
            .map(Map.Entry::getKey)
            .orElse(selectDefaultDataCenter(serviceId));
    }
    
    private void updateLatencyMetrics() {
        // 模拟延迟测量过程
        // 在实际实现中，这可能涉及主动探测或被动收集延迟数据
        
        latencyMap.forEach((clientId, dataCenterLatencies) -> {
            dataCenterLatencies.forEach((dataCenterId, metrics) -> {
                // 模拟延迟测量
                long latency = measureLatency(clientId, dataCenterId);
                metrics.updateLatency(latency);
            });
        });
    }
    
    private long measureLatency(String clientId, String dataCenterId) {
        // 实现具体的延迟测量逻辑
        // 可以通过发送ping包、HTTP请求等方式测量
        return new Random().nextInt(100) + 50; // 模拟50-150ms的延迟
    }
    
    private String selectDefaultDataCenter(String serviceId) {
        // 默认选择策略
        return "dc1";
    }
    
    public void recordRequestLatency(String clientId, String dataCenterId, long latency) {
        // 记录请求延迟数据
        latencyMap.computeIfAbsent(clientId, k -> new ConcurrentHashMap<>())
            .computeIfAbsent(dataCenterId, k -> new LatencyMetrics())
            .updateLatency(latency);
    }
    
    private static class LatencyMetrics {
        private final AtomicLong totalLatency = new AtomicLong(0);
        private final AtomicLong requestCount = new AtomicLong(0);
        private volatile long averageLatency = 0;
        private volatile boolean available = true;
        private volatile long lastUpdate = 0;
        
        public void updateLatency(long latency) {
            totalLatency.addAndGet(latency);
            long count = requestCount.incrementAndGet();
            averageLatency = totalLatency.get() / count;
            lastUpdate = System.currentTimeMillis();
            
            // 如果连续多次超时，标记为不可用
            if (latency > 5000) { // 超过5秒认为超时
                markUnavailable();
            } else {
                markAvailable();
            }
        }
        
        public long getAverageLatency() {
            return averageLatency;
        }
        
        public boolean isAvailable() {
            // 如果超过5分钟没有更新，认为不可用
            return available && (System.currentTimeMillis() - lastUpdate) < 300000;
        }
        
        private void markUnavailable() {
            available = false;
        }
        
        private void markAvailable() {
            available = true;
        }
    }
}

数据一致性与同步

跨数据中心数据同步

1. 最终一致性模型

@Component
public class EventualConsistencyManager {
    private final KafkaTemplate<String, DataChangeEvent> kafkaTemplate;
    private final Map<String, DataStore> dataStores = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    
    @PostConstruct
    public void init() {
        // 定期检查和同步数据
        scheduler.scheduleAtFixedRate(this::syncDataAcrossRegions, 0, 30, TimeUnit.SECONDS);
    }
    
    public void onDataChange(String region, String key, Object value) {
        // 记录本地变更
        DataStore localStore = dataStores.get(region);
        if (localStore != null) {
            localStore.put(key, value, System.currentTimeMillis());
        }
        
        // 发布变更事件到其他区域
        DataChangeEvent event = new DataChangeEvent(region, key, value, System.currentTimeMillis());
        kafkaTemplate.send("data-change-topic", key, event);
    }
    
    @KafkaListener(topics = "data-change-topic")
    public void handleDataChange(DataChangeEvent event) {
        String sourceRegion = event.getSourceRegion();
        String key = event.getKey();
        Object value = event.getValue();
        long timestamp = event.getTimestamp();
        
        // 检查是否需要应用变更（避免环路）
        DataStore localStore = dataStores.get(getCurrentRegion());
        if (localStore != null) {
            DataEntry existingEntry = localStore.get(key);
            
            // 如果本地数据较新，则不应用变更
            if (existingEntry == null || existingEntry.getTimestamp() < timestamp) {
                localStore.put(key, value, timestamp);
            }
        }
    }
    
    private void syncDataAcrossRegions() {
        String currentRegion = getCurrentRegion();
        DataStore localStore = dataStores.get(currentRegion);
        
        if (localStore != null) {
            // 同步本地更新到其他区域
            localStore.getRecentUpdates(System.currentTimeMillis() - 60000) // 最近1分钟的更新
                .forEach(entry -> {
                    DataChangeEvent event = new DataChangeEvent(
                        currentRegion, entry.getKey(), entry.getValue(), entry.getTimestamp());
                    kafkaTemplate.send("data-change-topic", entry.getKey(), event);
                });
        }
    }
    
    private String getCurrentRegion() {
        // 获取当前数据中心/区域标识
        return System.getProperty("region", "default");
    }
    
    @Data
    @AllArgsConstructor
    public static class DataChangeEvent {
        private final String sourceRegion;
        private final String key;
        private final Object value;
        private final long timestamp;
    }
    
    private static class DataStore {
        private final Map<String, DataEntry> data = new ConcurrentHashMap<>();
        private final Map<String, Long> updateTimes = new ConcurrentHashMap<>();
        
        public void put(String key, Object value, long timestamp) {
            data.put(key, new DataEntry(key, value, timestamp));
            updateTimes.put(key, timestamp);
        }
        
        public DataEntry get(String key) {
            return data.get(key);
        }
        
        public List<DataEntry> getRecentUpdates(long sinceTime) {
            return updateTimes.entrySet().stream()
                .filter(entry -> entry.getValue() > sinceTime)
                .map(entry -> data.get(entry.getKey()))
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        }
    }
    
    @Data
    @AllArgsConstructor
    private static class DataEntry {
        private final String key;
        private final Object value;
        private final long timestamp;
    }
}

2. 冲突解决策略

@Component
public class ConflictResolutionManager {
    
    public Object resolveConflict(String key, List<DataVersion> versions) {
        if (versions.isEmpty()) {
            return null;
        }
        
        if (versions.size() == 1) {
            return versions.get(0).getValue();
        }
        
        // 根据冲突解决策略选择最终值
        ConflictResolutionStrategy strategy = determineStrategy(key);
        return strategy.resolve(versions);
    }
    
    private ConflictResolutionStrategy determineStrategy(String key) {
        // 根据数据类型或业务规则确定冲突解决策略
        if (key.startsWith("user:")) {
            return new LastWriteWinsStrategy();
        } else if (key.startsWith("counter:")) {
            return new MergeCountersStrategy();
        } else {
            return new VectorClockStrategy();
        }
    }
    
    private interface ConflictResolutionStrategy {
        Object resolve(List<DataVersion> versions);
    }
    
    private static class LastWriteWinsStrategy implements ConflictResolutionStrategy {
        @Override
        public Object resolve(List<DataVersion> versions) {
            return versions.stream()
                .max(Comparator.comparingLong(DataVersion::getTimestamp))
                .map(DataVersion::getValue)
                .orElse(null);
        }
    }
    
    private static class MergeCountersStrategy implements ConflictResolutionStrategy {
        @Override
        public Object resolve(List<DataVersion> versions) {
            return versions.stream()
                .mapToLong(version -> {
                    if (version.getValue() instanceof Number) {
                        return ((Number) version.getValue()).longValue();
                    }
                    return 0;
                })
                .sum();
        }
    }
    
    private static class VectorClockStrategy implements ConflictResolutionStrategy {
        @Override
        public Object resolve(List<DataVersion> versions) {
            // 使用向量时钟解决冲突
            // 实现并发版本的合并逻辑
            return mergeConcurrentVersions(versions);
        }
        
        private Object mergeConcurrentVersions(List<DataVersion> versions) {
            // 简化实现：返回所有版本的列表
            return versions.stream()
                .map(DataVersion::getValue)
                .collect(Collectors.toList());
        }
    }
    
    @Data
    @AllArgsConstructor
    public static class DataVersion {
        private final String key;
        private final Object value;
        private final long timestamp;
        private final Map<String, Integer> vectorClock;
    }
}

故障处理与容灾

跨区域故障检测与恢复

1. 网络分区检测

@Component
public class NetworkPartitionDetector {
    private final Map<String, RegionConnectivity> regionConnectivityMap = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    
    @PostConstruct
    public void init() {
        // 定期检测区域间连通性
        scheduler.scheduleAtFixedRate(this::checkRegionConnectivity, 0, 10, TimeUnit.SECONDS);
    }
    
    public boolean isRegionAccessible(String targetRegion) {
        RegionConnectivity connectivity = regionConnectivityMap.get(targetRegion);
        return connectivity != null && connectivity.isAccessible();
    }
    
    private void checkRegionConnectivity() {
        String currentRegion = getCurrentRegion();
        List<String> allRegions = getAllRegions();
        
        for (String targetRegion : allRegions) {
            if (!targetRegion.equals(currentRegion)) {
                boolean accessible = testConnectivity(targetRegion);
                updateConnectivityStatus(targetRegion, accessible);
            }
        }
    }
    
    private boolean testConnectivity(String targetRegion) {
        try {
            // 测试到目标区域的连通性
            // 可以通过ping、HTTP请求、TCP连接等方式
            String targetEndpoint = getRegionEndpoint(targetRegion);
            
            URL url = new URL(targetEndpoint + "/health");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setConnectTimeout(3000); // 3秒连接超时
            connection.setReadTimeout(5000);    // 5秒读取超时
            
            return connection.getResponseCode() == 200;
        } catch (Exception e) {
            return false;
        }
    }
    
    private void updateConnectivityStatus(String targetRegion, boolean accessible) {
        regionConnectivityMap.compute(targetRegion, (key, connectivity) -> {
            if (connectivity == null) {
                return new RegionConnectivity(accessible, System.currentTimeMillis());
            }
            return new RegionConnectivity(accessible, System.currentTimeMillis());
        });
    }
    
    private String getCurrentRegion() {
        return System.getProperty("region", "default");
    }
    
    private List<String> getAllRegions() {
        // 获取所有区域列表
        return Arrays.asList("us-east", "us-west", "eu-central", "ap-southeast");
    }
    
    private String getRegionEndpoint(String region) {
        // 根据区域获取对应的端点地址
        return "https://" + region + ".example.com";
    }
    
    private static class RegionConnectivity {
        private final boolean accessible;
        private final long lastCheckTime;
        
        RegionConnectivity(boolean accessible, long lastCheckTime) {
            this.accessible = accessible;
            this.lastCheckTime = lastCheckTime;
        }
        
        public boolean isAccessible() {
            // 如果超过30秒没有检查，认为不可访问
            return accessible && (System.currentTimeMillis() - lastCheckTime) < 30000;
        }
    }
}

2. 自动故障切换

@Component
public class AutomaticFailoverManager {
    private final NetworkPartitionDetector partitionDetector;
    private final GlobalServiceRegistry serviceRegistry;
    private final Map<String, FailoverState> failoverStates = new ConcurrentHashMap<>();
    
    public List<ServiceInstance> getAvailableInstances(String serviceId) {
        String currentRegion = getCurrentRegion();
        FailoverState state = failoverStates.get(serviceId);
        
        // 首先尝试获取本区域的实例
        List<ServiceInstance> localInstances = serviceRegistry.getInstances(serviceId, currentRegion);
        List<ServiceInstance> healthyLocalInstances = filterHealthyInstances(localInstances, currentRegion);
        
        // 如果本区域有健康实例，直接返回
        if (!healthyLocalInstances.isEmpty()) {
            return healthyLocalInstances;
        }
        
        // 如果本区域没有健康实例，检查是否需要故障切换
        if (state == null || !state.isFailoverAllowed()) {
            return localInstances; // 返回所有本地实例（包括不健康的）
        }
        
        // 尝试故障切换到其他区域
        return failoverToOtherRegions(serviceId, currentRegion);
    }
    
    private List<ServiceInstance> filterHealthyInstances(List<ServiceInstance> instances, String region) {
        return instances.stream()
            .filter(instance -> isInstanceHealthy(region, instance.getInstanceId()))
            .collect(Collectors.toList());
    }
    
    private List<ServiceInstance> failoverToOtherRegions(String serviceId, String currentRegion) {
        List<String> allRegions = getAllRegions();
        
        for (String region : allRegions) {
            if (!region.equals(currentRegion) && partitionDetector.isRegionAccessible(region)) {
                List<ServiceInstance> instances = serviceRegistry.getInstances(serviceId, region);
                List<ServiceInstance> healthyInstances = filterHealthyInstances(instances, region);
                
                if (!healthyInstances.isEmpty()) {
                    // 记录故障切换事件
                    recordFailover(serviceId, currentRegion, region);
                    return healthyInstances;
                }
            }
        }
        
        // 所有区域都不可用，返回空列表
        return Collections.emptyList();
    }
    
    private boolean isInstanceHealthy(String region, String instanceId) {
        // 检查实例健康状态
        return true; // 简化实现
    }
    
    private void recordFailover(String serviceId, String fromRegion, String toRegion) {
        failoverStates.computeIfAbsent(serviceId, k -> new FailoverState())
            .recordFailover(fromRegion, toRegion, System.currentTimeMillis());
        
        // 记录日志和发送告警
        System.out.println("Failover for service " + serviceId + 
            " from " + fromRegion + " to " + toRegion);
    }
    
    private String getCurrentRegion() {
        return System.getProperty("region", "default");
    }
    
    private List<String> getAllRegions() {
        return Arrays.asList("us-east", "us-west", "eu-central", "ap-southeast");
    }
    
    private static class FailoverState {
        private volatile long lastFailoverTime = 0;
        private volatile boolean failoverInProgress = false;
        private final Map<String, String> failoverHistory = new ConcurrentHashMap<>();
        
        public boolean isFailoverAllowed() {
            // 限制故障切换频率，避免频繁切换
            return !failoverInProgress && 
                   (System.currentTimeMillis() - lastFailoverTime) > 60000; // 1分钟间隔
        }
        
        public void recordFailover(String fromRegion, String toRegion, long timestamp) {
            lastFailoverTime = timestamp;
            failoverHistory.put(fromRegion, toRegion);
        }
    }
}

监控与运维

跨区域监控指标

1. 全局健康面板

@Component
public class GlobalHealthDashboard {
    private final MeterRegistry meterRegistry;
    private final GlobalServiceRegistry serviceRegistry;
    private final NetworkPartitionDetector partitionDetector;
    
    public GlobalHealthMetrics getGlobalHealthMetrics() {
        GlobalHealthMetrics metrics = new GlobalHealthMetrics();
        
        // 收集各区域服务健康指标
        Map<String, RegionHealthMetrics> regionMetrics = collectRegionMetrics();
        metrics.setRegionMetrics(regionMetrics);
        
        // 收集跨区域连通性指标
        Map<String, Boolean> connectivityMetrics = collectConnectivityMetrics();
        metrics.setConnectivityMetrics(connectivityMetrics);
        
        // 计算全局健康评分
        double globalHealthScore = calculateGlobalHealthScore(regionMetrics, connectivityMetrics);
        metrics.setGlobalHealthScore(globalHealthScore);
        
        return metrics;
    }
    
    private Map<String, RegionHealthMetrics> collectRegionMetrics() {
        Map<String, RegionHealthMetrics> regionMetrics = new HashMap<>();
        List<String> allRegions = getAllRegions();
        
        for (String region : allRegions) {
            RegionHealthMetrics metrics = new RegionHealthMetrics();
            
            // 收集该区域的服务实例数量
            long totalInstances = collectTotalInstances(region);
            metrics.setTotalInstances(totalInstances);
            
            // 收集该区域的健康实例数量
            long healthyInstances = collectHealthyInstances(region);
            metrics.setHealthyInstances(healthyInstances);
            
            // 计算该区域的健康比例
            double healthRatio = totalInstances > 0 ? (double) healthyInstances / totalInstances : 1.0;
            metrics.setHealthRatio(healthRatio);
            
            regionMetrics.put(region, metrics);
        }
        
        return regionMetrics;
    }
    
    private Map<String, Boolean> collectConnectivityMetrics() {
        Map<String, Boolean> connectivityMetrics = new HashMap<>();
        List<String> allRegions = getAllRegions();
        String currentRegion = getCurrentRegion();
        
        for (String region : allRegions) {
            if (!region.equals(currentRegion)) {
                boolean accessible = partitionDetector.isRegionAccessible(region);
                connectivityMetrics.put(region, accessible);
            }
        }
        
        return connectivityMetrics;
    }
    
    private double calculateGlobalHealthScore(Map<String, RegionHealthMetrics> regionMetrics,
                                           Map<String, Boolean> connectivityMetrics) {
        double totalScore = 0.0;
        int scoreCount = 0;
        
        // 计算各区域健康评分的平均值
        for (RegionHealthMetrics metrics : regionMetrics.values()) {
            totalScore += metrics.getHealthRatio();
            scoreCount++;
        }
        
        // 考虑跨区域连通性对健康评分的影响
        long disconnectedRegions = connectivityMetrics.values().stream()
            .filter(connected -> !connected)
            .count();
        
        if (scoreCount > 0) {
            double averageRegionScore = totalScore / scoreCount;
            // 每个断开连接的区域降低10%的评分
            double connectivityPenalty = disconnectedRegions * 0.1;
            return Math.max(0.0, averageRegionScore - connectivityPenalty);
        }
        
        return 1.0; // 默认满分
    }
    
    private long collectTotalInstances(String region) {
        // 收集指定区域的总实例数
        return 100; // 简化实现
    }
    
    private long collectHealthyInstances(String region) {
        // 收集指定区域的健康实例数
        return 95; // 简化实现
    }
    
    private List<String> getAllRegions() {
        return Arrays.asList("us-east", "us-west", "eu-central", "ap-southeast");
    }
    
    private String getCurrentRegion() {
        return System.getProperty("region", "default");
    }
    
    @Data
    public static class GlobalHealthMetrics {
        private Map<String, RegionHealthMetrics> regionMetrics;
        private Map<String, Boolean> connectivityMetrics;
        private double globalHealthScore;
    }
    
    @Data
    public static class RegionHealthMetrics {
        private long totalInstances;
        private long healthyInstances;
        private double healthRatio;
    }
}

2. 跨区域追踪

@Component
public class CrossRegionTracing {
    private final Tracer tracer;
    
    public <T> T executeWithTracing(String operationName, String targetRegion, 
                                   Supplier<T> operation) {
        Span span = tracer.nextSpan()
            .name(operationName)
            .tag("target.region", targetRegion)
            .tag("source.region", getCurrentRegion())
            .start();
        
        try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
            T result = operation.get();
            
            span.tag("status", "success");
            return result;
        } catch (Exception e) {
            span.tag("status", "error")
                .tag("error.message", e.getMessage());
            throw e;
        } finally {
            span.finish();
        }
    }
    
    public void recordCrossRegionCall(String targetRegion, long duration, boolean success) {
        // 记录跨区域调用指标
        Timer.Sample sample = Timer.start();
        
        if (success) {
            sample.stop(Timer.builder("cross.region.calls")
                .tag("target.region", targetRegion)
                .tag("source.region", getCurrentRegion())
                .tag("status", "success")
                .register(Metrics.globalRegistry));
        } else {
            Counter.builder("cross.region.call.failures")
                .tag("target.region", targetRegion)
                .tag("source.region", getCurrentRegion())
                .register(Metrics.globalRegistry)
                .increment();
        }
    }
    
    private String getCurrentRegion() {
        return System.getProperty("region", "default");
    }
}

最佳实践

1. 配置管理

# application.yml
multi-region:
  enabled: true
  regions:
    - name: us-east
      priority: 1
      endpoint: https://us-east.example.com
    - name: us-west
      priority: 2
      endpoint: https://us-west.example.com
    - name: eu-central
      priority: 3
      endpoint: https://eu-central.example.com
      
  routing:
    strategy: geo-based # 可选: latency-based, geo-based, priority-based
    failover:
      enabled: true
      max-attempts: 3
      timeout: 5s
      
  health:
    check:
      interval: 30s
      timeout: 5s
    failover:
      threshold: 3
      window: 60s

2. 测试策略

@SpringBootTest
class MultiRegionDiscoveryTest {
    
    @Autowired
    private GlobalServiceRegistry serviceRegistry;
    
    @Autowired
    private AutomaticFailoverManager failoverManager;
    
    @Test
    void testCrossRegionServiceDiscovery() {
        // 注册不同区域的服务实例
        serviceRegistry.registerInstance("us-east", 
            new ServiceInstance("user-service-1", "user-service", "192.168.1.10", 8080));
        serviceRegistry.registerInstance("eu-central", 
            new ServiceInstance("user-service-2", "user-service", "192.168.2.10", 8080));
        
        // 验证跨区域服务发现
        List<ServiceInstance> instances = serviceRegistry.getInstances("user-service", "us-east");
        assertEquals(2, instances.size());
    }
    
    @Test
    void testAutomaticFailover() {
        // 模拟本地区域服务不可用
        // 验证自动故障切换到其他区域
        List<ServiceInstance> instances = failoverManager.getAvailableInstances("user-service");
        assertNotNull(instances);
        assertFalse(instances.isEmpty());
    }
}

3. 性能优化

@Component
public class OptimizedMultiRegionDiscovery {
    private final Map<String, CachedServiceInstances> instanceCache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService cacheRefreshScheduler = Executors.newScheduledThreadPool(2);
    
    @PostConstruct
    public void init() {
        // 定期刷新缓存
        cacheRefreshScheduler.scheduleAtFixedRate(this::refreshCache, 0, 10, TimeUnit.SECONDS);
    }
    
    public List<ServiceInstance> getInstances(String serviceId, String preferredRegion) {
        String cacheKey = serviceId + ":" + preferredRegion;
        CachedServiceInstances cached = instanceCache.get(cacheKey);
        
        if (cached != null && System.currentTimeMillis() - cached.getTimestamp() < 5000) {
            return cached.getInstances();
        }
        
        // 异步刷新缓存
        refreshCacheAsync(serviceId, preferredRegion);
        
        // 返回缓存值或从注册中心获取
        if (cached != null) {
            return cached.getInstances();
        }
        
        return fetchInstancesFromRegistry(serviceId, preferredRegion);
    }
    
    private void refreshCacheAsync(String serviceId, String preferredRegion) {
        CompletableFuture.supplyAsync(() -> fetchInstancesFromRegistry(serviceId, preferredRegion))
            .thenAccept(instances -> {
                String cacheKey = serviceId + ":" + preferredRegion;
                instanceCache.put(cacheKey, new CachedServiceInstances(instances, System.currentTimeMillis()));
            })
            .exceptionally(throwable -> {
                // 记录异常但不影响主流程
                return null;
            });
    }
    
    private List<ServiceInstance> fetchInstancesFromRegistry(String serviceId, String preferredRegion) {
        // 从服务注册中心获取实例列表
        return Collections.emptyList(); // 简化实现
    }
    
    private void refreshCache() {
        // 批量刷新热点缓存
        instanceCache.entrySet().removeIf(entry -> {
            CachedServiceInstances cached = entry.getValue();
            return System.currentTimeMillis() - cached.getTimestamp() > 300000; // 5分钟过期
        });
    }
    
    private static class CachedServiceInstances {
        private final List<ServiceInstance> instances;
        private final long timestamp;
        
        CachedServiceInstances(List<ServiceInstance> instances, long timestamp) {
            this.instances = instances;
            this.timestamp = timestamp;
        }
        
        public List<ServiceInstance> getInstances() {
            return instances;
        }
        
        public long getTimestamp() {
            return timestamp;
        }
    }
}

总结

多数据中心与跨区域发现是构建全球分布式系统的关键技术。通过合理的架构设计、智能的路由策略、完善的数据一致性保障以及健壮的故障处理机制，可以实现高可用、低延迟、可扩展的全球服务架构。

在实际应用中，需要根据具体的业务需求、技术栈和资源约束来选择合适的实现方案。随着云原生技术的发展，服务网格、容器编排等新兴技术为多数据中心部署提供了更好的支持，使得构建和管理复杂的全球分布式系统变得更加容易。

未来，随着边缘计算、5G网络等技术的发展，多数据中心架构将向更广泛的地理分布和更精细的延迟优化方向发展，为用户提供更好的服务体验。