第208集网络和网际互连架构实战：TCP-IP协议栈、路由算法、负载均衡的企业级解决方案

/**
 * TCP连接池管理器
 * 实现连接复用、超时控制、健康检查
 */
public class TCPConnectionPool {
    private final BlockingQueue<Socket> connectionPool;
    private final AtomicInteger activeConnections;
    private final int maxConnections;
    private final int maxIdleTime;
    
    public TCPConnectionPool(int maxConnections, int maxIdleTime) {
        this.maxConnections = maxConnections;
        this.maxIdleTime = maxIdleTime;
        this.connectionPool = new LinkedBlockingQueue<>(maxConnections);
        this.activeConnections = new AtomicInteger(0);
    }
    
    /**
     * 获取连接
     */
    public Socket getConnection(String host, int port) throws IOException {
        Socket socket = connectionPool.poll();
        if (socket == null || !isConnectionValid(socket)) {
            socket = createNewConnection(host, port);
        }
        return socket;
    }
    
    /**
     * 归还连接
     */
    public void returnConnection(Socket socket) {
        if (socket != null && !socket.isClosed()) {
            connectionPool.offer(socket);
        }
    }
    
    /**
     * 创建新连接
     */
    private Socket createNewConnection(String host, int port) throws IOException {
        if (activeConnections.get() >= maxConnections) {
            throw new IOException("连接池已满");
        }
        
        Socket socket = new Socket();
        // 设置TCP参数优化
        socket.setTcpNoDelay(true);  // 禁用Nagle算法
        socket.setKeepAlive(true);   // 启用Keep-Alive
        socket.setSoTimeout(30000);  // 设置读取超时
        socket.setSoLinger(true, 0); // 立即关闭连接
        
        socket.connect(new InetSocketAddress(host, port), 5000);
        activeConnections.incrementAndGet();
        
        return socket;
    }
    
    /**
     * 连接有效性检查
     */
    private boolean isConnectionValid(Socket socket) {
        try {
            return !socket.isClosed() && socket.isConnected();
        } catch (Exception e) {
            return false;
        }
    }
}

/**
 * TCP拥塞控制算法实现
 * 支持Cubic、BBR等现代拥塞控制算法
 */
public class TCPCongestionControl {
    private double cwnd;  // 拥塞窗口
    private double ssthresh;  // 慢启动阈值
    private long lastUpdateTime;
    private CongestionControlAlgorithm algorithm;
    
    public enum CongestionControlAlgorithm {
        CUBIC, BBR, RENO
    }
    
    public TCPCongestionControl(CongestionControlAlgorithm algorithm) {
        this.algorithm = algorithm;
        this.cwnd = 1.0;
        this.ssthresh = 65535.0;
        this.lastUpdateTime = System.currentTimeMillis();
    }
    
    /**
     * 处理ACK事件
     */
    public void onAckReceived(int bytesAcked) {
        switch (algorithm) {
            case CUBIC:
                handleCubicAck(bytesAcked);
                break;
            case BBR:
                handleBBRAck(bytesAcked);
                break;
            case RENO:
                handleRenoAck(bytesAcked);
                break;
        }
    }
    
    /**
     * CUBIC算法实现
     */
    private void handleCubicAck(int bytesAcked) {
        long currentTime = System.currentTimeMillis();
        double timeDiff = (currentTime - lastUpdateTime) / 1000.0;
        
        if (cwnd < ssthresh) {
            // 慢启动阶段
            cwnd += bytesAcked;
        } else {
            // 拥塞避免阶段
            double cubicFactor = Math.pow(timeDiff, 3);
            cwnd = 0.4 * Math.pow(bytesAcked, 3) + cubicFactor;
        }
        
        lastUpdateTime = currentTime;
    }
    
    /**
     * BBR算法实现
     */
    private void handleBBRAck(int bytesAcked) {
        // BBR算法基于带宽和RTT的测量
        double bandwidth = calculateBandwidth(bytesAcked);
        double rtt = calculateRTT();
        
        // 根据带宽和RTT调整拥塞窗口
        cwnd = Math.min(cwnd * 1.25, bandwidth * rtt);
    }
    
    /**
     * Reno算法实现
     */
    private void handleRenoAck(int bytesAcked) {
        if (cwnd < ssthresh) {
            // 慢启动
            cwnd += bytesAcked;
        } else {
            // 拥塞避免
            cwnd += (bytesAcked * bytesAcked) / cwnd;
        }
    }
    
    /**
     * 处理丢包事件
     */
    public void onPacketLoss() {
        ssthresh = Math.max(cwnd / 2, 2.0);
        cwnd = 1.0;
    }
    
    private double calculateBandwidth(int bytesAcked) {
        // 带宽计算逻辑
        return bytesAcked * 8.0 / 1000.0; // 简化的带宽计算
    }
    
    private double calculateRTT() {
        // RTT计算逻辑
        return 50.0; // 简化的RTT值
    }
    
    public double getCongestionWindow() {
        return cwnd;
    }
}

/**
 * IP分片重组器
 * 高效处理IP分片，支持内存优化和超时清理
 */
public class IPFragmentReassembler {
    private final Map<String, FragmentBuffer> fragmentBuffers;
    private final ScheduledExecutorService cleanupExecutor;
    private final long fragmentTimeout;
    
    public IPFragmentReassembler(long fragmentTimeout) {
        this.fragmentBuffers = new ConcurrentHashMap<>();
        this.cleanupExecutor = Executors.newScheduledThreadPool(2);
        this.fragmentTimeout = fragmentTimeout;
        
        // 启动清理任务
        cleanupExecutor.scheduleAtFixedRate(this::cleanupExpiredFragments, 
            60, 60, TimeUnit.SECONDS);
    }
    
    /**
     * 处理IP分片
     */
    public byte[] processFragment(IPPacket packet) {
        String fragmentKey = generateFragmentKey(packet);
        FragmentBuffer buffer = fragmentBuffers.computeIfAbsent(fragmentKey, 
            k -> new FragmentBuffer(packet.getTotalLength()));
        
        buffer.addFragment(packet);
        
        if (buffer.isComplete()) {
            fragmentBuffers.remove(fragmentKey);
            return buffer.reassemble();
        }
        
        return null;
    }
    
    /**
     * 生成分片键
     */
    private String generateFragmentKey(IPPacket packet) {
        return packet.getSourceIP() + ":" + packet.getDestIP() + ":" + 
               packet.getIdentification() + ":" + packet.getProtocol();
    }
    
    /**
     * 分片缓冲区
     */
    private static class FragmentBuffer {
        private final byte[] data;
        private final boolean[] received;
        private final int totalLength;
        private long lastUpdateTime;
        
        public FragmentBuffer(int totalLength) {
            this.totalLength = totalLength;
            this.data = new byte[totalLength];
            this.received = new boolean[totalLength];
            this.lastUpdateTime = System.currentTimeMillis();
        }
        
        public void addFragment(IPPacket packet) {
            int offset = packet.getFragmentOffset();
            byte[] payload = packet.getPayload();
            
            System.arraycopy(payload, 0, data, offset, payload.length);
            for (int i = offset; i < offset + payload.length; i++) {
                received[i] = true;
            }
            
            lastUpdateTime = System.currentTimeMillis();
        }
        
        public boolean isComplete() {
            for (boolean b : received) {
                if (!b) return false;
            }
            return true;
        }
        
        public byte[] reassemble() {
            return data.clone();
        }
        
        public boolean isExpired(long timeout) {
            return System.currentTimeMillis() - lastUpdateTime > timeout;
        }
    }
    
    /**
     * 清理过期分片
     */
    private void cleanupExpiredFragments() {
        fragmentBuffers.entrySet().removeIf(entry -> 
            entry.getValue().isExpired(fragmentTimeout));
    }
}

/**
 * OSPF路由算法实现
 * 支持链路状态数据库、最短路径计算、路由表生成
 */
public class OSPFRouter {
    private final String routerId;
    private final Map<String, LinkStateAdvertisement> linkStateDatabase;
    private final Map<String, Integer> routingTable;
    private final Map<String, Neighbor> neighbors;
    private final DijkstraAlgorithm dijkstra;
    
    public OSPFRouter(String routerId) {
        this.routerId = routerId;
        this.linkStateDatabase = new ConcurrentHashMap<>();
        this.routingTable = new ConcurrentHashMap<>();
        this.neighbors = new ConcurrentHashMap<>();
        this.dijkstra = new DijkstraAlgorithm();
    }
    
    /**
     * 处理链路状态通告
     */
    public void processLSA(LinkStateAdvertisement lsa) {
        String lsaKey = lsa.getRouterId() + ":" + lsa.getLinkStateId();
        
        // 检查LSA是否更新
        LinkStateAdvertisement existingLSA = linkStateDatabase.get(lsaKey);
        if (existingLSA == null || lsa.getSequenceNumber() > existingLSA.getSequenceNumber()) {
            linkStateDatabase.put(lsaKey, lsa);
            floodLSA(lsa);
            recalculateRoutes();
        }
    }
    
    /**
     * 洪泛LSA
     */
    private void floodLSA(LinkStateAdvertisement lsa) {
        for (Neighbor neighbor : neighbors.values()) {
            if (!neighbor.getRouterId().equals(lsa.getRouterId())) {
                neighbor.sendLSA(lsa);
            }
        }
    }
    
    /**
     * 重新计算路由
     */
    private void recalculateRoutes() {
        // 构建图
        Graph graph = buildGraph();
        
        // 使用Dijkstra算法计算最短路径
        Map<String, Integer> shortestPaths = dijkstra.calculateShortestPaths(graph, routerId);
        
        // 更新路由表
        routingTable.clear();
        routingTable.putAll(shortestPaths);
    }
    
    /**
     * 构建网络图
     */
    private Graph buildGraph() {
        Graph graph = new Graph();
        
        for (LinkStateAdvertisement lsa : linkStateDatabase.values()) {
            String from = lsa.getRouterId();
            String to = lsa.getLinkStateId();
            int cost = lsa.getCost();
            
            graph.addEdge(from, to, cost);
        }
        
        return graph;
    }
    
    /**
     * 邻居管理
     */
    public void addNeighbor(String neighborId, String interfaceAddress) {
        Neighbor neighbor = new Neighbor(neighborId, interfaceAddress);
        neighbors.put(neighborId, neighbor);
        
        // 发送Hello消息
        sendHelloMessage(neighbor);
    }
    
    private void sendHelloMessage(Neighbor neighbor) {
        HelloMessage hello = new HelloMessage(routerId, neighbor.getInterfaceAddress());
        neighbor.sendMessage(hello);
    }
    
    /**
     * 获取路由表
     */
    public Map<String, Integer> getRoutingTable() {
        return new HashMap<>(routingTable);
    }
}

/**
 * Dijkstra最短路径算法
 */
class DijkstraAlgorithm {
    public Map<String, Integer> calculateShortestPaths(Graph graph, String source) {
        Map<String, Integer> distances = new HashMap<>();
        Map<String, String> previous = new HashMap<>();
        PriorityQueue<Vertex> queue = new PriorityQueue<>();
        Set<String> visited = new HashSet<>();
        
        // 初始化距离
        for (String vertex : graph.getVertices()) {
            distances.put(vertex, Integer.MAX_VALUE);
        }
        distances.put(source, 0);
        
        queue.offer(new Vertex(source, 0));
        
        while (!queue.isEmpty()) {
            Vertex current = queue.poll();
            String currentId = current.getId();
            
            if (visited.contains(currentId)) {
                continue;
            }
            
            visited.add(currentId);
            
            // 检查邻居
            for (Edge edge : graph.getEdges(currentId)) {
                String neighborId = edge.getDestination();
                int newDistance = distances.get(currentId) + edge.getWeight();
                
                if (newDistance < distances.get(neighborId)) {
                    distances.put(neighborId, newDistance);
                    previous.put(neighborId, currentId);
                    queue.offer(new Vertex(neighborId, newDistance));
                }
            }
        }
        
        return distances;
    }
}

/**
 * 图数据结构
 */
class Graph {
    private final Map<String, List<Edge>> adjacencyList;
    
    public Graph() {
        this.adjacencyList = new HashMap<>();
    }
    
    public void addEdge(String from, String to, int weight) {
        adjacencyList.computeIfAbsent(from, k -> new ArrayList<>())
                    .add(new Edge(to, weight));
    }
    
    public List<Edge> getEdges(String vertex) {
        return adjacencyList.getOrDefault(vertex, new ArrayList<>());
    }
    
    public Set<String> getVertices() {
        return adjacencyList.keySet();
    }
}

class Edge {
    private final String destination;
    private final int weight;
    
    public Edge(String destination, int weight) {
        this.destination = destination;
        this.weight = weight;
    }
    
    public String getDestination() { return destination; }
    public int getWeight() { return weight; }
}

class Vertex implements Comparable<Vertex> {
    private final String id;
    private final int distance;
    
    public Vertex(String id, int distance) {
        this.id = id;
        this.distance = distance;
    }
    
    public String getId() { return id; }
    public int getDistance() { return distance; }
    
    @Override
    public int compareTo(Vertex other) {
        return Integer.compare(this.distance, other.distance);
    }
}

/**
 * BGP路由算法实现
 * 支持路径向量协议、路由策略、AS路径管理
 */
public class BGPRouter {
    private final String asNumber;
    private final Map<String, BGPPeer> peers;
    private final Map<String, BGPRoute> routingTable;
    private final RoutePolicyEngine policyEngine;
    
    public BGPRouter(String asNumber) {
        this.asNumber = asNumber;
        this.peers = new ConcurrentHashMap<>();
        this.routingTable = new ConcurrentHashMap<>();
        this.policyEngine = new RoutePolicyEngine();
    }
    
    /**
     * 处理BGP更新消息
     */
    public void processUpdate(BGPUpdateMessage update) {
        String peerId = update.getPeerId();
        BGPPeer peer = peers.get(peerId);
        
        if (peer == null) {
            return;
        }
        
        // 处理撤销路由
        for (String withdrawnRoute : update.getWithdrawnRoutes()) {
            withdrawRoute(withdrawnRoute, peerId);
        }
        
        // 处理新路由
        for (BGPRoute route : update.getNewRoutes()) {
            processNewRoute(route, peerId);
        }
    }
    
    /**
     * 处理新路由
     */
    private void processNewRoute(BGPRoute route, String peerId) {
        // 应用路由策略
        RouteDecision decision = policyEngine.evaluateRoute(route, peerId);
        
        if (decision == RouteDecision.ACCEPT) {
            // 添加AS路径
            route.addAsPath(asNumber);
            
            // 更新路由表
            String prefix = route.getPrefix();
            BGPRoute existingRoute = routingTable.get(prefix);
            
            if (existingRoute == null || isBetterRoute(route, existingRoute)) {
                routingTable.put(prefix, route);
                
                // 向其他对等体通告
                advertiseRoute(route, peerId);
            }
        }
    }
    
    /**
     * 路由选择算法
     */
    private boolean isBetterRoute(BGPRoute newRoute, BGPRoute existingRoute) {
        // BGP路由选择规则
        // 1. 本地优先级
        if (newRoute.getLocalPreference() != existingRoute.getLocalPreference()) {
            return newRoute.getLocalPreference() > existingRoute.getLocalPreference();
        }
        
        // 2. AS路径长度
        if (newRoute.getAsPathLength() != existingRoute.getAsPathLength()) {
            return newRoute.getAsPathLength() < existingRoute.getAsPathLength();
        }
        
        // 3. 起源类型
        if (newRoute.getOrigin() != existingRoute.getOrigin()) {
            return newRoute.getOrigin().getValue() < existingRoute.getOrigin().getValue();
        }
        
        // 4. MED值
        if (newRoute.getMed() != existingRoute.getMed()) {
            return newRoute.getMed() < existingRoute.getMed();
        }
        
        // 5. 对等体类型
        return newRoute.getPeerType().getValue() < existingRoute.getPeerType().getValue();
    }
    
    /**
     * 向对等体通告路由
     */
    private void advertiseRoute(BGPRoute route, String excludePeerId) {
        for (BGPPeer peer : peers.values()) {
            if (!peer.getId().equals(excludePeerId)) {
                // 检查出口策略
                if (policyEngine.shouldAdvertise(route, peer.getId())) {
                    peer.sendUpdate(route);
                }
            }
        }
    }
    
    /**
     * 撤销路由
     */
    private void withdrawRoute(String prefix, String peerId) {
        BGPRoute route = routingTable.get(prefix);
        if (route != null && route.getPeerId().equals(peerId)) {
            routingTable.remove(prefix);
            
            // 向其他对等体发送撤销消息
            for (BGPPeer peer : peers.values()) {
                if (!peer.getId().equals(peerId)) {
                    peer.sendWithdraw(prefix);
                }
            }
        }
    }
}

/**
 * BGP路由策略引擎
 */
class RoutePolicyEngine {
    private final List<RoutePolicy> policies;
    
    public RoutePolicyEngine() {
        this.policies = new ArrayList<>();
    }
    
    public RouteDecision evaluateRoute(BGPRoute route, String peerId) {
        for (RoutePolicy policy : policies) {
            if (policy.matches(route, peerId)) {
                return policy.getDecision();
            }
        }
        return RouteDecision.ACCEPT; // 默认接受
    }
    
    public boolean shouldAdvertise(BGPRoute route, String peerId) {
        for (RoutePolicy policy : policies) {
            if (policy.matches(route, peerId)) {
                return policy.shouldAdvertise();
            }
        }
        return true; // 默认通告
    }
}

enum RouteDecision {
    ACCEPT, REJECT, MODIFY
}

class RoutePolicy {
    private final String name;
    private final RouteCondition condition;
    private final RouteAction action;
    
    public RoutePolicy(String name, RouteCondition condition, RouteAction action) {
        this.name = name;
        this.condition = condition;
        this.action = action;
    }
    
    public boolean matches(BGPRoute route, String peerId) {
        return condition.matches(route, peerId);
    }
    
    public RouteDecision getDecision() {
        return action.getDecision();
    }
    
    public boolean shouldAdvertise() {
        return action.shouldAdvertise();
    }
}

/**
 * 高性能负载均衡器
 * 支持多种算法、健康检查、故障转移
 */
public class HighPerformanceLoadBalancer {
    private final LoadBalanceAlgorithm algorithm;
    private final List<ServerNode> servers;
    private final HealthChecker healthChecker;
    private final CircuitBreaker circuitBreaker;
    private final MetricsCollector metricsCollector;
    
    public HighPerformanceLoadBalancer(LoadBalanceAlgorithm algorithm) {
        this.algorithm = algorithm;
        this.servers = new CopyOnWriteArrayList<>();
        this.healthChecker = new HealthChecker();
        this.circuitBreaker = new CircuitBreaker();
        this.metricsCollector = new MetricsCollector();
        
        // 启动健康检查
        startHealthCheck();
    }
    
    /**
     * 选择服务器
     */
    public ServerNode selectServer(Request request) {
        List<ServerNode> healthyServers = getHealthyServers();
        
        if (healthyServers.isEmpty()) {
            throw new NoAvailableServerException("没有可用的服务器");
        }
        
        ServerNode selectedServer = algorithm.select(healthyServers, request);
        
        // 记录指标
        metricsCollector.recordSelection(selectedServer, request);
        
        return selectedServer;
    }
    
    /**
     * 获取健康服务器列表
     */
    private List<ServerNode> getHealthyServers() {
        return servers.stream()
                .filter(ServerNode::isHealthy)
                .filter(server -> !circuitBreaker.isOpen(server.getId()))
                .collect(Collectors.toList());
    }
    
    /**
     * 添加服务器
     */
    public void addServer(ServerNode server) {
        servers.add(server);
        healthChecker.addServer(server);
        circuitBreaker.addServer(server.getId());
    }
    
    /**
     * 移除服务器
     */
    public void removeServer(String serverId) {
        servers.removeIf(server -> server.getId().equals(serverId));
        healthChecker.removeServer(serverId);
        circuitBreaker.removeServer(serverId);
    }
    
    /**
     * 启动健康检查
     */
    private void startHealthCheck() {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        executor.scheduleAtFixedRate(() -> {
            for (ServerNode server : servers) {
                healthChecker.checkHealth(server);
            }
        }, 0, 30, TimeUnit.SECONDS);
    }
}

/**
 * 负载均衡算法接口
 */
interface LoadBalanceAlgorithm {
    ServerNode select(List<ServerNode> servers, Request request);
}

/**
 * 一致性哈希算法
 */
class ConsistentHashAlgorithm implements LoadBalanceAlgorithm {
    private final ConsistentHashRing hashRing;
    private final int virtualNodes;
    
    public ConsistentHashAlgorithm(int virtualNodes) {
        this.virtualNodes = virtualNodes;
        this.hashRing = new ConsistentHashRing();
    }
    
    @Override
    public ServerNode select(List<ServerNode> servers, Request request) {
        // 更新哈希环
        updateHashRing(servers);
        
        // 计算请求的哈希值
        String key = generateKey(request);
        int hash = hash(key);
        
        // 查找最近的服务器
        return hashRing.getServer(hash);
    }
    
    private void updateHashRing(List<ServerNode> servers) {
        hashRing.clear();
        for (ServerNode server : servers) {
            for (int i = 0; i < virtualNodes; i++) {
                String virtualKey = server.getId() + "#" + i;
                hashRing.addNode(virtualKey, server);
            }
        }
    }
    
    private String generateKey(Request request) {
        // 根据请求特征生成键
        return request.getClientIp() + ":" + request.getPath();
    }
    
    private int hash(String key) {
        return key.hashCode();
    }
}

/**
 * 一致性哈希环
 */
class ConsistentHashRing {
    private final TreeMap<Integer, ServerNode> ring;
    
    public ConsistentHashRing() {
        this.ring = new TreeMap<>();
    }
    
    public void addNode(String key, ServerNode server) {
        int hash = key.hashCode();
        ring.put(hash, server);
    }
    
    public ServerNode getServer(int hash) {
        Map.Entry<Integer, ServerNode> entry = ring.ceilingEntry(hash);
        if (entry == null) {
            entry = ring.firstEntry();
        }
        return entry.getValue();
    }
    
    public void clear() {
        ring.clear();
    }
}

/**
 * 加权最少连接算法
 */
class WeightedLeastConnectionsAlgorithm implements LoadBalanceAlgorithm {
    @Override
    public ServerNode select(List<ServerNode> servers, Request request) {
        return servers.stream()
                .min((s1, s2) -> {
                    double ratio1 = (double) s1.getActiveConnections() / s1.getWeight();
                    double ratio2 = (double) s2.getActiveConnections() / s2.getWeight();
                    return Double.compare(ratio1, ratio2);
                })
                .orElse(null);
    }
}

/**
 * 服务器节点
 */
class ServerNode {
    private final String id;
    private final String host;
    private final int port;
    private final int weight;
    private volatile boolean healthy;
    private volatile int activeConnections;
    private volatile long lastResponseTime;
    
    public ServerNode(String id, String host, int port, int weight) {
        this.id = id;
        this.host = host;
        this.port = port;
        this.weight = weight;
        this.healthy = true;
        this.activeConnections = 0;
        this.lastResponseTime = 0;
    }
    
    public String getId() { return id; }
    public String getHost() { return host; }
    public int getPort() { return port; }
    public int getWeight() { return weight; }
    public boolean isHealthy() { return healthy; }
    public int getActiveConnections() { return activeConnections; }
    public long getLastResponseTime() { return lastResponseTime; }
    
    public void setHealthy(boolean healthy) { this.healthy = healthy; }
    public void incrementConnections() { this.activeConnections++; }
    public void decrementConnections() { this.activeConnections--; }
    public void updateResponseTime(long responseTime) { this.lastResponseTime = responseTime; }
    
    public String getAddress() {
        return host + ":" + port;
    }
}

/**
 * 健康检查器
 */
class HealthChecker {
    private final Map<String, ServerNode> servers;
    private final HttpClient httpClient;
    
    public HealthChecker() {
        this.servers = new ConcurrentHashMap<>();
        this.httpClient = HttpClient.newHttpClient();
    }
    
    public void addServer(ServerNode server) {
        servers.put(server.getId(), server);
    }
    
    public void removeServer(String serverId) {
        servers.remove(serverId);
    }
    
    public void checkHealth(ServerNode server) {
        try {
            String healthUrl = "http://" + server.getAddress() + "/health";
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(healthUrl))
                    .timeout(Duration.ofSeconds(5))
                    .build();
            
            HttpResponse<String> response = httpClient.send(request, 
                    HttpResponse.BodyHandlers.ofString());
            
            boolean isHealthy = response.statusCode() == 200;
            server.setHealthy(isHealthy);
            
            if (isHealthy) {
                server.updateResponseTime(System.currentTimeMillis());
            }
            
        } catch (Exception e) {
            server.setHealthy(false);
        }
    }
}

/**
 * 熔断器
 */
class CircuitBreaker {
    private final Map<String, CircuitBreakerState> states;
    private final int failureThreshold;
    private final long timeout;
    
    public CircuitBreaker(int failureThreshold, long timeout) {
        this.states = new ConcurrentHashMap<>();
        this.failureThreshold = failureThreshold;
        this.timeout = timeout;
    }
    
    public CircuitBreaker() {
        this(5, 60000); // 默认5次失败，60秒超时
    }
    
    public void addServer(String serverId) {
        states.put(serverId, new CircuitBreakerState());
    }
    
    public void removeServer(String serverId) {
        states.remove(serverId);
    }
    
    public boolean isOpen(String serverId) {
        CircuitBreakerState state = states.get(serverId);
        if (state == null) return false;
        
        if (state.getState() == CircuitState.OPEN) {
            if (System.currentTimeMillis() - state.getLastFailureTime() > timeout) {
                state.setState(CircuitState.HALF_OPEN);
                return false;
            }
            return true;
        }
        
        return false;
    }
    
    public void recordSuccess(String serverId) {
        CircuitBreakerState state = states.get(serverId);
        if (state != null) {
            state.setState(CircuitState.CLOSED);
            state.resetFailureCount();
        }
    }
    
    public void recordFailure(String serverId) {
        CircuitBreakerState state = states.get(serverId);
        if (state != null) {
            state.incrementFailureCount();
            if (state.getFailureCount() >= failureThreshold) {
                state.setState(CircuitState.OPEN);
                state.setLastFailureTime(System.currentTimeMillis());
            }
        }
    }
}

enum CircuitState {
    CLOSED, OPEN, HALF_OPEN
}

class CircuitBreakerState {
    private CircuitState state;
    private int failureCount;
    private long lastFailureTime;
    
    public CircuitBreakerState() {
        this.state = CircuitState.CLOSED;
        this.failureCount = 0;
        this.lastFailureTime = 0;
    }
    
    public CircuitState getState() { return state; }
    public void setState(CircuitState state) { this.state = state; }
    public int getFailureCount() { return failureCount; }
    public void incrementFailureCount() { this.failureCount++; }
    public void resetFailureCount() { this.failureCount = 0; }
    public long getLastFailureTime() { return lastFailureTime; }
    public void setLastFailureTime(long lastFailureTime) { this.lastFailureTime = lastFailureTime; }
}

/**
 * 四层负载均衡器
 * 基于IP和端口进行负载均衡
 */
public class Layer4LoadBalancer {
    private final Map<String, BackendPool> pools;
    private final PacketProcessor packetProcessor;
    private final ConnectionTracker connectionTracker;
    
    public Layer4LoadBalancer() {
        this.pools = new ConcurrentHashMap<>();
        this.packetProcessor = new PacketProcessor();
        this.connectionTracker = new ConnectionTracker();
    }
    
    /**
     * 处理数据包
     */
    public void processPacket(NetworkPacket packet) {
        String poolKey = packet.getDestIP() + ":" + packet.getDestPort();
        BackendPool pool = pools.get(poolKey);
        
        if (pool == null) {
            // 丢弃数据包
            return;
        }
        
        // 查找现有连接
        String connectionKey = generateConnectionKey(packet);
        BackendServer existingServer = connectionTracker.getServer(connectionKey);
        
        if (existingServer != null) {
            // 使用现有连接
            forwardPacket(packet, existingServer);
        } else {
            // 选择新服务器
            BackendServer selectedServer = pool.selectServer();
            if (selectedServer != null) {
                connectionTracker.addConnection(connectionKey, selectedServer);
                forwardPacket(packet, selectedServer);
            }
        }
    }
    
    /**
     * 转发数据包
     */
    private void forwardPacket(NetworkPacket packet, BackendServer server) {
        // 修改目标IP和端口
        packet.setDestIP(server.getIP());
        packet.setDestPort(server.getPort());
        
        // 重新计算校验和
        packetProcessor.recalculateChecksum(packet);
        
        // 发送到后端服务器
        server.sendPacket(packet);
    }
    
    /**
     * 生成连接键
     */
    private String generateConnectionKey(NetworkPacket packet) {
        return packet.getSourceIP() + ":" + packet.getSourcePort() + ":" +
               packet.getDestIP() + ":" + packet.getDestPort();
    }
    
    /**
     * 添加后端池
     */
    public void addBackendPool(String vip, int vport, List<BackendServer> servers) {
        String poolKey = vip + ":" + vport;
        BackendPool pool = new BackendPool(servers);
        pools.put(poolKey, pool);
    }
}

/**
 * 后端服务器池
 */
class BackendPool {
    private final List<BackendServer> servers;
    private final LoadBalanceAlgorithm algorithm;
    private final HealthChecker healthChecker;
    
    public BackendPool(List<BackendServer> servers) {
        this.servers = new CopyOnWriteArrayList<>(servers);
        this.algorithm = new WeightedRoundRobinAlgorithm();
        this.healthChecker = new HealthChecker();
        
        // 启动健康检查
        startHealthCheck();
    }
    
    public BackendServer selectServer() {
        List<BackendServer> healthyServers = servers.stream()
                .filter(BackendServer::isHealthy)
                .collect(Collectors.toList());
        
        if (healthyServers.isEmpty()) {
            return null;
        }
        
        return algorithm.select(healthyServers, null);
    }
    
    private void startHealthCheck() {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleAtFixedRate(() -> {
            for (BackendServer server : servers) {
                healthChecker.checkHealth(server);
            }
        }, 0, 10, TimeUnit.SECONDS);
    }
}

/**
 * 后端服务器
 */
class BackendServer {
    private final String id;
    private final String ip;
    private final int port;
    private final int weight;
    private volatile boolean healthy;
    private volatile int currentWeight;
    
    public BackendServer(String id, String ip, int port, int weight) {
        this.id = id;
        this.ip = ip;
        this.port = port;
        this.weight = weight;
        this.healthy = true;
        this.currentWeight = 0;
    }
    
    public String getId() { return id; }
    public String getIP() { return ip; }
    public int getPort() { return port; }
    public int getWeight() { return weight; }
    public boolean isHealthy() { return healthy; }
    public int getCurrentWeight() { return currentWeight; }
    
    public void setHealthy(boolean healthy) { this.healthy = healthy; }
    public void setCurrentWeight(int currentWeight) { this.currentWeight = currentWeight; }
    
    public void sendPacket(NetworkPacket packet) {
        // 发送数据包到后端服务器
        // 这里需要实现实际的网络发送逻辑
    }
}

/**
 * 连接跟踪器
 */
class ConnectionTracker {
    private final Map<String, BackendServer> connections;
    private final ScheduledExecutorService cleanupExecutor;
    
    public ConnectionTracker() {
        this.connections = new ConcurrentHashMap<>();
        this.cleanupExecutor = Executors.newScheduledThreadPool(1);
        
        // 启动连接清理
        cleanupExecutor.scheduleAtFixedRate(this::cleanupExpiredConnections, 
            60, 60, TimeUnit.SECONDS);
    }
    
    public void addConnection(String connectionKey, BackendServer server) {
        connections.put(connectionKey, server);
    }
    
    public BackendServer getServer(String connectionKey) {
        return connections.get(connectionKey);
    }
    
    public void removeConnection(String connectionKey) {
        connections.remove(connectionKey);
    }
    
    private void cleanupExpiredConnections() {
        // 清理过期的连接
        // 这里需要实现连接超时检测逻辑
    }
}

/**
 * 加权轮询算法
 */
class WeightedRoundRobinAlgorithm implements LoadBalanceAlgorithm {
    @Override
    public ServerNode select(List<ServerNode> servers, Request request) {
        int totalWeight = servers.stream().mapToInt(ServerNode::getWeight).sum();
        int currentWeight = 0;
        
        for (ServerNode server : servers) {
            currentWeight += server.getWeight();
            if (currentWeight >= totalWeight) {
                return server;
            }
        }
        
        return servers.get(0);
    }
}

/**
 * 微服务网络架构管理器
 * 实现服务发现、负载均衡、熔断、限流
 */
public class MicroserviceNetworkArchitecture {
    private final ServiceRegistry serviceRegistry;
    private final LoadBalancer loadBalancer;
    private final CircuitBreakerManager circuitBreakerManager;
    private final RateLimiterManager rateLimiterManager;
    private final MetricsCollector metricsCollector;
    
    public MicroserviceNetworkArchitecture() {
        this.serviceRegistry = new ServiceRegistry();
        this.loadBalancer = new LoadBalancer();
        this.circuitBreakerManager = new CircuitBreakerManager();
        this.rateLimiterManager = new RateLimiterManager();
        this.metricsCollector = new MetricsCollector();
    }
    
    /**
     * 处理服务请求
     */
    public Response handleRequest(ServiceRequest request) {
        String serviceName = request.getServiceName();
        
        try {
            // 限流检查
            if (!rateLimiterManager.allowRequest(serviceName, request.getClientId())) {
                return Response.rateLimited();
            }
            
            // 获取服务实例
            List<ServiceInstance> instances = serviceRegistry.getInstances(serviceName);
            if (instances.isEmpty()) {
                return Response.serviceNotFound();
            }
            
            // 负载均衡选择
            ServiceInstance selectedInstance = loadBalancer.select(instances, request);
            
            // 熔断检查
            if (circuitBreakerManager.isOpen(selectedInstance.getId())) {
                return Response.circuitBreakerOpen();
            }
            
            // 发送请求
            long startTime = System.currentTimeMillis();
            Response response = sendRequest(selectedInstance, request);
            long endTime = System.currentTimeMillis();
            
            // 记录成功
            circuitBreakerManager.recordSuccess(selectedInstance.getId());
            metricsCollector.recordRequest(selectedInstance, request, response, endTime - startTime);
            
            return response;
            
        } catch (Exception e) {
            // 记录失败
            circuitBreakerManager.recordFailure(serviceName);
            metricsCollector.recordError(serviceName, e);
            
            return Response.error(e.getMessage());
        }
    }
    
    /**
     * 发送请求到服务实例
     */
    private Response sendRequest(ServiceInstance instance, ServiceRequest request) {
        // 实现实际的HTTP请求发送
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest httpRequest = HttpRequest.newBuilder()
                .uri(URI.create("http://" + instance.getAddress() + request.getPath()))
                .method(request.getMethod(), HttpRequest.BodyPublishers.ofString(request.getBody()))
                .timeout(Duration.ofSeconds(30))
                .build();
        
        try {
            HttpResponse<String> httpResponse = client.send(httpRequest, 
                    HttpResponse.BodyHandlers.ofString());
            
            return Response.success(httpResponse.body(), httpResponse.statusCode());
        } catch (Exception e) {
            throw new RuntimeException("请求失败", e);
        }
    }
    
    /**
     * 注册服务实例
     */
    public void registerService(ServiceInstance instance) {
        serviceRegistry.register(instance);
    }
    
    /**
     * 注销服务实例
     */
    public void unregisterService(String instanceId) {
        serviceRegistry.unregister(instanceId);
    }
}

/**
 * 服务注册中心
 */
class ServiceRegistry {
    private final Map<String, List<ServiceInstance>> services;
    private final Map<String, ServiceInstance> instances;
    private final ScheduledExecutorService heartbeatExecutor;
    
    public ServiceRegistry() {
        this.services = new ConcurrentHashMap<>();
        this.instances = new ConcurrentHashMap<>();
        this.heartbeatExecutor = Executors.newScheduledThreadPool(2);
        
        // 启动心跳检查
        startHeartbeatCheck();
    }
    
    public void register(ServiceInstance instance) {
        instances.put(instance.getId(), instance);
        services.computeIfAbsent(instance.getServiceName(), k -> new CopyOnWriteArrayList<>())
                .add(instance);
        
        // 启动心跳
        startHeartbeat(instance);
    }
    
    public void unregister(String instanceId) {
        ServiceInstance instance = instances.remove(instanceId);
        if (instance != null) {
            List<ServiceInstance> serviceInstances = services.get(instance.getServiceName());
            if (serviceInstances != null) {
                serviceInstances.removeIf(inst -> inst.getId().equals(instanceId));
            }
        }
    }
    
    public List<ServiceInstance> getInstances(String serviceName) {
        List<ServiceInstance> serviceInstances = services.get(serviceName);
        if (serviceInstances == null) {
            return new ArrayList<>();
        }
        
        return serviceInstances.stream()
                .filter(ServiceInstance::isHealthy)
                .collect(Collectors.toList());
    }
    
    private void startHeartbeat(ServiceInstance instance) {
        heartbeatExecutor.scheduleAtFixedRate(() -> {
            try {
                instance.heartbeat();
            } catch (Exception e) {
                // 心跳失败，标记为不健康
                instance.setHealthy(false);
            }
        }, 0, 30, TimeUnit.SECONDS);
    }
    
    private void startHeartbeatCheck() {
        heartbeatExecutor.scheduleAtFixedRate(() -> {
            for (ServiceInstance instance : instances.values()) {
                if (instance.isExpired()) {
                    instance.setHealthy(false);
                }
            }
        }, 0, 60, TimeUnit.SECONDS);
    }
}

/**
 * 服务实例
 */
class ServiceInstance {
    private final String id;
    private final String serviceName;
    private final String host;
    private final int port;
    private final Map<String, String> metadata;
    private volatile boolean healthy;
    private volatile long lastHeartbeat;
    
    public ServiceInstance(String id, String serviceName, String host, int port) {
        this.id = id;
        this.serviceName = serviceName;
        this.host = host;
        this.port = port;
        this.metadata = new ConcurrentHashMap<>();
        this.healthy = true;
        this.lastHeartbeat = System.currentTimeMillis();
    }
    
    public String getId() { return id; }
    public String getServiceName() { return serviceName; }
    public String getHost() { return host; }
    public int getPort() { return port; }
    public String getAddress() { return host + ":" + port; }
    public boolean isHealthy() { return healthy; }
    public Map<String, String> getMetadata() { return metadata; }
    
    public void setHealthy(boolean healthy) { this.healthy = healthy; }
    public void heartbeat() { this.lastHeartbeat = System.currentTimeMillis(); }
    public boolean isExpired() { return System.currentTimeMillis() - lastHeartbeat > 90000; }
}