`

Java简单实现Ping功能

 
阅读更多

基本需求： 定时测试被监控的设备是否可以ping通，如果ping不通的需要发出告警信息。

方案思路： 运用java调用服务器的自身命令来简单实现ping功能 ，本文只是讲述如何运用Java简单实现Ping的功能，至于告警信息的发送方式有很多种（比如短信 、邮件 、Syslog 、MSN 等等），在以前的文章中已经描述过，这里就不再一一详述了。

实现方式 ： 根据不同的情况可分为如下两种
直接调用监控服务器的ping命令去测试需要监控的设备
通过指定服务器测试能否ping通 需要监控的设备 (运用Mina实现 )
下面将给出上述的两种实现的详细过程：

一、直接调用服务器本身的ping命令
TestPingCmd.java
Java代码 
package michael.net; 
 
import java.io.BufferedReader; 
import java.io.File; 
import java.io.FileReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.LineNumberReader; 
import java.text.MessageFormat; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 
 
/**
* @blog http://sjsky.iteye.com
* @author Michael
*/ 
public class TestPingCmd { 
 
    /**
     * @param args
     * @throws Exception
     */ 
    public static void main(String[] args) throws Exception { 
 
        // 读取txt文件中的IP列表 
         TestPingCmd pinger = new TestPingCmd(); 
        List<String> iplist = pinger 
                .getIpListFromTxt("d:/test/idc_ping_ip.txt"); 
 
        // List<String> iplist = new ArrayList<String>(); 
        // iplist.add("222.*.*.*"); 
        // iplist.add("222.*.*.*"); 
        // iplist.add("222.*.*.*"); 
        // iplist.add("222.*.*.*"); 
        // iplist.add("222.*.*.*"); 
        ThreadPoolExecutor executorPool = new ThreadPoolExecutor(50, 60, 60, 
                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(50), 
                new ThreadPoolExecutor.CallerRunsPolicy()); 
        long startTime = System.currentTimeMillis(); 
        final int maxCount = 4; 
        for (final String ip : iplist) { 
            executorPool.execute(new Runnable() { 
                public void run() { 
                    TestPingCmd pinger = new TestPingCmd(); 
                    Integer countSucce = pinger.doPingCmd(ip, maxCount); 
                    if (null != countSucce) { 
                        System.out.println("host:[ " + ip + " ] ping cout: " 
                                + maxCount + " success: " + countSucce); 
 
                    } else { 
                        System.out 
                                .println("host:[ " + ip + " ] ping cout null"); 
                    } 
                } 
 
            }); 
        } 
        while (executorPool.getActiveCount() > 0) { 
            Thread.sleep(100); 
        } 
        System.out.println("complete ping jobs count = " + iplist.size() 
                + " , total used time(ms) = " 
                + (System.currentTimeMillis() - startTime)); 
        executorPool.shutdown(); 
    } 
 
    /**
     * @param destIp
     * @param maxCount
     * @return
     */ 
    public Integer doPingCmd(String destIp, int maxCount) { 
        LineNumberReader input = null; 
        try { 
            String osName = System.getProperties().getProperty("os.name"); 
            String pingCmd = null; 
            if (osName.startsWith("Windows")) { 
                pingCmd = "cmd /c ping -n {0} {1}"; 
                pingCmd = MessageFormat.format(pingCmd, maxCount, destIp); 
            } else if (osName.startsWith("Linux")) { 
                pingCmd = "ping -c {0} {1}"; 
                pingCmd = MessageFormat.format(pingCmd, maxCount, destIp); 
            } else { 
                System.out.println("not support OS"); 
                return null; 
            } 
            Process process = Runtime.getRuntime().exec(pingCmd); 
            InputStreamReader ir = new InputStreamReader(process 
                    .getInputStream()); 
            input = new LineNumberReader(ir); 
            String line; 
            List<String> reponse = new ArrayList<String>(); 
 
            while ((line = input.readLine()) != null) { 
                if (!"".equals(line)) { 
                    reponse.add(line); 
                    // System.out.println("====:" + line); 
                } 
            } 
            if (osName.startsWith("Windows")) { 
                return parseWindowsMsg(reponse, maxCount); 
            } else if (osName.startsWith("Linux")) { 
                return parseLinuxMsg(reponse, maxCount); 
            } 
 
        } catch (IOException e) { 
            System.out.println("IOException   " + e.getMessage()); 
 
        } finally { 
            if (null != input) { 
                try { 
                    input.close(); 
                } catch (IOException ex) { 
                    System.out.println("close error:" + ex.getMessage()); 
 
                } 
            } 
        } 
        return null; 
    } 
 
    private int parseWindowsMsg(List<String> reponse, int total) { 
        int countTrue = 0; 
        int countFalse = 0; 
        for (String str : reponse) { 
            if (str.startsWith("来自") || str.startsWith("Reply from")) { 
                countTrue++; 
            } 
            if (str.startsWith("请求超时") || str.startsWith("Request timed out")) { 
                countFalse++; 
            } 
        } 
        return countTrue; 
    } 
 
    private int parseLinuxMsg(List<String> reponse, int total) { 
        int countTrue = 0; 
        for (String str : reponse) { 
            if (str.contains("bytes from") && str.contains("icmp_seq=")) { 
                countTrue++; 
            } 
        } 
        return countTrue; 
    } 
 
    /**
     * @param filepath
     * @return list
     */ 
    public List<String> getIpListFromTxt(String filepath) { 
        BufferedReader br = null; 
        List<String> iplist = new ArrayList<String>(); 
        try { 
            File file = new File(filepath); 
            br = new BufferedReader(new FileReader(file)); 
            while (br.ready()) { 
                String line = br.readLine(); 
                if (null != line && !"".equals(line)) { 
                    iplist.add(line); 
                } 
            } 
        } catch (Exception e) { 
            e.printStackTrace(System.out); 
 
        } finally { 
            if (null != br) { 
                try { 
                    br.close(); 
                } catch (Exception ex) { 
                    ex.printStackTrace(System.out); 
                } 
            } 
        } 
        return iplist; 
    } 
 
} 

读取文件中IP列表（1001个IP）运行结果：
complete ping jobs count = 1001 , total used time(ms) = 483536


二、通过指定服务器去ping测试

       主要思路：利用Mina在指定的第三方服务器上运行server端，然后实现客户端和 第三方 服务器建立socket连接，发送ping任务的消息给第三方服务器，第三方服务器再把执行结果实时反馈给客户端。
       代码包括四个类：
服务端：PingServerIoHandler.java PingServer.java
客户端：PingClientIoHandler.java PingClient.java
Java代码 
package michael.mina.ping; 
 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.LineNumberReader; 
import java.text.MessageFormat; 
 
import org.apache.mina.core.service.IoHandlerAdapter; 
import org.apache.mina.core.session.IdleStatus; 
import org.apache.mina.core.session.IoSession; 
 
/**
* @blog http://sjsky.iteye.com
* @author Michael
*/ 
public class PingServerIoHandler extends IoHandlerAdapter { 
    private String logId = "SERVER:: "; 
    private int msgCount = 0; 
 
    @Override 
    public void exceptionCaught(IoSession pSession, Throwable pCause) 
            throws Exception { 
        System.out.println(logId + "发生异常：" + pCause.getLocalizedMessage()); 
    } 
 
    @Override 
    public void messageReceived(IoSession pSession, Object pMessage) 
            throws Exception { 
        String msg = String.valueOf(pMessage); 
        msgCount++; 
        System.out.println(logId + "收到客户端第 " + msgCount + " 条消息：" + msg); 
        pSession.write(msgCount); 
 
        if (msg.startsWith("ping")) { 
            String destIp = msg.split(" ")[1]; 
            doPingCmd(pSession, destIp); 
        } 
 
    } 
 
    @Override 
    public void messageSent(IoSession pSession, Object pMessage) 
            throws Exception { 
        System.out.println(logId + "发出消息：" + pMessage); 
    } 
 
    @Override 
    public void sessionClosed(IoSession pSession) throws Exception { 
        System.out.println(logId + "one client closed "); 
    } 
 
    @Override 
    public void sessionCreated(IoSession pSession) throws Exception { 
        System.out.println(logId + "sessionCreated "); 
    } 
 
    @Override 
    public void sessionIdle(IoSession pSession, IdleStatus pStatus) 
            throws Exception { 
        super.sessionIdle(pSession, pStatus); 
    } 
 
    @Override 
    public void sessionOpened(IoSession pSession) throws Exception { 
        System.out.println(logId + "sessionOpened "); 
    } 
 
    private Integer doPingCmd(IoSession pSession, String destIp) { 
        LineNumberReader input = null; 
        int maxCount = 4; 
        try { 
            String osName = System.getProperties().getProperty("os.name"); 
            String pingCmd = null; 
            if (osName.startsWith("Windows")) { 
                pingCmd = "cmd /c ping -n {0} {1}"; 
                pingCmd = MessageFormat.format(pingCmd, maxCount, destIp); 
            } else if (osName.startsWith("Linux")) { 
                pingCmd = "ping -c {0} {1}"; 
                pingCmd = MessageFormat.format(pingCmd, maxCount, destIp); 
            } else { 
                System.out.println("not support OS"); 
                return null; 
            } 
            Process process = Runtime.getRuntime().exec(pingCmd); 
            InputStreamReader ir = new InputStreamReader(process 
                    .getInputStream()); 
            input = new LineNumberReader(ir); 
            String line; 
 
            while ((line = input.readLine()) != null) { 
                if (!"".equals(line)) { 
                    pSession.write(line); 
                } 
            } 
        } catch (IOException e) { 
            System.out.println("IOException   " + e.getMessage()); 
 
        } finally { 
            if (null != input) { 
                try { 
                    input.close(); 
                } catch (IOException ex) { 
                    System.out.println("close error:" + ex.getMessage()); 
 
                } 
            } 
        } 
        return null; 
    } 
} 

Java代码 
package michael.mina.ping; 
 
import java.net.InetSocketAddress; 
import java.nio.charset.Charset; 
 
import org.apache.mina.core.service.IoAcceptor; 
import org.apache.mina.filter.codec.ProtocolCodecFilter; 
import org.apache.mina.filter.codec.textline.TextLineCodecFactory; 
import org.apache.mina.filter.logging.LoggingFilter; 
import org.apache.mina.transport.socket.nio.NioSocketAcceptor; 
 
/**
* @blog http://sjsky.iteye.com
* @author Michael
*/ 
public class PingServer { 
 
    private static final int PORT = 54321; 
 
    /**
     * @param args
     * @throws Exception
     */ 
    public static void main(String[] args) throws Exception { 
        IoAcceptor acceptor = new NioSocketAcceptor(); 
 
        acceptor.getFilterChain().addLast("logger", new LoggingFilter()); 
        acceptor.getFilterChain().addLast( 
                "codec", 
                new ProtocolCodecFilter(new TextLineCodecFactory(Charset 
                        .forName("UTF-8")))); 
        acceptor.setHandler(new PingServerIoHandler()); 
        acceptor.bind(new InetSocketAddress(PORT)); 
 
        System.out.println("服务端已启动，监听端口：" + PORT); 
 
    } 
 
} 


Java代码 
package michael.mina.ping; 
 
import org.apache.mina.core.service.IoHandlerAdapter; 
import org.apache.mina.core.session.IdleStatus; 
import org.apache.mina.core.session.IoSession; 
 
/**
* @blog http://sjsky.iteye.com
* @author Michael
*/ 
public class PingClientIoHandler extends IoHandlerAdapter { 
 
    private String logId = "CLIENT:: "; 
 
    @Override 
    public void exceptionCaught(IoSession pSession, Throwable pCause) 
            throws Exception { 
        System.out.println(logId + "发生异常：" + pCause.getLocalizedMessage()); 
    } 
 
    @Override 
    public void messageReceived(IoSession pSession, Object pMessage) 
            throws Exception { 
        String count = String.valueOf(pMessage); 
        System.out.println(logId + "服务端收到的消息数 = " + count); 
    } 
 
    @Override 
    public void messageSent(IoSession pSession, Object pMessage) 
            throws Exception { 
        System.out.println(logId + "发出消息：" + pMessage); 
    } 
 
    @Override 
    public void sessionClosed(IoSession pSession) throws Exception { 
        System.out.println(logId + "one client closed "); 
    } 
 
    @Override 
    public void sessionCreated(IoSession pSession) throws Exception { 
        System.out.println(logId + "sessionCreated "); 
    } 
 
    @Override 
    public void sessionIdle(IoSession pSession, IdleStatus pStatus) 
            throws Exception { 
        super.sessionIdle(pSession, pStatus); 
    } 
 
    @Override 
    public void sessionOpened(IoSession pSession) throws Exception { 
        System.out.println(logId + "sessionOpened "); 
    } 
} 

Java代码 
package michael.mina.ping; 
 
import java.net.InetSocketAddress; 
import java.nio.charset.Charset; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.Scanner; 
 
import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder; 
import org.apache.mina.core.future.ConnectFuture; 
import org.apache.mina.core.session.IoSession; 
import org.apache.mina.filter.codec.ProtocolCodecFilter; 
import org.apache.mina.filter.codec.textline.TextLineCodecFactory; 
import org.apache.mina.transport.socket.SocketConnector; 
import org.apache.mina.transport.socket.nio.NioSocketConnector; 
 
/**
* @blog http://sjsky.iteye.com
* @author Michael
*/ 
public class PingClient { 
 
    private static final int PORT = 54321; 
 
    /**
     * IP列表
     * @param ipList
     */ 
    public void createPingClient(List<String> ipList) { 
        SocketConnector connector = new NioSocketConnector(); 
 
        DefaultIoFilterChainBuilder chain = connector.getFilterChain(); 
 
        // 设定过滤器一行一行读取数据 
        chain.addLast("codec", new ProtocolCodecFilter( 
                new TextLineCodecFactory(Charset.forName("UTF-8")))); 
 
        // 注册消息处理器 
        connector.setHandler(new PingClientIoHandler()); 
        connector.setConnectTimeoutMillis(30 * 1000L); 
        // 连接服务器 
        ConnectFuture cf = connector.connect(new InetSocketAddress("127.0.0.1", 
                54321)); 
        cf.awaitUninterruptibly(); 
        IoSession session = cf.getSession(); 
        for (String ip : ipList) { 
            session.write("ping " + ip); 
        } 
        session.getCloseFuture().awaitUninterruptibly(); 
        connector.dispose(); 
        System.out.println("-------------------"); 
    } 
 
    /**
     * 控制台输入
     * @param ipList
     */ 
    public void createPingClient() { 
        SocketConnector connector = new NioSocketConnector(); 
 
        DefaultIoFilterChainBuilder chain = connector.getFilterChain(); 
 
        // 设定过滤器一行一行读取数据 
        chain.addLast("codec", new ProtocolCodecFilter( 
                new TextLineCodecFactory(Charset.forName("UTF-8")))); 
 
        // 注册消息处理器 
        connector.setHandler(new PingClientIoHandler()); 
        connector.setConnectTimeoutMillis(30 * 1000L); 
        // 连接服务器 
        ConnectFuture cf = connector.connect(new InetSocketAddress("127.0.0.1", 
                54321)); 
        cf.awaitUninterruptibly(); 
        IoSession session = cf.getSession(); 
        Scanner input = new Scanner(System.in).useDelimiter("\\r\\n"); 
        while (input.hasNext()) { 
            String s = input.next(); 
            if (s.equals("quit")) { 
                break; 
            } 
            session.write(s); 
        } 
        // cf.getSession().getCloseFuture().awaitUninterruptibly(); 
        connector.dispose(); 
    } 
 
    /**
     * @param args
     * @throws Exception
     */ 
    public static void main(String[] args) throws Exception { 
        PingClient tester = new PingClient(); 
        List<String> iplist = new ArrayList<String>(); 
        iplist.add("192.168.8.89"); 
        iplist.add("192.168.8.93"); 
        iplist.add("192.168.8.109"); 
        iplist.add("192.168.8.117"); 
        iplist.add("192.168.8.118"); 
        tester.createPingClient(iplist); 
    } 
 
} 

BTW：先运行server端，在运行client端（ ）。
server端日志如下：
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
服务端已启动，监听端口：54321
SERVER:: sessionCreated
SERVER:: sessionOpened
SERVER:: 收到客户端第 1 条消息：ping 192.168.8.89
SERVER:: 发出消息：1
SERVER:: 收到客户端第 2 条消息：ping 192.168.8.93
SERVER:: 收到客户端第 3 条消息：ping 192.168.8.109
SERVER:: 收到客户端第 4 条消息：ping 192.168.8.117
SERVER:: 收到客户端第 5 条消息：ping 192.168.8.118
SERVER:: 发出消息：正在 Ping 192.168.8.89 具有 32 字节的数据:
SERVER:: 发出消息：来自 192.168.8.89 的回复: 字节=32 时间=5ms TTL=60
SERVER:: 发出消息：来自 192.168.8.89 的回复: 字节=32 时间=3ms TTL=59
SERVER:: 发出消息：来自 192.168.8.89 的回复: 字节=32 时间=4ms TTL=59
SERVER:: 发出消息：来自 222.73.88.89 的回复: 字节=32 时间=41ms TTL=59
SERVER:: 发出消息：192.168.8.89 的 Ping 统计信息:
SERVER:: 发出消息： 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
SERVER:: 发出消息：往返行程的估计时间(以毫秒为单位):
SERVER:: 发出消息： 最短 = 3ms，最长 = 41ms，平均 = 13ms
SERVER:: 发出消息：2
SERVER:: 发出消息：正在 Ping 192.168.8.93 具有 32 字节的数据:
SERVER:: 发出消息：来自 192.168.8.93 的回复: 字节=32 时间=4ms TTL=59
SERVER:: 发出消息：来自 192.168.8.93 的回复: 字节=32 时间=4ms TTL=59
SERVER:: 发出消息：来自 192.168.8.93 的回复: 字节=32 时间=4ms TTL=59
SERVER:: 发出消息：来自 192.168.8.93 的回复: 字节=32 时间=3ms TTL=59
SERVER:: 发出消息：192.168.8.93 的 Ping 统计信息:
SERVER:: 发出消息： 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
SERVER:: 发出消息：往返行程的估计时间(以毫秒为单位):
SERVER:: 发出消息： 最短 = 3ms，最长 = 4ms，平均 = 3ms
SERVER:: 发出消息：3
SERVER:: 发出消息：正在 Ping 192.168.8.109 具有 32 字节的数据:
SERVER:: 发出消息：来自 192.168.8.109 的回复: 字节=32 时间=13ms TTL=249
SERVER:: 发出消息：来自 192.168.8.109 的回复: 字节=32 时间=36ms TTL=249
SERVER:: 发出消息：来自 192.168.8.109 的回复: 字节=32 时间=61ms TTL=249
SERVER:: 发出消息：来自 192.168.8.109 的回复: 字节=32 时间=83ms TTL=249
SERVER:: 发出消息：192.168.8.109 的 Ping 统计信息:
SERVER:: 发出消息： 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
SERVER:: 发出消息：往返行程的估计时间(以毫秒为单位):
SERVER:: 发出消息： 最短 = 13ms，最长 = 83ms，平均 = 48ms
SERVER:: 发出消息：4
SERVER:: 发出消息：正在 Ping 192.168.8.117 具有 32 字节的数据:
SERVER:: 发出消息：来自 192.168.8.117 的回复: 字节=32 时间=4ms TTL=249
SERVER:: 发出消息：来自 192.168.8.117 的回复: 字节=32 时间=4ms TTL=249
SERVER:: 发出消息：来自 192.168.8.117 的回复: 字节=32 时间=4ms TTL=249
SERVER:: 发出消息：来自 192.168.8.117 的回复: 字节=32 时间=5ms TTL=249
SERVER:: 发出消息：192.168.8.117 的 Ping 统计信息:
SERVER:: 发出消息： 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
SERVER:: 发出消息：往返行程的估计时间(以毫秒为单位):
SERVER:: 发出消息： 最短 = 4ms，最长 = 5ms，平均 = 4ms
SERVER:: 发出消息：5
SERVER:: 发出消息：正在 Ping 192.168.8.118 具有 32 字节的数据:
SERVER:: 发出消息：来自 192.168.8.118 的回复: 字节=32 时间=3ms TTL=251
SERVER:: 发出消息：来自 192.168.8.118 的回复: 字节=32 时间=3ms TTL=251
SERVER:: 发出消息：来自 192.168.8.118 的回复: 字节=32 时间=5ms TTL=251
SERVER:: 发出消息：来自 192.168.8.118 的回复: 字节=32 时间=4ms TTL=251
SERVER:: 发出消息：192.168.8.118 的 Ping 统计信息:
SERVER:: 发出消息： 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
SERVER:: 发出消息：往返行程的估计时间(以毫秒为单位):
SERVER:: 发出消息： 最短 = 3ms，最长 = 5ms，平均 = 3ms

client端日志如下 ：
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
CLIENT:: sessionCreated
CLIENT:: sessionOpened
CLIENT:: 发出消息：ping 192.168.8.89
CLIENT:: 发出消息：ping 192.168.8.93
CLIENT:: 发出消息：ping 192.168.8.109
CLIENT:: 发出消息：ping 192.168.8.117
CLIENT:: 发出消息：ping 192.168.8.118
CLIENT:: 服务端收到的消息数 = 1
CLIENT:: 服务端收到的消息数 = 正在 Ping 192.168.8.89 具有 32 字节的数据:
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.89 的回复: 字节=32 时间=5ms TTL=60
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.89 的回复: 字节=32 时间=3ms TTL=59
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.89 的回复: 字节=32 时间=4ms TTL=59
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.89 的回复: 字节=32 时间=41ms TTL=59
CLIENT:: 服务端收到的消息数 = 192.168.8.89 的 Ping 统计信息:
CLIENT:: 服务端收到的消息数 = 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
CLIENT:: 服务端收到的消息数 = 往返行程的估计时间(以毫秒为单位):
CLIENT:: 服务端收到的消息数 = 最短 = 3ms，最长 = 41ms，平均 = 13ms
CLIENT:: 服务端收到的消息数 = 2
CLIENT:: 服务端收到的消息数 = 正在 Ping 192.168.8.93 具有 32 字节的数据:
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.93 的回复: 字节=32 时间=4ms TTL=59
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.93 的回复: 字节=32 时间=4ms TTL=59
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.93 的回复: 字节=32 时间=4ms TTL=59
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.93 的回复: 字节=32 时间=3ms TTL=59
CLIENT:: 服务端收到的消息数 = 192.168.8.93 的 Ping 统计信息:
CLIENT:: 服务端收到的消息数 = 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
CLIENT:: 服务端收到的消息数 = 往返行程的估计时间(以毫秒为单位):
CLIENT:: 服务端收到的消息数 = 最短 = 3ms，最长 = 4ms，平均 = 3ms
CLIENT:: 服务端收到的消息数 = 3
CLIENT:: 服务端收到的消息数 = 正在 Ping 192.168.8.109 具有 32 字节的数据:
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.109 的回复: 字节=32 时间=13ms TTL=249
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.109 的回复: 字节=32 时间=36ms TTL=249
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.109 的回复: 字节=32 时间=61ms TTL=249
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.109 的回复: 字节=32 时间=83ms TTL=249
CLIENT:: 服务端收到的消息数 = 192.168.8.109 的 Ping 统计信息:
CLIENT:: 服务端收到的消息数 = 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
CLIENT:: 服务端收到的消息数 = 往返行程的估计时间(以毫秒为单位):
CLIENT:: 服务端收到的消息数 = 最短 = 13ms，最长 = 83ms，平均 = 48ms
CLIENT:: 服务端收到的消息数 = 4
CLIENT:: 服务端收到的消息数 = 正在 Ping 192.168.8.117 具有 32 字节的数据:
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.117 的回复: 字节=32 时间=4ms TTL=249
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.117 的回复: 字节=32 时间=4ms TTL=249
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.117 的回复: 字节=32 时间=4ms TTL=249
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.117 的回复: 字节=32 时间=5ms TTL=249
CLIENT:: 服务端收到的消息数 = 192.168.8.117 的 Ping 统计信息:
CLIENT:: 服务端收到的消息数 = 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
CLIENT:: 服务端收到的消息数 = 往返行程的估计时间(以毫秒为单位):
CLIENT:: 服务端收到的消息数 = 最短 = 4ms，最长 = 5ms，平均 = 4ms
CLIENT:: 服务端收到的消息数 = 5
CLIENT:: 服务端收到的消息数 = 正在 Ping 192.168.8.118 具有 32 字节的数据:
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.118 的回复: 字节=32 时间=3ms TTL=251
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.118 的回复: 字节=32 时间=3ms TTL=251
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.118 的回复: 字节=32 时间=5ms TTL=251
CLIENT:: 服务端收到的消息数 = 来自 192.168.8.118 的回复: 字节=32 时间=4ms TTL=251
CLIENT:: 服务端收到的消息数 = 192.168.8.118 的 Ping 统计信息:
CLIENT:: 服务端收到的消息数 = 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
CLIENT:: 服务端收到的消息数 = 往返行程的估计时间(以毫秒为单位):
CLIENT:: 服务端收到的消息数 = 最短 = 3ms，最长 = 5ms，平均 = 3ms

分享到：
| Java实现二维码QRCode的编码和解码
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java简单实现Ping功能.doc

    Java实现ping功能主要涉及到对操作系统命令的调用和并发处理。在Java中，可以通过执行操作系统命令来实现ping操作，这通常使用`Runtime.getRuntime().exec()`或`ProcessBuilder`类来完成。下面详细解释这两种实现...

    用java实现ping的几种方式

    #### 方法二：Java调用外部EXE实现PING功能 除了纯Java实现之外，还可以利用Java中的`Runtime.exec()`方法来调用操作系统的`ping`命令。这种方法相对简单，适用于大多数场景，但可能会受到不同操作系统下命令差异的...

    用java实现ping功能

    在Java编程中，我们不能直接使用内置的库来实现ping功能，因为Java标准库并不包含这样的功能。但是，我们可以借助第三方库如jpcap（Java Packet Capture）来实现这个功能。 jpcap是一个Java库，它提供了对网络接口...

    java语言实现ping函数的功能

    在Java编程语言中，实现ping功能通常涉及到网络通信和套接字编程。ping命令在网络中主要用于检查网络连接的可达性，其工作原理是发送ICMP（Internet Control Message Protocol）回显请求报文到目标主机，然后接收...

    基于socket实现Ping功能的源代码

    本文将深入探讨基于Socket实现Ping功能的源代码，涉及到的主要知识点包括Socket编程、原始套接字（SOCK_RAW）以及ICMP（Internet Control Message Protocol）协议。 首先，我们需要理解什么是Socket。Socket是操作...

    计网课设_Java实现简单的PING操作

    在Java中实现PING功能，主要是通过Java的`InetAddress`类来完成的。 【描述】提到，这个课程设计项目旨在让学生理解并实践如何用Java来模拟PING命令的功能。项目分为两个部分：一是针对单个IP地址的PING操作，二是...

    Android中实现ping功能的多种方法详解

    直接调用CMD命令来实现ping功能，这种方法简单易行，但需要注意的是，需要有权限来执行CMD命令。代码如下： ```java public static void ping1(String ipAddress) throws Exception { String line = null; try { ...

    编程实现基于UDP的PING (Java)

    下面将详细解释基于UDP的PING实现以及相关的Java编程知识。 首先，UDP是传输层的一种无连接协议，它不提供诸如确认、流量控制或重传等服务，因此相对于TCP，UDP更适合于对实时性要求高但可以容忍数据丢失的应用场景...

    实现linux java ping 及traceroute 功能.rar

    本文将详细解析如何在Linux环境中利用Java语言实现`ping`和`traceroute`的功能，并结合C#的相关知识进行探讨。 首先，`ping`是一个简单但实用的网络工具，用于测试主机之间是否可达以及网络的延迟时间。在Linux中，...

    javaping.rar_JAVA ping_ping_ping（java）

    这个"javaping.rar"压缩包包含了一个Java实现的ping功能，使得开发者能够在Java应用程序中集成网络检测的能力。下面将详细探讨Java如何实现ping操作以及其背后的原理。 首先，我们要理解原始的ping命令是基于ICMP...

    TCP-Ping_ping_TCP,IP_JAVAping_java_源码.zip

    解压这个压缩包后，你可以学习和研究如何在实际项目中使用这些代码来实现TCP-Ping功能。这不仅可以帮助你理解TCP/IP通信的细节，还可以让你掌握Java的Socket编程技术。 总之，TCP-Ping是一种基于TCP协议的网络连通...

    实现linux java ping 及traceroute 功能.zip

    首先，让我们看看如何在Java中实现`ping`功能。在Java中，我们可以利用`java.net.Socket`类或`java.net.InetAddress`类来创建一个网络连接并检查其连通性。以下是一个简单的示例： ```java import java.io....

    udp_Ping_JAVAping_javaudpping_java_基于UDP的PING_udp_Ping_

    UDP（User Datagram Protocol）是一种无...在给定的项目“udp_Ping_JAVAping_javaudpping_java_基于UDP的PING_udp_Ping”中，你可以找到实现这些功能的具体代码，进一步学习和理解Java如何操作UDP套接字进行数据通信。

    利用原始套接字实现PING功能的源代码(13kb)

    标题中的“利用原始套接字实现PING功能的源代码”是指使用计算机网络编程中的原始套接字（Raw Sockets）来构建一个简单的网络诊断工具，类似于操作系统内置的PING命令。这个工具可以用来测试网络连通性，测量数据包...

    基于 Java 的Ping程序的设计和实现课程设计（课程报告+源码）

    课程设计使用java来实现ping功能。 为了使用java来实现ping的功能， 可以有三种方法：第一种是用Java 1.5，java.net包中的InetAddress实现ICMP ping的功能，虽然代码简单，但不可靠，在Linux系统下会不可靠；第二种...

    java定时ping命令程序

    Java定时ping命令程序是利用Java编程语言实现的一种自动化任务，它可以定期执行ping操作，检查指定服务器或网络设备的可达性。在IT运维和系统监控中，这种程序具有很高的实用价值，能够帮助我们及时发现网络连接问题...

    java实现ping.pdf

    Java 实现 ICMP 的 ping 命令是一种在 Java 环境下模拟操作系统原生 `ping` 工具的方法。通常，`ping` 命令是通过发送 Internet 控制消息协议 (ICMP) 的回显请求报文来检查网络连接的可达性和延迟。在 Java 中，由于...

    手机端实现Ping测试功能

    在移动设备上，实现ping测试...总之，通过这个项目，开发者能够学习到如何在Android平台上实现ping功能，这对于网络诊断和优化应用性能是非常有价值的。在实际开发过程中，可以根据项目需求进一步完善和定制此功能。

    实现ping功能

    在IT领域，"实现ping功能"是一个常见的编程任务，它涉及到网络通信的基础——ICMP（Internet Control Message Protocol）协议。Ping是网络诊断工具，用于测试网络连接性，通过发送ICMP回显请求报文到目标IP地址，...

    用Jpcap和Java实现图形化的Ping程序.pdf

    ### 用Jpcap和Java实现图形化的Ping程序 #### 1. 引言 Ping程序作为一种常用的网络诊断工具，广泛应用于检测网络连通性和主机可达性。传统的Ping程序主要在命令行界面运行，这对于习惯了图形用户界面的用户来说...

Magicbox
Global site tag (gtag.js) - Google Analytics