`
sjsky
  • 浏览: 917942 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Java简单实现Ping功能

JavaSocketMinaping 
阅读更多

   blog迁移至 :http://www.micmiu.com

 

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

 

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

 

实现方式 ： 根据不同的情况可分为如下两种

  • 直接调用监控服务器的ping命令去测试需要监控的设备
  • 通过指定服务器测试能否ping通 需要监控的设备 (运用Mina实现 )

下面将给出上述的两种实现的详细过程：

 

一、直接调用服务器本身的ping命令

TestPingCmd.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
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;
    }
}

 

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);

    }

}
 

 

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 ");
    }
}
  
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

 

本文连接：http://sjsky.iteye.com/blog/1130277

 

 

转载请注明来自：Michael's blog @ http://sjsky.iteye.com

----------------------------- 分 ------------------------------ 隔 ------------------------------ 线 ------------------------------

 

 

 

 

 

 

6
顶
7
踩
分享到：
| xstream:Invalid byte 2 of 2-byte UTF-8 s ...
评论
7 楼 sjsky 2011-07-23  
wanghuapeng0000 写道
可以发表意见没必要对lz进行人身攻击

说的很对，技术上的东西大家可以互相讨论
6 楼 wanghuapeng0000 2011-07-23  
可以发表意见没必要对lz进行人身攻击
5 楼 sjsky 2011-07-23  
Caedmon 写道
....楼下的，LZ虽然写的东西可能不是你想要的，但是你起码得有点素质。。。 不过话说LZ，你这写的 确实没啥意思，不调用系统命令的话可以研究下。。

还真没有研究用java重新实现下这个ping，不过好像java.net包中就实现了ICMP ping的简单功能（InetAddress.getByName(host).isReachable(timeOut);）
这里简单实现主要是为了利用linux ping命令可以设定很多参数：包的数量、包的大小等等
4 楼 Caedmon 2011-07-22  
....楼下的，LZ虽然写的东西可能不是你想要的，但是你起码得有点素质。。。 不过话说LZ，你这写的 确实没啥意思，不调用系统命令的话可以研究下。。
3 楼 sjsky 2011-07-22  
smiky 写道
调用个破系统命令来做也好意思拿出来,就算是这样也不要用标题来骗人

标题有什么好骗人的 除非你傻或者你不是啥 那就没办法了
2 楼 smiky 2011-07-22  
调用个破系统命令来做也好意思拿出来,就算是这样也不要用标题来骗人
1 楼 吴小懒 2011-07-22  
发表评论

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

相关推荐

    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