网络通信层

# 网络通信层

# 📖 章节概述

网络通信层是物联网系统的神经网络，负责设备间的数据传输、协议转换和网络管理。本章将深入讲解网络拓扑设计、通信协议选择、网络安全机制和QoS保障策略。

# 🎯 学习目标

掌握物联网网络拓扑设计原则
理解各种通信协议的特点和应用场景
学会设计网络安全防护机制
掌握QoS保障和网络优化策略

# 1. 网络架构概览

# 1.1 分层网络架构

graph TB
    subgraph "云端网络 Cloud Network"
        C1[云服务器]
        C2[负载均衡器]
        C3[CDN节点]
        C4[数据中心]
    end
    
    subgraph "广域网 WAN"
        W1[互联网]
        W2[专线网络]
        W3[卫星网络]
        W4[移动网络]
    end
    
    subgraph "边缘网络 Edge Network"
        E1[边缘服务器]
        E2[边缘网关]
        E3[基站]
        E4[接入点]
    end
    
    subgraph "局域网 LAN"
        L1[企业网络]
        L2[家庭网络]
        L3[工业网络]
        L4[校园网络]
    end
    
    subgraph "设备网络 Device Network"
        D1[WiFi设备]
        D2[蓝牙设备]
        D3[Zigbee设备]
        D4[LoRa设备]
    end
    
    C1 --> W1
    C2 --> W2
    C3 --> W3
    C4 --> W4
    
    W1 --> E1
    W2 --> E2
    W3 --> E3
    W4 --> E4
    
    E1 --> L1
    E2 --> L2
    E3 --> L3
    E4 --> L4
    
    L1 --> D1
    L2 --> D2
    L3 --> D3
    L4 --> D4

# 1.2 网络拓扑类型

拓扑类型	特点	优势	劣势	适用场景
星型拓扑	中心节点连接所有设备	易管理、故障隔离	中心节点单点故障	家庭网络、小型办公
网状拓扑	设备间多路径连接	高可靠性、自愈能力	复杂度高、成本高	工业控制、关键应用
树型拓扑	分层结构连接	扩展性好、层次清晰	根节点故障影响大	大型企业网络
总线拓扑	共享通信介质	成本低、易扩展	冲突多、性能受限	传感器网络
混合拓扑	多种拓扑组合	灵活性高、适应性强	设计复杂、管理困难	复杂物联网系统

# 2. 通信协议栈

# 2.1 协议分层模型

graph TB
    subgraph "应用层 Application Layer"
        A1[MQTT]
        A2[CoAP]
        A3[HTTP/HTTPS]
        A4[WebSocket]
    end
    
    subgraph "传输层 Transport Layer"
        T1[TCP]
        T2[UDP]
        T3[DTLS]
        T4[QUIC]
    end
    
    subgraph "网络层 Network Layer"
        N1[IPv4]
        N2[IPv6]
        N3[6LoWPAN]
        N4[RPL]
    end
    
    subgraph "数据链路层 Data Link Layer"
        D1[Ethernet]
        D2[WiFi]
        D3[Bluetooth]
        D4[Zigbee]
    end
    
    subgraph "物理层 Physical Layer"
        P1[有线介质]
        P2[无线电波]
        P3[光纤]
        P4[电力线]
    end
    
    A1 --> T1
    A2 --> T2
    A3 --> T1
    A4 --> T1
    
    T1 --> N1
    T2 --> N2
    T3 --> N3
    T4 --> N4
    
    N1 --> D1
    N2 --> D2
    N3 --> D3
    N4 --> D4
    
    D1 --> P1
    D2 --> P2
    D3 --> P3
    D4 --> P4

# 2.2 协议选择决策树

// 示例：智能协议选择器
public class ProtocolSelector {
    
    public enum NetworkRequirement {
        LOW_POWER,
        HIGH_THROUGHPUT,
        LOW_LATENCY,
        HIGH_RELIABILITY,
        LONG_RANGE,
        SECURITY_CRITICAL
    }
    
    public enum ProtocolType {
        WIFI,
        BLUETOOTH,
        ZIGBEE,
        LORA,
        NB_IOT,
        ETHERNET,
        CELLULAR_4G,
        CELLULAR_5G
    }
    
    private static class ProtocolCharacteristics {
        final ProtocolType type;
        final int range;           // 传输距离(米)
        final int throughput;      // 吞吐量(Mbps)
        final int powerConsumption; // 功耗等级(1-10)
        final int latency;         // 延迟(ms)
        final int reliability;     // 可靠性(1-10)
        final boolean securitySupport;
        
        public ProtocolCharacteristics(ProtocolType type, int range, 
                int throughput, int powerConsumption, int latency, 
                int reliability, boolean securitySupport) {
            this.type = type;
            this.range = range;
            this.throughput = throughput;
            this.powerConsumption = powerConsumption;
            this.latency = latency;
            this.reliability = reliability;
            this.securitySupport = securitySupport;
        }
    }
    
    private final List<ProtocolCharacteristics> protocols;
    
    public ProtocolSelector() {
        protocols = Arrays.asList(
            new ProtocolCharacteristics(ProtocolType.WIFI, 100, 150, 7, 10, 8, true),
            new ProtocolCharacteristics(ProtocolType.BLUETOOTH, 10, 2, 3, 50, 6, true),
            new ProtocolCharacteristics(ProtocolType.ZIGBEE, 100, 1, 2, 100, 7, true),
            new ProtocolCharacteristics(ProtocolType.LORA, 15000, 1, 1, 1000, 9, false),
            new ProtocolCharacteristics(ProtocolType.NB_IOT, 35000, 1, 1, 2000, 9, true),
            new ProtocolCharacteristics(ProtocolType.ETHERNET, 100, 1000, 5, 1, 10, true),
            new ProtocolCharacteristics(ProtocolType.CELLULAR_4G, 50000, 100, 8, 50, 9, true),
            new ProtocolCharacteristics(ProtocolType.CELLULAR_5G, 50000, 1000, 9, 1, 10, true)
        );
    }
    
    public ProtocolType selectOptimalProtocol(Set<NetworkRequirement> requirements, 
            int requiredRange, int requiredThroughput) {
        
        return protocols.stream()
            .filter(p -> p.range >= requiredRange)
            .filter(p -> p.throughput >= requiredThroughput)
            .filter(p -> meetsRequirements(p, requirements))
            .min(this::compareProtocols)
            .map(p -> p.type)
            .orElse(ProtocolType.WIFI); // 默认选择
    }
    
    private boolean meetsRequirements(ProtocolCharacteristics protocol, 
            Set<NetworkRequirement> requirements) {
        
        for (NetworkRequirement req : requirements) {
            switch (req) {
                case LOW_POWER:
                    if (protocol.powerConsumption > 3) return false;
                    break;
                case HIGH_THROUGHPUT:
                    if (protocol.throughput < 10) return false;
                    break;
                case LOW_LATENCY:
                    if (protocol.latency > 100) return false;
                    break;
                case HIGH_RELIABILITY:
                    if (protocol.reliability < 8) return false;
                    break;
                case LONG_RANGE:
                    if (protocol.range < 1000) return false;
                    break;
                case SECURITY_CRITICAL:
                    if (!protocol.securitySupport) return false;
                    break;
            }
        }
        return true;
    }
    
    private int compareProtocols(ProtocolCharacteristics p1, ProtocolCharacteristics p2) {
        // 综合评分：功耗权重40%，可靠性30%，延迟20%，成本10%
        double score1 = (10 - p1.powerConsumption) * 0.4 + 
                        p1.reliability * 0.3 + 
                        (1000 - p1.latency) / 100.0 * 0.2 + 
                        5 * 0.1; // 简化的成本评分
        
        double score2 = (10 - p2.powerConsumption) * 0.4 + 
                        p2.reliability * 0.3 + 
                        (1000 - p2.latency) / 100.0 * 0.2 + 
                        5 * 0.1;
        
        return Double.compare(score2, score1); // 分数高的优先
    }
    
    // 使用示例
    public static void main(String[] args) {
        ProtocolSelector selector = new ProtocolSelector();
        
        // 场景1：智能家居传感器
        Set<NetworkRequirement> homeRequirements = Set.of(
            NetworkRequirement.LOW_POWER,
            NetworkRequirement.HIGH_RELIABILITY
        );
        ProtocolType homeProtocol = selector.selectOptimalProtocol(
            homeRequirements, 50, 1);
        System.out.println("智能家居推荐协议: " + homeProtocol);
        
        // 场景2：工业实时控制
        Set<NetworkRequirement> industrialRequirements = Set.of(
            NetworkRequirement.LOW_LATENCY,
            NetworkRequirement.HIGH_RELIABILITY,
            NetworkRequirement.SECURITY_CRITICAL
        );
        ProtocolType industrialProtocol = selector.selectOptimalProtocol(
            industrialRequirements, 200, 10);
        System.out.println("工业控制推荐协议: " + industrialProtocol);
        
        // 场景3：远程监控
        Set<NetworkRequirement> remoteRequirements = Set.of(
            NetworkRequirement.LONG_RANGE,
            NetworkRequirement.LOW_POWER
        );
        ProtocolType remoteProtocol = selector.selectOptimalProtocol(
            remoteRequirements, 10000, 1);
        System.out.println("远程监控推荐协议: " + remoteProtocol);
    }
}

# 3. 网络拓扑设计

# 3.1 自适应网络拓扑

// 示例：自适应网络拓扑管理器
public class AdaptiveNetworkTopology {
    
    private static class NetworkNode {
        final String nodeId;
        final String nodeType;
        final Set<String> neighbors;
        final Map<String, Integer> linkQuality;
        final boolean isGateway;
        int batteryLevel;
        long lastSeen;
        
        public NetworkNode(String nodeId, String nodeType, boolean isGateway) {
            this.nodeId = nodeId;
            this.nodeType = nodeType;
            this.isGateway = isGateway;
            this.neighbors = new ConcurrentHashMap<>().keySet(ConcurrentHashMap.newKeySet());
            this.linkQuality = new ConcurrentHashMap<>();
            this.batteryLevel = 100;
            this.lastSeen = System.currentTimeMillis();
        }
    }
    
    private final Map<String, NetworkNode> nodes;
    private final Map<String, List<String>> routingTable;
    private final ScheduledExecutorService scheduler;
    
    public AdaptiveNetworkTopology() {
        this.nodes = new ConcurrentHashMap<>();
        this.routingTable = new ConcurrentHashMap<>();
        this.scheduler = Executors.newScheduledThreadPool(2);
        
        // 启动网络维护任务
        startNetworkMaintenance();
    }
    
    public void addNode(String nodeId, String nodeType, boolean isGateway) {
        NetworkNode node = new NetworkNode(nodeId, nodeType, isGateway);
        nodes.put(nodeId, node);
        
        // 发现邻居节点
        discoverNeighbors(nodeId);
        
        // 更新路由表
        updateRoutingTable();
    }
    
    public void removeNode(String nodeId) {
        NetworkNode removedNode = nodes.remove(nodeId);
        if (removedNode != null) {
            // 清理邻居关系
            for (NetworkNode node : nodes.values()) {
                node.neighbors.remove(nodeId);
                node.linkQuality.remove(nodeId);
            }
            
            // 重新计算路由
            updateRoutingTable();
            
            // 如果是网关节点，触发网络重组
            if (removedNode.isGateway) {
                reorganizeNetwork();
            }
        }
    }
    
    public void updateLinkQuality(String nodeId1, String nodeId2, int quality) {
        NetworkNode node1 = nodes.get(nodeId1);
        NetworkNode node2 = nodes.get(nodeId2);
        
        if (node1 != null && node2 != null) {
            node1.linkQuality.put(nodeId2, quality);
            node2.linkQuality.put(nodeId1, quality);
            
            // 如果链路质量过低，移除邻居关系
            if (quality < 30) {
                node1.neighbors.remove(nodeId2);
                node2.neighbors.remove(nodeId1);
                updateRoutingTable();
            } else {
                // 添加邻居关系
                node1.neighbors.add(nodeId2);
                node2.neighbors.add(nodeId1);
            }
        }
    }
    
    public List<String> findOptimalPath(String sourceId, String targetId) {
        // 使用Dijkstra算法找到最优路径
        Map<String, Integer> distances = new HashMap<>();
        Map<String, String> previous = new HashMap<>();
        PriorityQueue<String> queue = new PriorityQueue<>(
            Comparator.comparing(distances::get));
        
        // 初始化距离
        for (String nodeId : nodes.keySet()) {
            distances.put(nodeId, Integer.MAX_VALUE);
        }
        distances.put(sourceId, 0);
        queue.add(sourceId);
        
        while (!queue.isEmpty()) {
            String current = queue.poll();
            
            if (current.equals(targetId)) {
                break;
            }
            
            NetworkNode currentNode = nodes.get(current);
            if (currentNode == null) continue;
            
            for (String neighbor : currentNode.neighbors) {
                int linkCost = calculateLinkCost(current, neighbor);
                int newDistance = distances.get(current) + linkCost;
                
                if (newDistance < distances.get(neighbor)) {
                    distances.put(neighbor, newDistance);
                    previous.put(neighbor, current);
                    queue.remove(neighbor);
                    queue.add(neighbor);
                }
            }
        }
        
        // 重建路径
        List<String> path = new ArrayList<>();
        String current = targetId;
        while (current != null) {
            path.add(0, current);
            current = previous.get(current);
        }
        
        return path.get(0).equals(sourceId) ? path : Collections.emptyList();
    }
    
    private int calculateLinkCost(String nodeId1, String nodeId2) {
        NetworkNode node1 = nodes.get(nodeId1);
        NetworkNode node2 = nodes.get(nodeId2);
        
        if (node1 == null || node2 == null) {
            return Integer.MAX_VALUE;
        }
        
        // 综合考虑链路质量、节点电量、节点类型
        int linkQuality = node1.linkQuality.getOrDefault(nodeId2, 50);
        int batteryFactor = Math.min(node1.batteryLevel, node2.batteryLevel);
        int typeFactor = (node1.isGateway || node2.isGateway) ? 50 : 100;
        
        // 成本计算：链路质量越高成本越低，电量越低成本越高
        return (100 - linkQuality) + (100 - batteryFactor) / 2 + typeFactor;
    }
    
    private void discoverNeighbors(String nodeId) {
        // 模拟邻居发现过程
        NetworkNode node = nodes.get(nodeId);
        if (node == null) return;
        
        for (NetworkNode otherNode : nodes.values()) {
            if (!otherNode.nodeId.equals(nodeId)) {
                // 模拟信号强度检测
                int signalStrength = simulateSignalStrength(nodeId, otherNode.nodeId);
                
                if (signalStrength > 40) { // 信号强度阈值
                    node.neighbors.add(otherNode.nodeId);
                    otherNode.neighbors.add(nodeId);
                    
                    node.linkQuality.put(otherNode.nodeId, signalStrength);
                    otherNode.linkQuality.put(nodeId, signalStrength);
                }
            }
        }
    }
    
    private int simulateSignalStrength(String nodeId1, String nodeId2) {
        // 简化的信号强度模拟
        return 50 + (int)(Math.random() * 40); // 50-90之间的随机值
    }
    
    private void updateRoutingTable() {
        routingTable.clear();
        
        // 为每个节点计算到所有其他节点的最优路径
        for (String sourceId : nodes.keySet()) {
            for (String targetId : nodes.keySet()) {
                if (!sourceId.equals(targetId)) {
                    List<String> path = findOptimalPath(sourceId, targetId);
                    if (!path.isEmpty()) {
                        routingTable.put(sourceId + "-" + targetId, path);
                    }
                }
            }
        }
    }
    
    private void reorganizeNetwork() {
        // 网络重组逻辑
        System.out.println("网络重组开始...");
        
        // 1. 寻找新的网关节点
        List<String> potentialGateways = findPotentialGateways();
        
        // 2. 重新分配网络角色
        reassignNetworkRoles(potentialGateways);
        
        // 3. 重建网络拓扑
        rebuildTopology();
        
        System.out.println("网络重组完成");
    }
    
    private List<String> findPotentialGateways() {
        return nodes.values().stream()
            .filter(node -> node.batteryLevel > 50)
            .filter(node -> node.neighbors.size() >= 2)
            .sorted((n1, n2) -> Integer.compare(n2.neighbors.size(), n1.neighbors.size()))
            .map(node -> node.nodeId)
            .limit(3)
            .collect(Collectors.toList());
    }
    
    private void reassignNetworkRoles(List<String> potentialGateways) {
        // 重新分配网关角色
        for (NetworkNode node : nodes.values()) {
            node.isGateway = potentialGateways.contains(node.nodeId);
        }
    }
    
    private void rebuildTopology() {
        // 重建网络拓扑
        for (String nodeId : nodes.keySet()) {
            discoverNeighbors(nodeId);
        }
        updateRoutingTable();
    }
    
    private void startNetworkMaintenance() {
        // 定期网络健康检查
        scheduler.scheduleAtFixedRate(this::performHealthCheck, 30, 30, TimeUnit.SECONDS);
        
        // 定期路由优化
        scheduler.scheduleAtFixedRate(this::optimizeRouting, 60, 60, TimeUnit.SECONDS);
    }
    
    private void performHealthCheck() {
        long currentTime = System.currentTimeMillis();
        List<String> deadNodes = new ArrayList<>();
        
        for (NetworkNode node : nodes.values()) {
            // 检查节点是否超时
            if (currentTime - node.lastSeen > 120000) { // 2分钟超时
                deadNodes.add(node.nodeId);
            }
            
            // 检查电量
            if (node.batteryLevel < 10) {
                System.out.println("警告：节点 " + node.nodeId + " 电量过低");
            }
        }
        
        // 移除死节点
        for (String deadNode : deadNodes) {
            removeNode(deadNode);
        }
    }
    
    private void optimizeRouting() {
        // 路由优化逻辑
        updateRoutingTable();
        
        // 负载均衡
        balanceNetworkLoad();
    }
    
    private void balanceNetworkLoad() {
        // 简化的负载均衡实现
        Map<String, Integer> nodeLoad = new HashMap<>();
        
        // 计算每个节点的负载
        for (List<String> path : routingTable.values()) {
            for (String nodeId : path) {
                nodeLoad.put(nodeId, nodeLoad.getOrDefault(nodeId, 0) + 1);
            }
        }
        
        // 识别过载节点
        int avgLoad = nodeLoad.values().stream().mapToInt(Integer::intValue).sum() / nodeLoad.size();
        
        for (Map.Entry<String, Integer> entry : nodeLoad.entrySet()) {
            if (entry.getValue() > avgLoad * 1.5) {
                System.out.println("节点 " + entry.getKey() + " 负载过高: " + entry.getValue());
                // 可以在这里实施负载分散策略
            }
        }
    }
    
    public void printNetworkStatus() {
        System.out.println("=== 网络状态 ===");
        System.out.println("节点总数: " + nodes.size());
        
        for (NetworkNode node : nodes.values()) {
            System.out.printf("节点 %s: 类型=%s, 网关=%s, 电量=%d%%, 邻居=%d\n",
                node.nodeId, node.nodeType, node.isGateway, 
                node.batteryLevel, node.neighbors.size());
        }
        
        System.out.println("路由表条目: " + routingTable.size());
    }
}

# 4. 网络安全机制

# 4.1 多层安全防护

graph TB
    subgraph "应用层安全 Application Security"
        AS1[API认证]
        AS2[数据加密]
        AS3[访问控制]
        AS4[审计日志]
    end
    
    subgraph "传输层安全 Transport Security"
        TS1[TLS/SSL]
        TS2[DTLS]
        TS3[VPN隧道]
        TS4[端到端加密]
    end
    
    subgraph "网络层安全 Network Security"
        NS1[IPSec]
        NS2[防火墙]
        NS3[入侵检测]
        NS4[流量分析]
    end
    
    subgraph "链路层安全 Link Security"
        LS1[WPA3]
        LS2[802.1X]
        LS3[MAC过滤]
        LS4[VLAN隔离]
    end
    
    subgraph "物理层安全 Physical Security"
        PS1[信号加密]
        PS2[频谱跳跃]
        PS3[功率控制]
        PS4[物理隔离]
    end
    
    AS1 --> TS1
    AS2 --> TS2
    AS3 --> TS3
    AS4 --> TS4
    
    TS1 --> NS1
    TS2 --> NS2
    TS3 --> NS3
    TS4 --> NS4
    
    NS1 --> LS1
    NS2 --> LS2
    NS3 --> LS3
    NS4 --> LS4
    
    LS1 --> PS1
    LS2 --> PS2
    LS3 --> PS3
    LS4 --> PS4

# 4.2 网络安全管理器

// 示例：综合网络安全管理器
public class NetworkSecurityManager {
    
    private final CertificateManager certificateManager;
    private final EncryptionService encryptionService;
    private final AccessControlService accessControl;
    private final IntrusionDetectionSystem ids;
    private final AuditLogger auditLogger;
    
    public NetworkSecurityManager() {
        this.certificateManager = new CertificateManager();
        this.encryptionService = new EncryptionService();
        this.accessControl = new AccessControlService();
        this.ids = new IntrusionDetectionSystem();
        this.auditLogger = new AuditLogger();
    }
    
    // 设备认证
    public class DeviceAuthentication {
        
        public AuthenticationResult authenticateDevice(String deviceId, 
                X509Certificate deviceCert, byte[] challenge, byte[] signature) {
            
            try {
                // 1. 验证设备证书
                if (!certificateManager.validateCertificate(deviceCert)) {
                    auditLogger.logSecurityEvent("CERT_VALIDATION_FAILED", deviceId);
                    return AuthenticationResult.CERTIFICATE_INVALID;
                }
                
                // 2. 验证设备身份
                if (!verifyDeviceIdentity(deviceId, deviceCert)) {
                    auditLogger.logSecurityEvent("IDENTITY_MISMATCH", deviceId);
                    return AuthenticationResult.IDENTITY_MISMATCH;
                }
                
                // 3. 验证挑战响应
                if (!verifyChallenge(deviceCert.getPublicKey(), challenge, signature)) {
                    auditLogger.logSecurityEvent("CHALLENGE_FAILED", deviceId);
                    return AuthenticationResult.CHALLENGE_FAILED;
                }
                
                // 4. 检查访问权限
                if (!accessControl.hasAccess(deviceId)) {
                    auditLogger.logSecurityEvent("ACCESS_DENIED", deviceId);
                    return AuthenticationResult.ACCESS_DENIED;
                }
                
                // 5. 生成会话密钥
                String sessionKey = generateSessionKey(deviceId);
                
                auditLogger.logSecurityEvent("AUTH_SUCCESS", deviceId);
                return AuthenticationResult.success(sessionKey);
                
            } catch (Exception e) {
                auditLogger.logSecurityEvent("AUTH_ERROR", deviceId, e.getMessage());
                return AuthenticationResult.ERROR;
            }
        }
        
        private boolean verifyDeviceIdentity(String deviceId, X509Certificate cert) {
            // 从证书中提取设备ID并验证
            String certDeviceId = extractDeviceIdFromCert(cert);
            return deviceId.equals(certDeviceId);
        }
        
        private boolean verifyChallenge(PublicKey publicKey, byte[] challenge, byte[] signature) {
            try {
                Signature sig = Signature.getInstance("SHA256withRSA");
                sig.initVerify(publicKey);
                sig.update(challenge);
                return sig.verify(signature);
            } catch (Exception e) {
                return false;
            }
        }
        
        private String generateSessionKey(String deviceId) {
            // 生成会话密钥
            return encryptionService.generateSessionKey(deviceId);
        }
    }
    
    // 数据加密服务
    public class EncryptionService {
        private final Map<String, SecretKey> sessionKeys = new ConcurrentHashMap<>();
        
        public String generateSessionKey(String deviceId) {
            try {
                KeyGenerator keyGen = KeyGenerator.getInstance("AES");
                keyGen.init(256);
                SecretKey sessionKey = keyGen.generateKey();
                
                sessionKeys.put(deviceId, sessionKey);
                
                // 返回Base64编码的密钥
                return Base64.getEncoder().encodeToString(sessionKey.getEncoded());
            } catch (Exception e) {
                throw new RuntimeException("Failed to generate session key", e);
            }
        }
        
        public byte[] encryptData(String deviceId, byte[] data) {
            SecretKey key = sessionKeys.get(deviceId);
            if (key == null) {
                throw new IllegalStateException("No session key for device: " + deviceId);
            }
            
            try {
                Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                
                byte[] iv = cipher.getIV();
                byte[] encrypted = cipher.doFinal(data);
                
                // 将IV和加密数据组合
                byte[] result = new byte[iv.length + encrypted.length];
                System.arraycopy(iv, 0, result, 0, iv.length);
                System.arraycopy(encrypted, 0, result, iv.length, encrypted.length);
                
                return result;
            } catch (Exception e) {
                throw new RuntimeException("Encryption failed", e);
            }
        }
        
        public byte[] decryptData(String deviceId, byte[] encryptedData) {
            SecretKey key = sessionKeys.get(deviceId);
            if (key == null) {
                throw new IllegalStateException("No session key for device: " + deviceId);
            }
            
            try {
                // 提取IV和加密数据
                byte[] iv = new byte[12]; // GCM IV长度
                byte[] encrypted = new byte[encryptedData.length - 12];
                
                System.arraycopy(encryptedData, 0, iv, 0, 12);
                System.arraycopy(encryptedData, 12, encrypted, 0, encrypted.length);
                
                Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
                GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv);
                cipher.init(Cipher.DECRYPT_MODE, key, gcmSpec);
                
                return cipher.doFinal(encrypted);
            } catch (Exception e) {
                throw new RuntimeException("Decryption failed", e);
            }
        }
    }
    
    // 入侵检测系统
    public class IntrusionDetectionSystem {
        private final Map<String, DeviceProfile> deviceProfiles = new ConcurrentHashMap<>();
        private final Map<String, List<SecurityEvent>> recentEvents = new ConcurrentHashMap<>();
        
        private static class DeviceProfile {
            final String deviceId;
            final Set<String> normalBehaviors;
            final Map<String, Integer> trafficPatterns;
            long lastUpdate;
            
            public DeviceProfile(String deviceId) {
                this.deviceId = deviceId;
                this.normalBehaviors = new HashSet<>();
                this.trafficPatterns = new HashMap<>();
                this.lastUpdate = System.currentTimeMillis();
            }
        }
        
        private static class SecurityEvent {
            final String eventType;
            final String deviceId;
            final long timestamp;
            final String details;
            
            public SecurityEvent(String eventType, String deviceId, String details) {
                this.eventType = eventType;
                this.deviceId = deviceId;
                this.timestamp = System.currentTimeMillis();
                this.details = details;
            }
        }
        
        public void analyzeTraffic(String deviceId, String protocol, int packetSize, String destination) {
            // 更新设备行为档案
            updateDeviceProfile(deviceId, protocol, packetSize, destination);
            
            // 检测异常行为
            List<String> anomalies = detectAnomalies(deviceId, protocol, packetSize, destination);
            
            // 记录安全事件
            for (String anomaly : anomalies) {
                recordSecurityEvent("ANOMALY_DETECTED", deviceId, anomaly);
            }
        }
        
        private void updateDeviceProfile(String deviceId, String protocol, int packetSize, String destination) {
            DeviceProfile profile = deviceProfiles.computeIfAbsent(deviceId, DeviceProfile::new);
            
            // 记录正常行为
            String behavior = protocol + ":" + destination;
            profile.normalBehaviors.add(behavior);
            
            // 更新流量模式
            String trafficKey = protocol + "_size";
            profile.trafficPatterns.merge(trafficKey, packetSize, Integer::sum);
            
            profile.lastUpdate = System.currentTimeMillis();
        }
        
        private List<String> detectAnomalies(String deviceId, String protocol, int packetSize, String destination) {
            List<String> anomalies = new ArrayList<>();
            DeviceProfile profile = deviceProfiles.get(deviceId);
            
            if (profile == null) {
                return anomalies; // 新设备，暂无基线
            }
            
            // 检测异常目标
            String behavior = protocol + ":" + destination;
            if (!profile.normalBehaviors.contains(behavior)) {
                anomalies.add("Unusual destination: " + destination);
            }
            
            // 检测异常包大小
            String trafficKey = protocol + "_size";
            Integer avgSize = profile.trafficPatterns.get(trafficKey);
            if (avgSize != null && Math.abs(packetSize - avgSize) > avgSize * 0.5) {
                anomalies.add("Unusual packet size: " + packetSize + " (avg: " + avgSize + ")");
            }
            
            // 检测频率异常
            if (isHighFrequencyAttack(deviceId)) {
                anomalies.add("High frequency traffic detected");
            }
            
            return anomalies;
        }
        
        private boolean isHighFrequencyAttack(String deviceId) {
            List<SecurityEvent> events = recentEvents.get(deviceId);
            if (events == null) return false;
            
            long currentTime = System.currentTimeMillis();
            long oneMinuteAgo = currentTime - 60000;
            
            long recentEventCount = events.stream()
                .filter(event -> event.timestamp > oneMinuteAgo)
                .count();
            
            return recentEventCount > 100; // 每分钟超过100个事件
        }
        
        private void recordSecurityEvent(String eventType, String deviceId, String details) {
            SecurityEvent event = new SecurityEvent(eventType, deviceId, details);
            
            recentEvents.computeIfAbsent(deviceId, k -> new ArrayList<>()).add(event);
            
            // 清理旧事件
            cleanupOldEvents(deviceId);
            
            // 记录到审计日志
            auditLogger.logSecurityEvent(eventType, deviceId, details);
            
            // 触发告警
            if ("ANOMALY_DETECTED".equals(eventType)) {
                triggerSecurityAlert(deviceId, details);
            }
        }
        
        private void cleanupOldEvents(String deviceId) {
            List<SecurityEvent> events = recentEvents.get(deviceId);
            if (events != null) {
                long oneHourAgo = System.currentTimeMillis() - 3600000;
                events.removeIf(event -> event.timestamp < oneHourAgo);
            }
        }
        
        private void triggerSecurityAlert(String deviceId, String details) {
            System.out.println("🚨 安全告警: 设备 " + deviceId + " - " + details);
            // 这里可以集成告警系统，发送邮件、短信等
        }
    }
    
    // 访问控制服务
    public class AccessControlService {
        private final Map<String, DevicePermissions> devicePermissions = new ConcurrentHashMap<>();
        
        private static class DevicePermissions {
            final Set<String> allowedOperations;
            final Set<String> allowedResources;
            final long expiryTime;
            
            public DevicePermissions(Set<String> operations, Set<String> resources, long expiryTime) {
                this.allowedOperations = new HashSet<>(operations);
                this.allowedResources = new HashSet<>(resources);
                this.expiryTime = expiryTime;
            }
            
            public boolean isExpired() {
                return System.currentTimeMillis() > expiryTime;
            }
        }
        
        public void grantAccess(String deviceId, Set<String> operations, Set<String> resources, long durationMs) {
            long expiryTime = System.currentTimeMillis() + durationMs;
            DevicePermissions permissions = new DevicePermissions(operations, resources, expiryTime);
            devicePermissions.put(deviceId, permissions);
            
            auditLogger.logSecurityEvent("ACCESS_GRANTED", deviceId, 
                "Operations: " + operations + ", Resources: " + resources);
        }
        
        public void revokeAccess(String deviceId) {
            devicePermissions.remove(deviceId);
            auditLogger.logSecurityEvent("ACCESS_REVOKED", deviceId);
        }
        
        public boolean hasAccess(String deviceId) {
            DevicePermissions permissions = devicePermissions.get(deviceId);
            if (permissions == null || permissions.isExpired()) {
                return false;
            }
            return true;
        }
        
        public boolean canPerformOperation(String deviceId, String operation) {
            DevicePermissions permissions = devicePermissions.get(deviceId);
            if (permissions == null || permissions.isExpired()) {
                return false;
            }
            return permissions.allowedOperations.contains(operation);
        }
        
        public boolean canAccessResource(String deviceId, String resource) {
            DevicePermissions permissions = devicePermissions.get(deviceId);
            if (permissions == null || permissions.isExpired()) {
                return false;
            }
            return permissions.allowedResources.contains(resource);
        }
    }
    
    // 审计日志服务
    public class AuditLogger {
        private final BlockingQueue<AuditEvent> eventQueue = new LinkedBlockingQueue<>();
        private final ExecutorService logProcessor = Executors.newSingleThreadExecutor();
        
        private static class AuditEvent {
            final String eventType;
            final String deviceId;
            final String details;
            final long timestamp;
            final String sourceIp;
            
            public AuditEvent(String eventType, String deviceId, String details, String sourceIp) {
                this.eventType = eventType;
                this.deviceId = deviceId;
                this.details = details;
                this.timestamp = System.currentTimeMillis();
                this.sourceIp = sourceIp;
            }
        }
        
        public AuditLogger() {
            // 启动日志处理线程
            logProcessor.submit(this::processAuditEvents);
        }
        
        public void logSecurityEvent(String eventType, String deviceId) {
            logSecurityEvent(eventType, deviceId, null);
        }
        
        public void logSecurityEvent(String eventType, String deviceId, String details) {
            String sourceIp = getCurrentSourceIp();
            AuditEvent event = new AuditEvent(eventType, deviceId, details, sourceIp);
            
            try {
                eventQueue.put(event);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        private void processAuditEvents() {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    AuditEvent event = eventQueue.take();
                    writeAuditLog(event);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
        
        private void writeAuditLog(AuditEvent event) {
            // 写入审计日志
            String logEntry = String.format(
                "%s [%s] Device: %s, Event: %s, Details: %s, Source: %s",
                new Date(event.timestamp),
                event.eventType,
                event.deviceId,
                event.eventType,
                event.details != null ? event.details : "N/A",
                event.sourceIp
            );
            
            System.out.println("AUDIT: " + logEntry);
            
            // 这里可以写入文件、数据库或发送到日志服务器
        }
        
        private String getCurrentSourceIp() {
            // 获取当前请求的源IP
            return "127.0.0.1"; // 简化实现
        }
    }
    
    // 认证结果枚举
    public enum AuthenticationResult {
        SUCCESS,
        CERTIFICATE_INVALID,
        IDENTITY_MISMATCH,
        CHALLENGE_FAILED,
        ACCESS_DENIED,
        ERROR;
        
        private String sessionKey;
        
        public static AuthenticationResult success(String sessionKey) {
            AuthenticationResult result = SUCCESS;
            result.sessionKey = sessionKey;
            return result;
        }
        
        public String getSessionKey() {
            return sessionKey;
        }
        
        public boolean isSuccess() {
            return this == SUCCESS;
        }
    }
}

# 5. QoS保障策略

# 5.1 流量分类与优先级

// 示例：QoS流量管理器
public class QoSTrafficManager {
    
    public enum TrafficClass {
        CRITICAL(1, "关键控制流量"),
        HIGH(2, "高优先级数据"),
        NORMAL(3, "普通业务流量"),
        LOW(4, "后台数据传输"),
        BEST_EFFORT(5, "尽力而为");
        
        private final int priority;
        private final String description;
        
        TrafficClass(int priority, String description) {
            this.priority = priority;
            this.description = description;
        }
        
        public int getPriority() { return priority; }
        public String getDescription() { return description; }
    }
    
    private static class TrafficFlow {
        final String flowId;
        final String sourceId;
        final String destinationId;
        final TrafficClass trafficClass;
        final int bandwidthRequirement; // Kbps
        final int latencyRequirement;   // ms
        final double packetLossThreshold; // %
        long lastPacketTime;
        int currentBandwidth;
        int currentLatency;
        double currentPacketLoss;
        
        public TrafficFlow(String flowId, String sourceId, String destinationId,
                TrafficClass trafficClass, int bandwidthReq, int latencyReq, double lossThreshold) {
            this.flowId = flowId;
            this.sourceId = sourceId;
            this.destinationId = destinationId;
            this.trafficClass = trafficClass;
            this.bandwidthRequirement = bandwidthReq;
            this.latencyRequirement = latencyReq;
            this.packetLossThreshold = lossThreshold;
            this.lastPacketTime = System.currentTimeMillis();
        }
    }
    
    private final Map<String, TrafficFlow> activeFlows = new ConcurrentHashMap<>();
    private final PriorityQueue<TrafficFlow> transmissionQueue;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    private final AtomicInteger totalBandwidth = new AtomicInteger(1000); // 1Mbps总带宽
    private final Map<TrafficClass, Integer> bandwidthAllocation = new HashMap<>();
    
    public QoSTrafficManager() {
        // 按优先级排序的传输队列
        this.transmissionQueue = new PriorityQueue<>(
            Comparator.comparing((TrafficFlow f) -> f.trafficClass.getPriority())
                     .thenComparing(f -> f.lastPacketTime)
        );
        
        // 初始化带宽分配
        initializeBandwidthAllocation();
        
        // 启动QoS监控
        startQoSMonitoring();
    }
    
    private void initializeBandwidthAllocation() {
        // 按优先级分配带宽百分比
        bandwidthAllocation.put(TrafficClass.CRITICAL, 30);    // 30%
        bandwidthAllocation.put(TrafficClass.HIGH, 25);        // 25%
        bandwidthAllocation.put(TrafficClass.NORMAL, 25);      // 25%
        bandwidthAllocation.put(TrafficClass.LOW, 15);         // 15%
        bandwidthAllocation.put(TrafficClass.BEST_EFFORT, 5);  // 5%
    }
    
    public String createTrafficFlow(String sourceId, String destinationId,
            TrafficClass trafficClass, int bandwidthReq, int latencyReq, double lossThreshold) {
        
        String flowId = generateFlowId(sourceId, destinationId);
        TrafficFlow flow = new TrafficFlow(flowId, sourceId, destinationId,
            trafficClass, bandwidthReq, latencyReq, lossThreshold);
        
        activeFlows.put(flowId, flow);
        
        // 检查资源可用性
        if (!checkResourceAvailability(flow)) {
            System.out.println("警告：流量 " + flowId + " 资源不足，可能影响QoS");
        }
        
        return flowId;
    }
    
    public boolean transmitPacket(String flowId, byte[] packet) {
        TrafficFlow flow = activeFlows.get(flowId);
        if (flow == null) {
            return false;
        }
        
        // 更新流量统计
        updateFlowStatistics(flow, packet.length);
        
        // 检查QoS要求
        if (!meetsQoSRequirements(flow)) {
            // 尝试调整QoS策略
            adjustQoSPolicy(flow);
        }
        
        // 加入传输队列
        synchronized (transmissionQueue) {
            transmissionQueue.offer(flow);
            transmissionQueue.notifyAll();
        }
        
        return true;
    }
    
    private boolean checkResourceAvailability(TrafficFlow flow) {
        // 检查带宽可用性
        int allocatedBandwidth = bandwidthAllocation.get(flow.trafficClass) * totalBandwidth.get() / 100;
        
        // 计算同类流量的总需求
        int totalRequirement = activeFlows.values().stream()
            .filter(f -> f.trafficClass == flow.trafficClass)
            .mapToInt(f -> f.bandwidthRequirement)
            .sum();
        
        return totalRequirement <= allocatedBandwidth;
    }
    
    private void updateFlowStatistics(TrafficFlow flow, int packetSize) {
        long currentTime = System.currentTimeMillis();
        
        // 更新带宽使用
        if (flow.lastPacketTime > 0) {
            long timeDiff = currentTime - flow.lastPacketTime;
            if (timeDiff > 0) {
                flow.currentBandwidth = (int)(packetSize * 8 / (timeDiff / 1000.0) / 1000); // Kbps
            }
        }
        
        flow.lastPacketTime = currentTime;
    }
    
    private boolean meetsQoSRequirements(TrafficFlow flow) {
        // 检查延迟要求
        if (flow.currentLatency > flow.latencyRequirement) {
            return false;
        }
        
        // 检查丢包率要求
        if (flow.currentPacketLoss > flow.packetLossThreshold) {
            return false;
        }
        
        // 检查带宽要求
        if (flow.currentBandwidth < flow.bandwidthRequirement * 0.8) { // 允许20%的波动
            return false;
        }
        
        return true;
    }
    
    private void adjustQoSPolicy(TrafficFlow flow) {
        System.out.println("调整QoS策略: " + flow.flowId);
        
        // 根据流量类型调整策略
        switch (flow.trafficClass) {
            case CRITICAL:
                // 关键流量：增加带宽分配，降低其他流量优先级
                increaseBandwidthAllocation(flow.trafficClass, 5);
                break;
            case HIGH:
                // 高优先级：适度调整
                increaseBandwidthAllocation(flow.trafficClass, 3);
                break;
            default:
                // 其他流量：降低要求或延迟传输
                delayTransmission(flow);
                break;
        }
    }
    
    private void increaseBandwidthAllocation(TrafficClass trafficClass, int increasePercent) {
        int currentAllocation = bandwidthAllocation.get(trafficClass);
        int newAllocation = Math.min(currentAllocation + increasePercent, 50); // 最大50%
        
        bandwidthAllocation.put(trafficClass, newAllocation);
        
        // 从低优先级流量中减少带宽
        redistributeBandwidth(trafficClass, increasePercent);
    }
    
    private void redistributeBandwidth(TrafficClass excludeClass, int reduceAmount) {
        List<TrafficClass> lowerPriorityClasses = Arrays.stream(TrafficClass.values())
            .filter(tc -> tc.getPriority() > excludeClass.getPriority())
            .sorted(Comparator.comparing(TrafficClass::getPriority).reversed())
            .collect(Collectors.toList());
        
        int remainingReduction = reduceAmount;
        for (TrafficClass tc : lowerPriorityClasses) {
            if (remainingReduction <= 0) break;
            
            int currentAllocation = bandwidthAllocation.get(tc);
            int reduction = Math.min(remainingReduction, currentAllocation / 2); // 最多减少50%
            
            bandwidthAllocation.put(tc, currentAllocation - reduction);
            remainingReduction -= reduction;
        }
    }
    
    private void delayTransmission(TrafficFlow flow) {
        // 延迟低优先级流量的传输
        scheduler.schedule(() -> {
            synchronized (transmissionQueue) {
                transmissionQueue.offer(flow);
                transmissionQueue.notifyAll();
            }
        }, 100, TimeUnit.MILLISECONDS);
    }
    
    private void startQoSMonitoring() {
        // 定期监控QoS指标
        scheduler.scheduleAtFixedRate(this::monitorQoSMetrics, 1, 1, TimeUnit.SECONDS);
        
        // 定期调整带宽分配
        scheduler.scheduleAtFixedRate(this::rebalanceBandwidth, 10, 10, TimeUnit.SECONDS);
    }
    
    private void monitorQoSMetrics() {
        for (TrafficFlow flow : activeFlows.values()) {
            // 模拟延迟测量
            flow.currentLatency = measureLatency(flow);
            
            // 模拟丢包率测量
            flow.currentPacketLoss = measurePacketLoss(flow);
            
            // 检查SLA违规
            if (!meetsQoSRequirements(flow)) {
                System.out.printf("QoS违规: 流量%s, 延迟%dms(要求%dms), 丢包率%.2f%%(要求%.2f%%)\n",
                    flow.flowId, flow.currentLatency, flow.latencyRequirement,
                    flow.currentPacketLoss, flow.packetLossThreshold);
            }
        }
    }
    
    private int measureLatency(TrafficFlow flow) {
        // 简化的延迟测量
        int baseLatency = 10; // 基础延迟10ms
        int congestionLatency = (int)(Math.random() * 50); // 拥塞延迟0-50ms
        
        // 高优先级流量延迟更低
        int priorityFactor = flow.trafficClass.getPriority();
        return baseLatency + congestionLatency / priorityFactor;
    }
    
    private double measurePacketLoss(TrafficFlow flow) {
        // 简化的丢包率测量
        double baseLoss = 0.1; // 基础丢包率0.1%
        double congestionLoss = Math.random() * 2.0; // 拥塞丢包0-2%
        
        // 高优先级流量丢包率更低
        int priorityFactor = flow.trafficClass.getPriority();
        return (baseLoss + congestionLoss) / priorityFactor;
    }
    
    private void rebalanceBandwidth() {
        // 根据实际使用情况重新平衡带宽分配
        Map<TrafficClass, Integer> actualUsage = calculateActualBandwidthUsage();
        
        for (TrafficClass tc : TrafficClass.values()) {
            int allocated = bandwidthAllocation.get(tc);
            int actual = actualUsage.getOrDefault(tc, 0);
            
            // 如果实际使用率低于分配，可以释放给其他类型
            if (actual < allocated * 0.5) {
                int reduction = (allocated - actual) / 2;
                bandwidthAllocation.put(tc, allocated - reduction);
                
                // 将释放的带宽分配给需要的流量类型
                redistributeFreeBandwidth(reduction);
            }
        }
    }
    
    private Map<TrafficClass, Integer> calculateActualBandwidthUsage() {
        Map<TrafficClass, Integer> usage = new HashMap<>();
        
        for (TrafficFlow flow : activeFlows.values()) {
            usage.merge(flow.trafficClass, flow.currentBandwidth, Integer::sum);
        }
        
        return usage;
    }
    
    private void redistributeFreeBandwidth(int freeBandwidth) {
        // 将释放的带宽按需分配给其他流量类型
        List<TrafficClass> needMoreBandwidth = findTrafficClassesNeedingBandwidth();
        
        if (!needMoreBandwidth.isEmpty()) {
            int perClassIncrease = freeBandwidth / needMoreBandwidth.size();
            
            for (TrafficClass tc : needMoreBandwidth) {
                int current = bandwidthAllocation.get(tc);
                bandwidthAllocation.put(tc, current + perClassIncrease);
            }
        }
    }
    
    private List<TrafficClass> findTrafficClassesNeedingBandwidth() {
        return activeFlows.values().stream()
            .filter(flow -> flow.currentBandwidth < flow.bandwidthRequirement)
            .map(flow -> flow.trafficClass)
            .distinct()
            .collect(Collectors.toList());
    }
    
    private String generateFlowId(String sourceId, String destinationId) {
        return sourceId + "-" + destinationId + "-" + System.currentTimeMillis();
    }
    
    public void printQoSStatus() {
        System.out.println("=== QoS状态报告 ===");
        System.out.println("总带宽: " + totalBandwidth.get() + " Kbps");
        
        System.out.println("\n带宽分配:");
        for (Map.Entry<TrafficClass, Integer> entry : bandwidthAllocation.entrySet()) {
            int allocated = entry.getValue() * totalBandwidth.get() / 100;
            System.out.printf("%s: %d%% (%d Kbps)\n", 
                entry.getKey().getDescription(), entry.getValue(), allocated);
        }
        
        System.out.println("\n活跃流量:");
        for (TrafficFlow flow : activeFlows.values()) {
            System.out.printf("流量 %s: %s -> %s, 类型=%s, 带宽=%d/%d Kbps, 延迟=%d/%d ms\n",
                flow.flowId, flow.sourceId, flow.destinationId, flow.trafficClass,
                flow.currentBandwidth, flow.bandwidthRequirement,
                flow.currentLatency, flow.latencyRequirement);
        }
    }
}

# 5.2 网络拥塞控制

// 示例：网络拥塞控制算法
public class CongestionController {
    
    public enum CongestionState {
        NORMAL,     // 正常状态
        WARNING,    // 警告状态
        CONGESTED,  // 拥塞状态
        CRITICAL    // 严重拥塞
    }
    
    private static class NetworkMetrics {
        double throughput;      // 吞吐量 (Mbps)
        double utilization;     // 利用率 (%)
        int queueLength;        // 队列长度
        double packetLoss;      // 丢包率 (%)
        int averageDelay;       // 平均延迟 (ms)
        long timestamp;
        
        public NetworkMetrics(double throughput, double utilization, 
                int queueLength, double packetLoss, int averageDelay) {
            this.throughput = throughput;
            this.utilization = utilization;
            this.queueLength = queueLength;
            this.packetLoss = packetLoss;
            this.averageDelay = averageDelay;
            this.timestamp = System.currentTimeMillis();
        }
    }
    
    private final Queue<NetworkMetrics> metricsHistory = new LinkedList<>();
    private final int maxHistorySize = 100;
    private CongestionState currentState = CongestionState.NORMAL;
    private final Map<String, Double> flowRates = new ConcurrentHashMap<>();
    
    public CongestionState detectCongestion(NetworkMetrics metrics) {
        // 添加到历史记录
        metricsHistory.offer(metrics);
        if (metricsHistory.size() > maxHistorySize) {
            metricsHistory.poll();
        }
        
        // 计算拥塞指标
        double congestionScore = calculateCongestionScore(metrics);
        
        // 确定拥塞状态
        CongestionState newState = determineCongestionState(congestionScore);
        
        // 状态变化时触发相应动作
        if (newState != currentState) {
            handleStateChange(currentState, newState);
            currentState = newState;
        }
        
        return currentState;
    }
    
    private double calculateCongestionScore(NetworkMetrics metrics) {
        // 综合评分算法
        double utilizationScore = Math.min(metrics.utilization / 80.0, 1.0) * 25;
        double lossScore = Math.min(metrics.packetLoss / 5.0, 1.0) * 30;
        double delayScore = Math.min(metrics.averageDelay / 200.0, 1.0) * 25;
        double queueScore = Math.min(metrics.queueLength / 100.0, 1.0) * 20;
        
        return utilizationScore + lossScore + delayScore + queueScore;
    }
    
    private CongestionState determineCongestionState(double score) {
        if (score >= 80) {
            return CongestionState.CRITICAL;
        } else if (score >= 60) {
            return CongestionState.CONGESTED;
        } else if (score >= 40) {
            return CongestionState.WARNING;
        } else {
            return CongestionState.NORMAL;
        }
    }
    
    private void handleStateChange(CongestionState oldState, CongestionState newState) {
        System.out.printf("拥塞状态变化: %s -> %s\n", oldState, newState);
        
        switch (newState) {
            case WARNING:
                // 预警措施
                implementEarlyWarning();
                break;
            case CONGESTED:
                // 拥塞控制
                implementCongestionControl();
                break;
            case CRITICAL:
                // 紧急措施
                implementEmergencyMeasures();
                break;
            case NORMAL:
                // 恢复正常
                restoreNormalOperation();
                break;
        }
    }
    
    private void implementEarlyWarning() {
        System.out.println("实施预警措施:");
        
        // 1. 降低非关键流量的发送速率
        reduceNonCriticalTraffic(0.9); // 降低到90%
        
        // 2. 增加缓冲区大小
        increaseBufferSize(1.2);
        
        // 3. 启用更积极的队列管理
        enableActiveQueueManagement();
    }
    
    private void implementCongestionControl() {
        System.out.println("实施拥塞控制:");
        
        // 1. 大幅降低非关键流量
        reduceNonCriticalTraffic(0.7); // 降低到70%
        
        // 2. 启用流量整形
        enableTrafficShaping();
        
        // 3. 丢弃低优先级数据包
        dropLowPriorityPackets();
        
        // 4. 通知发送端降低发送速率
        notifySendersToSlowDown();
    }
    
    private void implementEmergencyMeasures() {
        System.out.println("实施紧急措施:");
        
        // 1. 只允许关键流量通过
        allowOnlyCriticalTraffic();
        
        // 2. 启用紧急路由
        enableEmergencyRouting();
        
        // 3. 请求额外的网络资源
        requestAdditionalResources();
        
        // 4. 发送拥塞告警
        sendCongestionAlert();
    }
    
    private void restoreNormalOperation() {
        System.out.println("恢复正常运行:");
        
        // 1. 逐步恢复流量速率
        graduallyRestoreTrafficRates();
        
        // 2. 禁用紧急措施
        disableEmergencyMeasures();
        
        // 3. 重置缓冲区大小
        resetBufferSize();
    }
    
    // 具体的拥塞控制实现方法
    private void reduceNonCriticalTraffic(double factor) {
        for (Map.Entry<String, Double> entry : flowRates.entrySet()) {
            String flowId = entry.getKey();
            if (!isCriticalFlow(flowId)) {
                double newRate = entry.getValue() * factor;
                flowRates.put(flowId, newRate);
                System.out.printf("降低流量 %s 速率至 %.2f\n", flowId, newRate);
            }
        }
    }
    
    private boolean isCriticalFlow(String flowId) {
        // 判断是否为关键流量
        return flowId.contains("CRITICAL") || flowId.contains("EMERGENCY");
    }
    
    private void increaseBufferSize(double factor) {
        System.out.printf("增加缓冲区大小至 %.1f 倍\n", factor);
        // 实际实现中会调整网络设备的缓冲区配置
    }
    
    private void enableActiveQueueManagement() {
        System.out.println("启用主动队列管理 (AQM)");
        // 实现RED (Random Early Detection) 或其他AQM算法
    }
    
    private void enableTrafficShaping() {
        System.out.println("启用流量整形");
        // 实现令牌桶或漏桶算法
    }
    
    private void dropLowPriorityPackets() {
        System.out.println("丢弃低优先级数据包");
        // 实现选择性丢包策略
    }
    
    private void notifySendersToSlowDown() {
        System.out.println("通知发送端降低发送速率");
        // 发送拥塞通知消息
    }
    
    private void allowOnlyCriticalTraffic() {
        System.out.println("只允许关键流量通过");
        // 阻塞非关键流量
    }
    
    private void enableEmergencyRouting() {
        System.out.println("启用紧急路由");
        // 激活备用路径
    }
    
    private void requestAdditionalResources() {
        System.out.println("请求额外网络资源");
        // 向网络管理系统请求更多带宽
    }
    
    private void sendCongestionAlert() {
        System.out.println("发送拥塞告警");
        // 向监控系统发送告警
    }
    
    private void graduallyRestoreTrafficRates() {
        System.out.println("逐步恢复流量速率");
        // 缓慢增加流量速率，避免再次拥塞
    }
    
    private void disableEmergencyMeasures() {
        System.out.println("禁用紧急措施");
        // 关闭紧急模式
    }
    
    private void resetBufferSize() {
        System.out.println("重置缓冲区大小");
        // 恢复默认缓冲区配置
    }
}

# 6. 网络优化策略

# 6.1 自适应路由算法

// 示例：自适应路由算法实现
public class AdaptiveRoutingAlgorithm {
    
    private static class Link {
        final String linkId;
        final String sourceNode;
        final String targetNode;
        double bandwidth;        // 可用带宽 (Mbps)
        double latency;         // 延迟 (ms)
        double reliability;     // 可靠性 (0-1)
        double cost;           // 链路成本
        long lastUpdate;
        
        public Link(String linkId, String sourceNode, String targetNode,
                double bandwidth, double latency, double reliability, double cost) {
            this.linkId = linkId;
            this.sourceNode = sourceNode;
            this.targetNode = targetNode;
            this.bandwidth = bandwidth;
            this.latency = latency;
            this.reliability = reliability;
            this.cost = cost;
            this.lastUpdate = System.currentTimeMillis();
        }
        
        public double calculateMetric(RoutingCriteria criteria) {
            switch (criteria) {
                case SHORTEST_PATH:
                    return 1.0; // 跳数
                case LOWEST_LATENCY:
                    return latency;
                case HIGHEST_BANDWIDTH:
                    return 1.0 / bandwidth; // 倒数，使得带宽越高权重越小
                case HIGHEST_RELIABILITY:
                    return 1.0 - reliability;
                case LOWEST_COST:
                    return cost;
                case BALANCED:
                    // 综合指标
                    return (latency / 100.0) * 0.3 + 
                           (1.0 / bandwidth) * 0.3 + 
                           (1.0 - reliability) * 0.2 + 
                           (cost / 10.0) * 0.2;
                default:
                    return 1.0;
            }
        }
    }
    
    public enum RoutingCriteria {
        SHORTEST_PATH,
        LOWEST_LATENCY,
        HIGHEST_BANDWIDTH,
        HIGHEST_RELIABILITY,
        LOWEST_COST,
        BALANCED
    }
    
    private final Map<String, List<Link>> topology = new ConcurrentHashMap<>();
    private final Map<String, Map<String, List<String>>> routingCache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    
    public AdaptiveRoutingAlgorithm() {
        // 启动路由表更新任务
        scheduler.scheduleAtFixedRate(this::updateRoutingTables, 30, 30, TimeUnit.SECONDS);
    }
    
    public void addLink(String linkId, String sourceNode, String targetNode,
            double bandwidth, double latency, double reliability, double cost) {
        
        Link link = new Link(linkId, sourceNode, targetNode, bandwidth, latency, reliability, cost);
        
        // 添加正向链路
        topology.computeIfAbsent(sourceNode, k -> new ArrayList<>()).add(link);
        
        // 添加反向链路（假设链路是双向的）
        Link reverseLink = new Link(linkId + "_reverse", targetNode, sourceNode,
            bandwidth, latency, reliability, cost);
        topology.computeIfAbsent(targetNode, k -> new ArrayList<>()).add(reverseLink);
        
        // 清除相关的路由缓存
        invalidateRoutingCache(sourceNode, targetNode);
    }
    
    public List<String> findOptimalPath(String source, String destination, RoutingCriteria criteria) {
        // 检查缓存
        String cacheKey = criteria.name();
        Map<String, List<String>> sourceCache = routingCache.get(source);
        if (sourceCache != null) {
            List<String> cachedPath = sourceCache.get(destination + "_" + cacheKey);
            if (cachedPath != null) {
                return new ArrayList<>(cachedPath);
            }
        }
        
        // 使用Dijkstra算法计算最优路径
        List<String> path = dijkstraWithCriteria(source, destination, criteria);
        
        // 缓存结果
        cacheRoutingResult(source, destination, criteria, path);
        
        return path;
    }
    
    private List<String> dijkstraWithCriteria(String source, String destination, RoutingCriteria criteria) {
        Map<String, Double> distances = new HashMap<>();
        Map<String, String> previous = new HashMap<>();
        PriorityQueue<String> queue = new PriorityQueue<>(Comparator.comparing(distances::get));
        Set<String> visited = new HashSet<>();
        
        // 初始化距离
        for (String node : topology.keySet()) {
            distances.put(node, Double.MAX_VALUE);
        }
        distances.put(source, 0.0);
        queue.add(source);
        
        while (!queue.isEmpty()) {
            String current = queue.poll();
            
            if (visited.contains(current)) {
                continue;
            }
            visited.add(current);
            
            if (current.equals(destination)) {
                break;
            }
            
            List<Link> neighbors = topology.get(current);
            if (neighbors == null) continue;
            
            for (Link link : neighbors) {
                String neighbor = link.targetNode;
                if (visited.contains(neighbor)) continue;
                
                double linkMetric = link.calculateMetric(criteria);
                double newDistance = distances.get(current) + linkMetric;
                
                if (newDistance < distances.get(neighbor)) {
                    distances.put(neighbor, newDistance);
                    previous.put(neighbor, current);
                    queue.remove(neighbor);
                    queue.add(neighbor);
                }
            }
        }
        
        // 重建路径
        return reconstructPath(previous, source, destination);
    }
    
    private List<String> reconstructPath(Map<String, String> previous, String source, String destination) {
        List<String> path = new ArrayList<>();
        String current = destination;
        
        while (current != null) {
            path.add(0, current);
            current = previous.get(current);
        }
        
        return path.isEmpty() || !path.get(0).equals(source) ? Collections.emptyList() : path;
    }
    
    public List<String> findMultiplePaths(String source, String destination, 
            RoutingCriteria criteria, int maxPaths) {
        
        List<List<String>> allPaths = new ArrayList<>();
        Set<String> excludedLinks = new HashSet<>();
        
        for (int i = 0; i < maxPaths; i++) {
            List<String> path = findPathExcludingLinks(source, destination, criteria, excludedLinks);
            
            if (path.isEmpty()) {
                break; // 没有更多路径
            }
            
            allPaths.add(path);
            
            // 排除当前路径中的一条链路，以找到不同的路径
            if (path.size() > 1) {
                String linkToExclude = path.get(path.size() / 2) + "-" + path.get(path.size() / 2 + 1);
                excludedLinks.add(linkToExclude);
            }
        }
        
        // 返回最优路径
        return allPaths.isEmpty() ? Collections.emptyList() : allPaths.get(0);
    }
    
    private List<String> findPathExcludingLinks(String source, String destination,
            RoutingCriteria criteria, Set<String> excludedLinks) {
        
        // 临时移除被排除的链路
        Map<String, List<Link>> originalTopology = new HashMap<>();
        for (Map.Entry<String, List<Link>> entry : topology.entrySet()) {
            originalTopology.put(entry.getKey(), new ArrayList<>(entry.getValue()));
        }
        
        // 移除被排除的链路
        for (String excludedLink : excludedLinks) {
            String[] nodes = excludedLink.split("-");
            if (nodes.length == 2) {
                removeTemporaryLink(nodes[0], nodes[1]);
            }
        }
        
        // 计算路径
        List<String> path = dijkstraWithCriteria(source, destination, criteria);
        
        // 恢复拓扑
        topology.clear();
        topology.putAll(originalTopology);
        
        return path;
    }
    
    private void removeTemporaryLink(String source, String target) {
        List<Link> sourceLinks = topology.get(source);
        if (sourceLinks != null) {
            sourceLinks.removeIf(link -> link.targetNode.equals(target));
        }
    }
    
    private void cacheRoutingResult(String source, String destination, 
            RoutingCriteria criteria, List<String> path) {
        
        String cacheKey = destination + "_" + criteria.name();
        routingCache.computeIfAbsent(source, k -> new ConcurrentHashMap<>())
                   .put(cacheKey, new ArrayList<>(path));
    }
    
    private void invalidateRoutingCache(String sourceNode, String targetNode) {
        // 清除涉及这些节点的所有缓存条目
        routingCache.remove(sourceNode);
        routingCache.remove(targetNode);
        
        // 清除其他节点到这些节点的缓存
        for (Map<String, List<String>> cache : routingCache.values()) {
            cache.entrySet().removeIf(entry -> 
                entry.getKey().startsWith(sourceNode + "_") || 
                entry.getKey().startsWith(targetNode + "_"));
        }
    }
    
    private void updateRoutingTables() {
        System.out.println("更新路由表...");
        
        // 更新链路状态
        updateLinkStates();
        
        // 清除过期的缓存
        clearExpiredCache();
        
        // 预计算常用路径
        precomputeCommonPaths();
    }
    
    private void updateLinkStates() {
        for (List<Link> links : topology.values()) {
            for (Link link : links) {
                // 模拟链路状态更新
                updateLinkMetrics(link);
            }
        }
    }
    
    private void updateLinkMetrics(Link link) {
        // 模拟实时链路指标更新
        link.bandwidth = Math.max(0.1, link.bandwidth + (Math.random() - 0.5) * 0.2);
        link.latency = Math.max(1.0, link.latency + (Math.random() - 0.5) * 10);
        link.reliability = Math.max(0.1, Math.min(1.0, link.reliability + (Math.random() - 0.5) * 0.1));
        link.lastUpdate = System.currentTimeMillis();
    }
    
    private void clearExpiredCache() {
        // 清除超过5分钟的缓存
        long expiryTime = System.currentTimeMillis() - 300000;
        
        routingCache.entrySet().removeIf(entry -> {
            // 这里简化处理，实际应该检查每个缓存项的时间戳
            return false; // 暂不实现过期逻辑
        });
    }
    
    private void precomputeCommonPaths() {
        // 预计算一些常用的路径组合
        List<String> commonNodes = topology.keySet().stream()
            .limit(5) // 只处理前5个节点
            .collect(Collectors.toList());
        
        for (String source : commonNodes) {
            for (String destination : commonNodes) {
                if (!source.equals(destination)) {
                    findOptimalPath(source, destination, RoutingCriteria.BALANCED);
                }
            }
        }
    }
    
    public void printTopologyStatus() {
        System.out.println("=== 网络拓扑状态 ===");
        
        for (Map.Entry<String, List<Link>> entry : topology.entrySet()) {
            String node = entry.getKey();
            List<Link> links = entry.getValue();
            
            System.out.printf("节点 %s (%d 条链路):\n", node, links.size());
            
            for (Link link : links) {
                System.out.printf("  -> %s: 带宽=%.1fMbps, 延迟=%.1fms, 可靠性=%.2f, 成本=%.1f\n",
                    link.targetNode, link.bandwidth, link.latency, link.reliability, link.cost);
            }
        }
        
        System.out.println("\n缓存统计:");
        int totalCacheEntries = routingCache.values().stream()
            .mapToInt(Map::size)
            .sum();
        System.out.println("缓存条目总数: " + totalCacheEntries);
    }
}

# 7. 最佳实践总结

# 7.1 设计原则

分层设计：采用分层网络架构，每层专注特定功能
冗余备份：关键路径和节点要有备份方案
自适应性：网络能够根据条件变化自动调整
安全优先：在设计阶段就考虑安全防护
可扩展性：支持网络规模的平滑扩展

# 7.2 开发建议

协议选择：根据应用场景选择合适的通信协议
QoS保障：为不同类型的流量提供差异化服务
监控告警：建立完善的网络监控和告警机制
性能优化：持续优化网络性能和资源利用率
故障恢复：设计快速的故障检测和恢复机制

# 8. 下一步学习

协议适配层：学习如何适配不同的通信协议
设备管理层：了解设备接入和管理机制
数据处理层：掌握数据收集和处理技术
应用服务层：学习业务逻辑的实现方式

Jeskson-微服务分布式

Choose mode

网络通信层

# 网络通信层

# 📖 章节概述

# 🎯 学习目标

# 1. 网络架构概览

# 1.1 分层网络架构

# 1.2 网络拓扑类型

# 2. 通信协议栈

# 2.1 协议分层模型

# 2.2 协议选择决策树

# 3. 网络拓扑设计

# 3.1 自适应网络拓扑

# 4. 网络安全机制

# 4.1 多层安全防护

# 4.2 网络安全管理器

# 5. QoS保障策略

# 5.1 流量分类与优先级

# 5.2 网络拥塞控制

# 6. 网络优化策略

# 6.1 自适应路由算法

# 7. 最佳实践总结

# 7.1 设计原则

# 7.2 开发建议

# 8. 下一步学习