[关闭]
@liruiyi962464 2025-07-22T07:15:24.000000Z 字数 8737 阅读 146

ping

代码

自己写的ping

  1. public void monitorUseState() {
  2.         List<ZcMonitor> zcMonitorList = zcMonitorService.list();
  3.         Integer flag = 0;
  4.         if(zcMonitorList.size() > 0 && zcMonitorList != null) {
  5.             for (int i = 0; i < zcMonitorList.size(); i++) {
  6.                 String ip = zcMonitorList.get(i).getIp();
  7.                 String name = zcMonitorList.get(i).getName();
  8.                 String position = zcMonitorList.get(i).getPosition();
  9.                 // 当返回值是true时，说明监控IP是可用的，false则不可。
  10.                 int timeOut = 3000;   // 超时应该在3钞以上
  11.                 boolean status = false;
  12.                 try {
  13.                     // status = InetAddress.getByName(ip).isReachable(timeOut);
  15.                     InetAddress address = InetAddress.getByName(ip);
  16.                     System.out.println("开始检查 IP 地址 " + ip + " 是否可达...");
  18.                     long startTime = System.currentTimeMillis();
  19.                     status = address.isReachable(timeOut);
  20.                     long endTime = System.currentTimeMillis();
  22.                     System.out.println("检查完成，耗时：" + (endTime - startTime) + " 毫秒");
  23.                     if (status) {
  24.                         System.out .println("IP 地址 " + ip + " 是可达的");
  25.                     } else {
  26.                         System.out.println("IP 地址 " + ip + " 不可达");
  27.                     }
  29.                 } catch (IOException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.                 //System.err.println("监控ip"+ip+"状态"+status);
  33.                 //onlineOrNot lineOrNot = new onlineOrNot();
  34.                 //String userAndPwd = onlineOrNot.userAndPwd(ip, username, password);
  35.                 if (!status) {
  36.                     // 状态更新到数据库
  37.                     zcMonitorList.get(i).setUseState("1");
  38.                     zcMonitorService.updateById(zcMonitorList.get(i));
  39.                     // 离线（在线状态不用推送）
  40.                     System.err.println("监控IP：【"+ip+"】监控名称：【"+name+"】监控位置：【"+position+"】【已离线】");
  41.                     zcWarningInformationService.warnXiaoxi(3,"监控IP：【"+ip+"】监控名称：【"+name+"】监控位置：【"+position+"】【已离线】",zcMonitorList.get(i));
  42.                 }else {
  43.                     // 状态更新到数据库
  44.                     zcMonitorList.get(i).setUseState("2");
  45.                     zcMonitorService.updateById(zcMonitorList.get(i));
  47.                 }
  48.             }
  49.         }
  50.     }

使用工具类

  1.      public Result<?> pingDevice(@RequestParam(name="ip") String ip) throws Exception {
  2.          List<String> pingContent = new ArrayList<>();
  3.          boolean b = Ping.ping(ip);
  4.          if (b){
  5.             pingContent = Ping.pingA(ip);
  6.          } else {
  7.             String message = "目标主机"+ip+"无法访问，请检查！";
  8.              pingContent.add(message);
  9.          }
  10.          return Result.OK(pingContent);
  11.      }

多线程定时任务（带线程池） 带参数ping

  1. package org.jeecg.modules.quartz.job;
  3. import lombok.SneakyThrows;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.jeecg.common.util.RedisUtil;
  6. import org.jeecg.modules.demo.alarmManagement.entity.AlarmRecord;
  7. import org.jeecg.modules.demo.alarmManagement.service.IAlarmRecordService;
  8. import org.jeecg.modules.demo.ping.Ping;
  9. import org.jeecg.modules.demo.system.entity.DeviceInfo;
  10. import org.jeecg.modules.demo.system.service.IDeviceInfoService;
  11. import org.jeecg.modules.message.websocket.WebSocket;
  12. import org.quartz.Job;
  13. import org.quartz.JobExecutionContext;
  14. import org.quartz.JobExecutionException;
  15. import org.springframework.beans.factory.annotation.Autowired;
  16. import java.text.SimpleDateFormat;
  17. import java.util.Date;
  18. import java.util.List;
  19. import java.util.concurrent.*;
  21. /**
  22.  * 多线程定时任务（带线程池）
  23.  * @Author Scott
  24.  */
  25. @Slf4j
  26. public class PingLuYouJob implements Job {
  27.     @Autowired
  28.     private IDeviceInfoService deviceInfoService;
  29.     @Autowired
  30.     private IAlarmRecordService alarmRecordService;
  31.     @Autowired
  32.     private WebSocket webSocket;
  33.     @Autowired
  34.     private RedisUtil redisUtil;
  36.     // 定义线程池参数
  37.     private static final int CORE_POOL_SIZE = 5;    // 核心线程数
  38.     private static final int MAX_POOL_SIZE = 10;    // 最大线程数
  39.     private static final int QUEUE_CAPACITY = 100;  // 队列容量
  41.     @SneakyThrows
  42.     @Override
  43.     public void execute(JobExecutionContext context) throws JobExecutionException {
  44.         // 获取设备信息列表
  45.         List<DeviceInfo> deviceInfoList = deviceInfoService.list();
  47.         // 创建线程池
  48.         ExecutorService executor = new ThreadPoolExecutor(
  49.                 CORE_POOL_SIZE,
  50.                 MAX_POOL_SIZE,
  51.                 60L, TimeUnit.SECONDS,
  52.                 new LinkedBlockingQueue<>(QUEUE_CAPACITY)
  53.         );
  55.         // 用于收集检测结果
  56.         ConcurrentHashMap<String, Boolean> pingResults = new ConcurrentHashMap<>();
  58.         try {
  59.             // 提交所有ping任务到线程池
  60.             int maxAttempts = 5;          // 最大尝试5次
  61.             int successThreshold = 3;     // 成功3次即认为可用
  62.             int timeoutPerAttempt = 3000; // 每次ping超时3秒
  63.             for (DeviceInfo deviceInfo : deviceInfoList) {
  64.                 String targetIp = deviceInfo.getIp();
  65.                 executor.submit(() -> {
  66.                     boolean result = false;
  67.                     try {
  68.                         // result = Ping.ping(ip);
  69.                         result = Ping.pingWithRetry(targetIp, maxAttempts, successThreshold, timeoutPerAttempt);
  70.                     } catch (Exception e) {
  71.                         result = false;
  72.                     }
  73.                     pingResults.put(targetIp, result);
  74.                 });
  75.             }
  77.             // 关闭线程池并等待任务完成
  78.             executor.shutdown();
  79.             if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
  80.                 log.warn("线程池未在指定时间内完成所有任务");
  81.             }
  83.             // 处理检测结果
  84.             for (DeviceInfo deviceInfo : deviceInfoList) {
  85.                 String ip = deviceInfo.getIp();
  86.                 boolean pingResult = pingResults.getOrDefault(ip, false);
  88.                 if (pingResult) {
  89.                     deviceInfo.setState("1");
  90.                 } else {
  91.                     if ("1".equals(deviceInfo.getState())) {
  92.                         // 添加报警记录
  93.                         AlarmRecord alarmRecord = new AlarmRecord();
  94.                         alarmRecord.setDeviceId(deviceInfo.getId());
  95.                         alarmRecord.setAlarmContent(deviceInfo.getName() + "设备未ping通，设备处于离线状态；");
  96.                         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  97.                         alarmRecord.setAlarmTime(sdf.format(new Date()));
  98.                         alarmRecord.setAlarmType("1");
  99.                         alarmRecordService.save(alarmRecord);
  101.                         // 推送告警信息
  102.                         String[] usersRecord = alarmRecordService.getSetUsersRecord();
  103.                         webSocket.sendMessage(usersRecord, "-" + deviceInfo.getName() + "设备未ping通，设备处于离线状态；" + "$" + sdf.format(new Date()));
  105.                         // 删除redis缓存
  106.                         redisUtil.del(deviceInfo.getId());
  107.                     }
  108.                     deviceInfo.setState("0");
  109.                     deviceInfo.setSimState("0");
  110.                     deviceInfo.setModuleState("0");
  111.                 }
  112.                 deviceInfoService.updateById(deviceInfo);
  113.             }
  114.         } catch (InterruptedException e) {
  115.             Thread.currentThread().interrupt();
  116.             log.error("线程池被中断", e);
  117.         } finally {
  118.             executor.shutdownNow(); // 确保线程池关闭
  119.         }
  120.     }
  121. }

Ping.java

  1. package org.jeecg.modules.demo.ping;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.net.InetAddress;
  7. import java.net.UnknownHostException;
  8. import java.util.ArrayList;
  9. import java.util.List;
  10. import java.util.regex.Matcher;
  11. import java.util.regex.Pattern;
  13. public class Ping {
  16.      public  static  boolean ping(String ipAddress)  throws Exception {
  17.          int  timeOut =  3000 ;   // 超时应该在3钞以上        
  18.          boolean status = InetAddress.getByName(ipAddress).isReachable(timeOut);      //  当返回值是true时，说明host是可用的，false则不可。
  19.          return status;
  20.     }
  22.     /**
  23.      * 带重试机制的Ping检测方法
  24.      * @param ipAddress 目标主机IP地址（如："8.8.8.8"）
  25.      * @param maxAttempts 最大尝试次数（建议3-5次，根据网络稳定性调整）
  26.      * @param successThreshold 成功判定阈值（建议设置为maxAttempts的60%-80%）
  27.      * @param timeoutPerAttempt 单次尝试超时时间（单位：毫秒，建议3000-5000ms）
  28.      * @return 达到成功阈值返回true，否则返回false
  29.      */
  30.     public static boolean pingWithRetry(String ipAddress, int maxAttempts, int successThreshold, int timeoutPerAttempt) {
  31.         int successCount = 0;
  33.         for (int i = 0; i < maxAttempts; i++) {
  34.             try {
  35.                 boolean isReachable = InetAddress.getByName(ipAddress).isReachable(timeoutPerAttempt);
  36.                 if (isReachable) {
  37.                     successCount++;
  38.                     System.out.println("Attempt " + (i + 1) + ": Success");
  39.                     // 提前退出条件：成功次数达到阈值
  40.                     if (successCount >= successThreshold) {
  41.                         return true;
  42.                     }
  43.                 } else {
  44.                     System.out.println("Attempt " + (i + 1) + ": Failed");
  45.                 }
  46.                 // 可选：添加短暂间隔避免频繁请求（例如1秒）
  47.                 Thread.sleep(1000);
  48.             } catch (UnknownHostException e) {
  49.                 System.err.println("Invalid host: " + e.getMessage());
  50.                 return false;
  51.             } catch (IOException e) {
  52.                 System.err.println("IO Error: " + e.getMessage());
  53.                 return false;
  54.             } catch (InterruptedException e) {
  55.                 Thread.currentThread().interrupt();
  56.                 System.err.println("Thread interrupted");
  57.                 return false;
  58.             }
  59.         }
  61.         System.out.println("Final success count: " + successCount + "/" + maxAttempts);
  62.         return successCount >= successThreshold;
  63.     }
  64.     public static void main(String[] args) {
  65.         String targetIp = "8.8.8.8"; // 示例IP
  66.         int maxAttempts = 5;          // 最大尝试5次
  67.         int successThreshold = 3;     // 成功3次即认为可用
  68.         int timeoutPerAttempt = 3000; // 每次ping超时3秒
  70.         boolean finalStatus = pingWithRetry(targetIp, maxAttempts, successThreshold, timeoutPerAttempt);
  71.         System.out.println("Host is reachable: " + finalStatus);
  72.     }
  74.      public  static  List<String> ping02(String ipAddress)  throws Exception {
  75.          List<String> outputLines = new ArrayList<>(); // 用于保存输出的集合
  76.          try {
  77.             Process pro = Runtime.getRuntime().exec("ping " + ipAddress);
  78.             BufferedReader buf =  new BufferedReader( new InputStreamReader(
  79.                     pro.getInputStream(),"GBK"));
  80.             int i =1;
  81.              String line =  null;
  82.              while ((line = buf.readLine()) !=  null)
  83.                 System.out.println(line);
  84.              outputLines.add(line);
  85.         }  catch (Exception ex) {
  86.             System.out.println(ex.getMessage());
  87.         }
  88.          return outputLines;
  89.     }
  92.      public  static  boolean ping(String ipAddress,  int pingTimes,  int timeOut) {  
  93.         BufferedReader in =  null;  
  94.         Runtime r = Runtime.getRuntime();   //  将要执行的ping命令,此命令是windows格式的命令
  95.         String pingCommand = "ping " + ipAddress + " -n " + pingTimes    + " -w " + timeOut;
  96.          try {    //  执行命令并获取输出  
  97.             System.out.println(pingCommand);
  98.             Process p = r.exec(pingCommand);
  99.              if (p ==  null) {
  100.                  return  false;
  101.             }
  102.             in =  new BufferedReader( new InputStreamReader(p.getInputStream()));    //  逐行检查输出,计算类似出现=23ms TTL=62字样的次数  
  103.              int connectedCount = 0;   
  104.             String line =  null;   
  105.              while ((line = in.readLine()) !=  null) {    
  106.                 connectedCount += getCheckResult(line);   
  107.             }    //  如果出现类似=23ms TTL=62这样的字样,出现的次数=测试次数则返回真  
  108.              return connectedCount == pingTimes;  
  109.         }  catch (Exception ex) {   
  110.             ex.printStackTrace();    //  出现异常则返回假  
  111.              return  false;  
  112.         }  finally {   
  113.              try {
  114.                 in.close();   
  115.             }  catch (IOException e) {    
  116.                 e.printStackTrace();   
  117.             }  
  118.         }
  119.     }
  122.      // 若line含有=18ms TTL=16字样,说明已经ping通,返回1,否則返回0.
  123.      private  static  int getCheckResult(String line) {   //  System.out.println("控制台输出的结果为:"+line);  
  124.         Pattern pattern = Pattern.compile("(\\d+ms)(\\s+)(TTL=\\d+)",    Pattern.CASE_INSENSITIVE);  
  125.         Matcher matcher = pattern.matcher(line);  
  126.          while (matcher.find()) {
  127.              return 1;
  128.         }
  129.          return 0; 
  130.     }
  133.     public static List<String> pingA(String ipAddress){
  134.         List<String> outputLines = new ArrayList<>(); // 用于保存输出的集合
  135.         try {
  136.             // 创建一个Process实例执行ping命令
  137.             Process process = Runtime.getRuntime().exec("ping " + ipAddress);
  138.             // 读取ping命令的输出
  139.             BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(),"GBK"));
  140.             String line;
  141.             while ((line = reader.readLine()) != null) {
  142.                 outputLines.add(line); // 将每行输出添加到集合中
  143.             }
  144.             // 等待ping命令执行完成
  145.             int exitCode = process.waitFor();
  146.             System.out.println("Ping命令执行完成，退出码: " + exitCode);
  147.         } catch (IOException | InterruptedException e) {
  148.             e.printStackTrace();
  149.         }
  150.         return outputLines;
  151.     }
  153. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注