第95集网络带宽运维监控与优化实战

1. 网络带宽运维监控概述

网络带宽是系统性能的关键指标，带宽不足会导致网络拥塞、延迟增加。本文将详细介绍带宽监控、流量分析、网络优化、QoS管理的完整解决方案，帮助运维人员有效管理网络带宽。

1.1 核心挑战

带宽监控: 实时监控网络带宽使用情况
流量分析: 分析网络流量模式和趋势
网络优化: 优化网络配置和路由策略
QoS管理: 管理网络服务质量
故障诊断: 快速定位网络问题

1.2 技术架构

带宽监控 → 数据采集 → 流量分析 → 告警通知 → 自动优化
   ↓        ↓         ↓         ↓         ↓
网络指标 → 监控代理 → 数据存储 → 告警引擎 → 调优脚本
   ↓        ↓         ↓         ↓         ↓
QoS管理 → 流量控制 → 路由优化 → 自动修复 → 性能报告

2. 带宽监控系统

2.1 Maven依赖配置

<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Boot Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- Micrometer监控 -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>
    
    <!-- MyBatis Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.2</version>
    </dependency>
    
    <!-- OSHI系统信息 -->
    <dependency>
        <groupId>com.github.oshi</groupId>
        <artifactId>oshi-core</artifactId>
        <version>6.4.0</version>
    </dependency>
</dependencies>

2.2 应用配置

# application.yml
server:
  port: 8080

spring:
  redis:
    host: localhost
    port: 6379
    database: 0

# 带宽监控配置
bandwidth-monitor:
  collection-interval: 5000         # 采集间隔(毫秒)
  bandwidth-threshold: 80           # 带宽使用率告警阈值(%)
  latency-threshold: 100           # 延迟告警阈值(毫秒)
  packet-loss-threshold: 5          # 丢包率告警阈值(%)
  qos-enabled: true                # 启用QoS管理

3. 带宽监控服务

3.1 带宽监控实体类

/**
 * 带宽监控数据实体类
 */
@Data
@TableName("bandwidth_monitor_data")
public class BandwidthMonitorData {
    
    @TableId(type = IdType.AUTO)
    private Long id;                    // 主键ID
    
    private String hostname;             // 主机名
    
    private String ip;                   // IP地址
    
    private String interfaceName;        // 网络接口名称
    
    private Long bytesReceived;          // 接收字节数
    
    private Long bytesSent;              // 发送字节数
    
    private Long packetsReceived;        // 接收包数
    
    private Long packetsSent;            // 发送包数
    
    private Long errorsReceived;         // 接收错误数
    
    private Long errorsSent;             // 发送错误数
    
    private Long dropsReceived;          // 接收丢包数
    
    private Long dropsSent;              // 发送丢包数
    
    private Double bandwidthUsage;       // 带宽使用率
    
    private Double latency;              // 网络延迟
    
    private Double packetLossRate;       // 丢包率
    
    private String networkStatus;        // 网络状态
    
    private Date collectTime;            // 采集时间
    
    private Date createTime;             // 创建时间
}

3.2 带宽监控服务

/**
 * 带宽监控服务
 * 负责网络带宽数据的采集、存储和分析
 */
@Service
public class BandwidthMonitorService {

    @Autowired
    private BandwidthMonitorDataMapper bandwidthMonitorDataMapper;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private AlertService alertService;
    
    private SystemInfo systemInfo = new SystemInfo();
    private Map<String, NetworkStats> previousStats = new HashMap<>();

    /**
     * 采集带宽数据
     * 定期采集网络带宽使用情况
     */
    @Scheduled(fixedRate = 5000) // 每5秒执行一次
    public void collectBandwidthData() {
        try {
            // 1. 获取网络接口信息
            List<NetworkIF> networkIFs = systemInfo.getHardware().getNetworkIFs();
            
            for (NetworkIF networkIF : networkIFs) {
                try {
                    // 2. 创建带宽监控数据
                    BandwidthMonitorData monitorData = createBandwidthMonitorData(networkIF);
                    
                    // 3. 保存到数据库
                    bandwidthMonitorDataMapper.insert(monitorData);
                    
                    // 4. 更新缓存
                    updateBandwidthCache(monitorData);
                    
                    // 5. 检查带宽告警
                    checkBandwidthAlert(monitorData);
                    
                    log.debug("采集带宽数据: interface={}, bandwidthUsage={}%", 
                            monitorData.getInterfaceName(), monitorData.getBandwidthUsage());
                            
                } catch (Exception e) {
                    log.error("处理网络接口失败: interface={}, error={}", 
                            networkIF.getName(), e.getMessage());
                }
            }
            
        } catch (Exception e) {
            log.error("采集带宽数据失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 创建带宽监控数据
     */
    private BandwidthMonitorData createBandwidthMonitorData(NetworkIF networkIF) {
        BandwidthMonitorData monitorData = new BandwidthMonitorData();
        
        // 设置基本信息
        monitorData.setHostname(getHostname());
        monitorData.setIp(getLocalIpAddress());
        monitorData.setInterfaceName(networkIF.getName());
        monitorData.setCollectTime(new Date());
        monitorData.setCreateTime(new Date());
        
        // 设置网络统计信息
        setNetworkStats(monitorData, networkIF);
        
        // 计算带宽使用率
        calculateBandwidthUsage(monitorData, networkIF);
        
        // 计算网络延迟
        calculateLatency(monitorData);
        
        // 计算丢包率
        calculatePacketLossRate(monitorData);
        
        // 设置网络状态
        setNetworkStatus(monitorData);
        
        return monitorData;
    }

    /**
     * 设置网络统计信息
     */
    private void setNetworkStats(BandwidthMonitorData monitorData, NetworkIF networkIF) {
        try {
            // 更新网络接口统计信息
            networkIF.updateNetworkStats();
            
            // 设置接收和发送的字节数
            monitorData.setBytesReceived(networkIF.getBytesRecv());
            monitorData.setBytesSent(networkIF.getBytesSent());
            
            // 设置接收和发送的包数
            monitorData.setPacketsReceived(networkIF.getPacketsRecv());
            monitorData.setPacketsSent(networkIF.getPacketsSent());
            
            // 设置接收和发送的错误数
            monitorData.setErrorsReceived(networkIF.getInErrors());
            monitorData.setErrorsSent(networkIF.getOutErrors());
            
            // 设置接收和发送的丢包数
            monitorData.setDropsReceived(networkIF.getInDrops());
            monitorData.setDropsSent(networkIF.getOutDrops());
            
        } catch (Exception e) {
            log.error("设置网络统计信息失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 计算带宽使用率
     */
    private void calculateBandwidthUsage(BandwidthMonitorData monitorData, NetworkIF networkIF) {
        try {
            String interfaceName = networkIF.getName();
            NetworkStats previousStat = previousStats.get(interfaceName);
            
            if (previousStat != null) {
                // 计算时间间隔（秒）
                long timeInterval = 5; // 5秒采集间隔
                
                // 计算字节数差值
                long bytesReceivedDiff = monitorData.getBytesReceived() - previousStat.getBytesReceived();
                long bytesSentDiff = monitorData.getBytesSent() - previousStat.getBytesSent();
                
                // 计算总字节数
                long totalBytesDiff = bytesReceivedDiff + bytesSentDiff;
                
                // 计算带宽使用率（假设网络接口速度为1Gbps）
                long interfaceSpeed = 1000000000L; // 1Gbps = 1,000,000,000 bps
                double bandwidthUsage = (double) totalBytesDiff * 8 / timeInterval / interfaceSpeed * 100;
                
                monitorData.setBandwidthUsage(Math.min(bandwidthUsage, 100.0));
            } else {
                monitorData.setBandwidthUsage(0.0);
            }
            
            // 更新历史统计信息
            NetworkStats currentStat = new NetworkStats();
            currentStat.setBytesReceived(monitorData.getBytesReceived());
            currentStat.setBytesSent(monitorData.getBytesSent());
            currentStat.setPacketsReceived(monitorData.getPacketsReceived());
            currentStat.setPacketsSent(monitorData.getPacketsSent());
            currentStat.setTimestamp(System.currentTimeMillis());
            
            previousStats.put(interfaceName, currentStat);
            
        } catch (Exception e) {
            log.error("计算带宽使用率失败: {}", e.getMessage(), e);
            monitorData.setBandwidthUsage(0.0);
        }
    }

    /**
     * 计算网络延迟
     */
    private void calculateLatency(BandwidthMonitorData monitorData) {
        try {
            // 使用ping命令测试网络延迟
            String host = "8.8.8.8"; // Google DNS
            ProcessBuilder processBuilder = new ProcessBuilder("ping", "-c", "1", host);
            Process process = processBuilder.start();
            
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            double latency = 0.0;
            
            while ((line = reader.readLine()) != null) {
                if (line.contains("time=")) {
                    // 解析ping结果中的延迟时间
                    String[] parts = line.split("time=");
                    if (parts.length > 1) {
                        String latencyStr = parts[1].split(" ")[0];
                        latency = Double.parseDouble(latencyStr);
                        break;
                    }
                }
            }
            
            process.waitFor();
            monitorData.setLatency(latency);
            
        } catch (Exception e) {
            log.error("计算网络延迟失败: {}", e.getMessage(), e);
            monitorData.setLatency(0.0);
        }
    }

    /**
     * 计算丢包率
     */
    private void calculatePacketLossRate(BandwidthMonitorData monitorData) {
        try {
            long totalPackets = monitorData.getPacketsReceived() + monitorData.getPacketsSent();
            long totalDrops = monitorData.getDropsReceived() + monitorData.getDropsSent();
            
            if (totalPackets > 0) {
                double packetLossRate = (double) totalDrops / totalPackets * 100;
                monitorData.setPacketLossRate(packetLossRate);
            } else {
                monitorData.setPacketLossRate(0.0);
            }
            
        } catch (Exception e) {
            log.error("计算丢包率失败: {}", e.getMessage(), e);
            monitorData.setPacketLossRate(0.0);
        }
    }

    /**
     * 设置网络状态
     */
    private void setNetworkStatus(BandwidthMonitorData monitorData) {
        try {
            String status = "Normal";
            
            // 根据带宽使用率判断状态
            if (monitorData.getBandwidthUsage() > 90) {
                status = "High";
            } else if (monitorData.getBandwidthUsage() > 80) {
                status = "Medium";
            }
            
            // 根据延迟判断状态
            if (monitorData.getLatency() > 200) {
                status = "High Latency";
            }
            
            // 根据丢包率判断状态
            if (monitorData.getPacketLossRate() > 5) {
                status = "Packet Loss";
            }
            
            monitorData.setNetworkStatus(status);
            
        } catch (Exception e) {
            log.error("设置网络状态失败: {}", e.getMessage(), e);
            monitorData.setNetworkStatus("Unknown");
        }
    }

    /**
     * 更新带宽缓存
     */
    private void updateBandwidthCache(BandwidthMonitorData monitorData) {
        try {
            String cacheKey = "bandwidth:realtime:" + monitorData.getInterfaceName();
            redisTemplate.opsForValue().set(cacheKey, monitorData, Duration.ofMinutes(5));
            
            // 更新历史数据缓存
            String historyKey = "bandwidth:history:" + monitorData.getInterfaceName();
            redisTemplate.opsForList().leftPush(historyKey, monitorData);
            redisTemplate.opsForList().trim(historyKey, 0, 99);
            redisTemplate.expire(historyKey, Duration.ofHours(1));
            
        } catch (Exception e) {
            log.warn("更新带宽缓存失败: {}", e.getMessage());
        }
    }

    /**
     * 检查带宽告警
     */
    private void checkBandwidthAlert(BandwidthMonitorData monitorData) {
        try {
            String alertType = null;
            String alertLevel = null;
            String alertMessage = null;
            
            // 检查带宽使用率告警
            if (monitorData.getBandwidthUsage() > 90) {
                alertType = "BANDWIDTH_USAGE_HIGH";
                alertLevel = "CRITICAL";
                alertMessage = String.format("带宽使用率过高: %.2f%%", monitorData.getBandwidthUsage());
            } else if (monitorData.getBandwidthUsage() > 80) {
                alertType = "BANDWIDTH_USAGE_WARNING";
                alertLevel = "WARNING";
                alertMessage = String.format("带宽使用率较高: %.2f%%", monitorData.getBandwidthUsage());
            }
            
            // 检查网络延迟告警
            if (monitorData.getLatency() > 200) {
                alertType = "NETWORK_LATENCY_HIGH";
                alertLevel = "WARNING";
                alertMessage = String.format("网络延迟过高: %.2fms", monitorData.getLatency());
            }
            
            // 检查丢包率告警
            if (monitorData.getPacketLossRate() > 5) {
                alertType = "PACKET_LOSS_HIGH";
                alertLevel = "CRITICAL";
                alertMessage = String.format("丢包率过高: %.2f%%", monitorData.getPacketLossRate());
            }
            
            // 发送告警
            if (alertType != null) {
                sendBandwidthAlert(monitorData, alertType, alertLevel, alertMessage);
            }
            
        } catch (Exception e) {
            log.error("检查带宽告警失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 发送带宽告警
     */
    private void sendBandwidthAlert(BandwidthMonitorData monitorData, String alertType, String alertLevel, String alertMessage) {
        try {
            // 检查是否已经发送过相同告警
            String alertKey = "bandwidth:alert:" + monitorData.getInterfaceName() + ":" + alertType;
            Boolean hasAlert = redisTemplate.hasKey(alertKey);
            
            if (hasAlert == null || !hasAlert) {
                // 创建告警记录
                BandwidthAlertRecord alertRecord = new BandwidthAlertRecord();
                alertRecord.setHostname(monitorData.getHostname());
                alertRecord.setInterfaceName(monitorData.getInterfaceName());
                alertRecord.setAlertType(alertType);
                alertRecord.setAlertLevel(alertLevel);
                alertRecord.setAlertMessage(alertMessage);
                alertRecord.setAlertStatus("ACTIVE");
                alertRecord.setAlertTime(new Date());
                
                // 发送告警通知
                alertService.sendBandwidthAlert(alertRecord);
                
                // 设置告警缓存
                redisTemplate.opsForValue().set(alertKey, "1", Duration.ofMinutes(5));
                
                log.warn("发送带宽告警: interface={}, type={}, level={}", 
                        monitorData.getInterfaceName(), alertType, alertLevel);
            }
            
        } catch (Exception e) {
            log.error("发送带宽告警失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 获取实时带宽数据
     */
    public BandwidthMonitorData getRealTimeBandwidthData(String interfaceName) {
        String cacheKey = "bandwidth:realtime:" + interfaceName;
        return (BandwidthMonitorData) redisTemplate.opsForValue().get(cacheKey);
    }

    /**
     * 获取带宽历史数据
     */
    public List<BandwidthMonitorData> getBandwidthHistoryData(String interfaceName, Date startTime, Date endTime) {
        return bandwidthMonitorDataMapper.selectByInterfaceAndTimeRange(interfaceName, startTime, endTime);
    }

    /**
     * 获取主机名
     */
    private String getHostname() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
            return "unknown";
        }
    }

    /**
     * 获取本地IP地址
     */
    private String getLocalIpAddress() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            return "127.0.0.1";
        }
    }
}

/**
 * 网络统计信息实体类
 */
@Data
public class NetworkStats {
    private long bytesReceived;          // 接收字节数
    private long bytesSent;              // 发送字节数
    private long packetsReceived;        // 接收包数
    private long packetsSent;            // 发送包数
    private long timestamp;             // 时间戳
}

4. 带宽优化服务

4.1 带宽优化服务

/**
 * 带宽优化服务
 * 提供网络带宽优化功能
 */
@Service
public class BandwidthOptimizationService {

    @Autowired
    private BandwidthMonitorService bandwidthMonitorService;
    
    @Autowired
    private AlertService alertService;

    /**
     * 自动带宽优化
     * 根据带宽使用情况自动进行优化
     */
    @Scheduled(fixedRate = 300000) // 每5分钟执行一次
    public void autoOptimizeBandwidth() {
        try {
            // 获取所有网络接口
            List<String> interfaces = getNetworkInterfaces();
            
            for (String interfaceName : interfaces) {
                try {
                    // 获取实时带宽数据
                    BandwidthMonitorData bandwidthData = bandwidthMonitorService.getRealTimeBandwidthData(interfaceName);
                    
                    if (bandwidthData == null) {
                        continue;
                    }
                    
                    // 检查带宽使用率
                    if (bandwidthData.getBandwidthUsage() > 90) {
                        // 带宽使用率过高，执行紧急优化
                        executeEmergencyOptimization(bandwidthData);
                    } else if (bandwidthData.getBandwidthUsage() > 80) {
                        // 带宽使用率较高，执行预防性优化
                        executePreventiveOptimization(bandwidthData);
                    }
                    
                    // 检查网络延迟
                    if (bandwidthData.getLatency() > 200) {
                        // 网络延迟过高，执行延迟优化
                        executeLatencyOptimization(bandwidthData);
                    }
                    
                } catch (Exception e) {
                    log.error("处理网络接口失败: interface={}, error={}", 
                            interfaceName, e.getMessage());
                }
            }
            
        } catch (Exception e) {
            log.error("自动带宽优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行紧急优化
     */
    private void executeEmergencyOptimization(BandwidthMonitorData bandwidthData) {
        log.warn("执行紧急带宽优化: interface={}, usage={}%", 
                bandwidthData.getInterfaceName(), bandwidthData.getBandwidthUsage());
        
        try {
            // 1. 启用流量控制
            enableTrafficControl(bandwidthData.getInterfaceName());
            
            // 2. 调整QoS策略
            adjustQosPolicy(bandwidthData.getInterfaceName());
            
            // 3. 优化网络配置
            optimizeNetworkConfig(bandwidthData.getInterfaceName());
            
            // 4. 发送优化通知
            sendOptimizationNotification(bandwidthData, "EMERGENCY_OPTIMIZATION");
            
        } catch (Exception e) {
            log.error("执行紧急优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行预防性优化
     */
    private void executePreventiveOptimization(BandwidthMonitorData bandwidthData) {
        log.info("执行预防性带宽优化: interface={}, usage={}%", 
                bandwidthData.getInterfaceName(), bandwidthData.getBandwidthUsage());
        
        try {
            // 1. 优化网络路由
            optimizeNetworkRouting(bandwidthData.getInterfaceName());
            
            // 2. 调整缓冲区大小
            adjustBufferSize(bandwidthData.getInterfaceName());
            
            // 3. 优化网络协议
            optimizeNetworkProtocol(bandwidthData.getInterfaceName());
            
            // 4. 发送优化通知
            sendOptimizationNotification(bandwidthData, "PREVENTIVE_OPTIMIZATION");
            
        } catch (Exception e) {
            log.error("执行预防性优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 执行延迟优化
     */
    private void executeLatencyOptimization(BandwidthMonitorData bandwidthData) {
        log.info("执行网络延迟优化: interface={}, latency={}ms", 
                bandwidthData.getInterfaceName(), bandwidthData.getLatency());
        
        try {
            // 1. 优化网络延迟
            optimizeNetworkLatency(bandwidthData.getInterfaceName());
            
            // 2. 调整网络参数
            adjustNetworkParameters(bandwidthData.getInterfaceName());
            
            // 3. 优化网络路径
            optimizeNetworkPath(bandwidthData.getInterfaceName());
            
            // 4. 发送优化通知
            sendOptimizationNotification(bandwidthData, "LATENCY_OPTIMIZATION");
            
        } catch (Exception e) {
            log.error("执行延迟优化失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 启用流量控制
     */
    private void enableTrafficControl(String interfaceName) {
        log.info("启用流量控制: interface={}", interfaceName);
        
        try {
            // 使用tc命令启用流量控制
            ProcessBuilder processBuilder = new ProcessBuilder("tc", "qdisc", "add", "dev", interfaceName, "root", "htb");
            Process process = processBuilder.start();
            process.waitFor();
            
            log.info("流量控制启用成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("启用流量控制失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 调整QoS策略
     */
    private void adjustQosPolicy(String interfaceName) {
        log.info("调整QoS策略: interface={}", interfaceName);
        
        try {
            // 设置QoS策略
            List<String> qosCommands = Arrays.asList(
                "tc", "class", "add", "dev", interfaceName, "parent", "1:0", "classid", "1:1", "htb", "rate", "100mbit",
                "tc", "class", "add", "dev", interfaceName, "parent", "1:1", "classid", "1:10", "htb", "rate", "50mbit", "ceil", "100mbit",
                "tc", "class", "add", "dev", interfaceName, "parent", "1:1", "classid", "1:20", "htb", "rate", "30mbit", "ceil", "100mbit"
            );
            
            for (String command : qosCommands) {
                ProcessBuilder processBuilder = new ProcessBuilder(command.split(" "));
                Process process = processBuilder.start();
                process.waitFor();
            }
            
            log.info("QoS策略调整成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("调整QoS策略失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 优化网络配置
     */
    private void optimizeNetworkConfig(String interfaceName) {
        log.info("优化网络配置: interface={}", interfaceName);
        
        try {
            // 优化网络配置参数
            List<String> configCommands = Arrays.asList(
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_congestion_control",
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_window_scaling",
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_timestamps"
            );
            
            for (String command : configCommands) {
                ProcessBuilder processBuilder = new ProcessBuilder(command.split(" "));
                Process process = processBuilder.start();
                process.waitFor();
            }
            
            log.info("网络配置优化成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("优化网络配置失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 优化网络路由
     */
    private void optimizeNetworkRouting(String interfaceName) {
        log.info("优化网络路由: interface={}", interfaceName);
        
        try {
            // 优化路由表
            ProcessBuilder processBuilder = new ProcessBuilder("ip", "route", "flush", "cache");
            Process process = processBuilder.start();
            process.waitFor();
            
            log.info("网络路由优化成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("优化网络路由失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 调整缓冲区大小
     */
    private void adjustBufferSize(String interfaceName) {
        log.info("调整缓冲区大小: interface={}", interfaceName);
        
        try {
            // 调整网络缓冲区大小
            List<String> bufferCommands = Arrays.asList(
                "echo", "16777216", ">", "/proc/sys/net/core/rmem_max",
                "echo", "16777216", ">", "/proc/sys/net/core/wmem_max",
                "echo", "16777216", ">", "/proc/sys/net/core/rmem_default",
                "echo", "16777216", ">", "/proc/sys/net/core/wmem_default"
            );
            
            for (String command : bufferCommands) {
                ProcessBuilder processBuilder = new ProcessBuilder(command.split(" "));
                Process process = processBuilder.start();
                process.waitFor();
            }
            
            log.info("缓冲区大小调整成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("调整缓冲区大小失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 优化网络协议
     */
    private void optimizeNetworkProtocol(String interfaceName) {
        log.info("优化网络协议: interface={}", interfaceName);
        
        try {
            // 优化TCP协议参数
            List<String> tcpCommands = Arrays.asList(
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_sack",
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_dsack",
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_fack"
            );
            
            for (String command : tcpCommands) {
                ProcessBuilder processBuilder = new ProcessBuilder(command.split(" "));
                Process process = processBuilder.start();
                process.waitFor();
            }
            
            log.info("网络协议优化成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("优化网络协议失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 优化网络延迟
     */
    private void optimizeNetworkLatency(String interfaceName) {
        log.info("优化网络延迟: interface={}", interfaceName);
        
        try {
            // 优化延迟相关参数
            List<String> latencyCommands = Arrays.asList(
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_low_latency",
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_no_delay_ack",
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_quick_ack"
            );
            
            for (String command : latencyCommands) {
                ProcessBuilder processBuilder = new ProcessBuilder(command.split(" "));
                Process process = processBuilder.start();
                process.waitFor();
            }
            
            log.info("网络延迟优化成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("优化网络延迟失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 调整网络参数
     */
    private void adjustNetworkParameters(String interfaceName) {
        log.info("调整网络参数: interface={}", interfaceName);
        
        try {
            // 调整网络参数
            List<String> paramCommands = Arrays.asList(
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_keepalive_time",
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_keepalive_intvl",
                "echo", "1", ">", "/proc/sys/net/ipv4/tcp_keepalive_probes"
            );
            
            for (String command : paramCommands) {
                ProcessBuilder processBuilder = new ProcessBuilder(command.split(" "));
                Process process = processBuilder.start();
                process.waitFor();
            }
            
            log.info("网络参数调整成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("调整网络参数失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 优化网络路径
     */
    private void optimizeNetworkPath(String interfaceName) {
        log.info("优化网络路径: interface={}", interfaceName);
        
        try {
            // 优化网络路径
            ProcessBuilder processBuilder = new ProcessBuilder("ip", "route", "flush", "cache");
            Process process = processBuilder.start();
            process.waitFor();
            
            log.info("网络路径优化成功: interface={}", interfaceName);
            
        } catch (Exception e) {
            log.error("优化网络路径失败: interface={}, error={}", interfaceName, e.getMessage());
        }
    }

    /**
     * 获取网络接口列表
     */
    private List<String> getNetworkInterfaces() {
        List<String> interfaces = new ArrayList<>();
        
        try {
            SystemInfo systemInfo = new SystemInfo();
            List<NetworkIF> networkIFs = systemInfo.getHardware().getNetworkIFs();
            
            for (NetworkIF networkIF : networkIFs) {
                interfaces.add(networkIF.getName());
            }
            
        } catch (Exception e) {
            log.error("获取网络接口列表失败: {}", e.getMessage(), e);
        }
        
        return interfaces;
    }

    /**
     * 发送优化通知
     */
    private void sendOptimizationNotification(BandwidthMonitorData bandwidthData, String optimizationType) {
        try {
            AlertMessage alert = new AlertMessage();
            alert.setType("BANDWIDTH_OPTIMIZATION");
            alert.setLevel("INFO");
            alert.setMessage(String.format("带宽优化完成: 类型=%s, 接口=%s, 使用率=%.2f%%", 
                    optimizationType, bandwidthData.getInterfaceName(), bandwidthData.getBandwidthUsage()));
            alert.setTimestamp(new Date());
            
            alertService.sendAlert(alert);
            
        } catch (Exception e) {
            log.error("发送优化通知失败: {}", e.getMessage(), e);
        }
    }
}

5. 总结

本文详细介绍了网络带宽运维监控与优化的完整解决方案，包括：

5.1 核心技术点

带宽监控: 实时监控网络带宽使用情况
流量分析: 分析网络流量模式和趋势
网络优化: 优化网络配置和路由策略
QoS管理: 管理网络服务质量
告警通知: 多级告警、智能通知

5.2 架构优势

实时监控: 5秒间隔的实时带宽数据采集
智能告警: 基于阈值的智能告警机制
自动优化: 自动化的网络优化
多维度分析: 带宽使用率、延迟、丢包率等多维度分析

5.3 最佳实践

监控策略: 设置合理的带宽监控阈值
优化策略: 根据带宽情况执行针对性优化
QoS管理: 合理配置网络服务质量
预防措施: 提前预防网络拥塞问题

通过以上架构设计，可以构建完善的网络带宽运维监控系统，实现网络性能的有效管理和优化。