ping 端口 java_[Java]ping或扫描端口的工具类

最新推荐文章于 2022-09-25 16:54:40 发布
最新推荐文章于 2022-09-25 16:54:40 发布
阅读量236 收藏
点赞数
文章标签： ping 端口 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33483080/article/details/114170588
版权
这是一个Java工具类，实现了对指定IP地址的ping操作和端口扫描功能。通过`Discovery`类，可以对单个或多个IP进行ping探测，返回探测结果。同时，类还提供了扫描指定IP范围的端口功能，支持多个端口或端口范围的扫描。代码中包含了针对Windows和Linux系统的不同ping命令处理，并利用`Socket`进行端口连接检查。
摘要由CSDN通过智能技术生成

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintStream;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

public class Discovery {

PrintStream out = null;

public Discovery(){

}

public Discovery(PrintStream out){

this.out = out;

}

/**

* 对指定的ip(数组)进行ping探测

*

* @param ips ip数组

* @return 返回格式为 ip:是否成功

*/

public LinkedHashMap ping(List ips) {

LinkedHashMap ret = new LinkedHashMap();

Map args = new HashMap();

BufferedReader br = null;

for (String ip : ips) {

args.put("ip", ip);

String value = SystoolkitConfigure.getValue("ping.command", args);

// 获得JVM的运行环境

//Runtime r = Runtime.getRuntime();

// 创建一个ping命令进程

try {

Process p = Runtime.getRuntime().exec(value);

StringBuilder sb = new StringBuilder();

String line = null;

br = new BufferedReader(new InputStreamReader(

p.getInputStream()));

while ((line = br.readLine()) != null) {

sb.append(line.trim());

sb.append('\n');

}

br.close();

br = new BufferedReader(new InputStreamReader(

p.getErrorStream()));

while ((line = br.readLine()) != null) {

sb.append(line.trim());

sb.append('\n');

}

br.close();

String os = SystoolkitConfigure.getOS().toLowerCase();

if (-1 != os.indexOf("windows")) {

int index = sb.toString().indexOf("Packets: Sent = 1, Received = 1,");

ret.put(ip, index != -1);

if(null!=out) {

out.println(ip+":"+(index != -1));

out.flush();

}

} else if (-1 != os.indexOf("linux")) {

int index = sb.toString().indexOf("1 packets transmitted, 1 received");

ret.put(ip, index != -1);

if(null!=out) {

out.println(ip+":"+(index != -1));

out.flush();

}

}

} catch (IOException e) {

// TODO Auto-generated catch block

//e.printStackTrace();

}

}

return ret;

}

/**

* 对指定网段的指定ip范围的机器，进行ping探测

*

* @param networkSection

*            网段，例:192.168.2

* @param startIp

*            开始ip,包含此ip,值>0

* @param endIp

*            结束ip,包含此ip,值<255

* @return ping探测结果

*/

public LinkedHashMap ping(String networkSection,

int startIp, int endIp) {

List ips = new ArrayList();

if (startIp <= 0 || endIp >= 255) {

throw new IllegalArgumentException("startIp<=0 or endIp>=255.");

}

for (int i = startIp; i <= endIp; i++) {

// ips.add(String.format("%s.%d", networkSection,i));

ips.add(networkSection + "." + i);

}

return ping(ips);

}

/**

* 此方法相当于ping(networkSection,1,254)

*

* @param networkSection

* @return

*/

public LinkedHashMap ping(String networkSection) {

return ping(networkSection, 1, 254);

}

//public LinkedHashMap scanPort(String networkSection,

//int startIp, int endIp, String port) {

 throw new RuntimeException();

//LinkedHashMap ret = new LinkedHashMap();

//List ports = new ArrayList();

//List ips = new ArrayList();

//if (startIp <= 0 || endIp >= 255) {

//throw new IllegalArgumentException("startIp<=0 or endIp>=255.");

//}

//for (int i = startIp; i <= endIp; i++) {

//ips.add(networkSection + "." + i);

//}

//String[] ss = port.split(",");

//for (String s : ss) {

//if (-1 != s.indexOf('-')) {

//String[] range = s.split("-");

//for (int i = Integer.parseInt(range[0]), end = Integer

//.parseInt(range[1]); i <= end; i++) {

//ports.add(i);

//}

//} else {

//ports.add(Integer.parseInt(s));

//}

//}

//Socket client = null;

//for (String ip : ips) {

//for (Integer p : ports) {

//try {

//client = new Socket();

//client.connect(new InetSocketAddress(ip, p), 300);

//ret.put(ip, true);

//} catch (Exception ex) {

//ret.put(ip, false);

//} finally {

//try {

//if (null != client)

//client.close();

//} catch (Exception ex) {

//}

//}

//}

//

//}

//return ret;

//}

//public void scanPort(List ips, String port, PrintStream out) {

//List ports = new ArrayList();

//

//String[] ss = port.split(",");

//for (String s : ss) {

//if (-1 != s.indexOf('-')) {

//String[] range = s.split("-");

//for (int i = Integer.parseInt(range[0]), end = Integer

//.parseInt(range[1]); i <= end; i++) {

//ports.add(i);

//}

//} else {

//ports.add(Integer.parseInt(s));

//}

//}

//

//Socket client = null;

//for (String ip : ips) {

//for (Integer p : ports) {

//try {

//client = new Socket();

//client.connect(new InetSocketAddress(ip, p), 300);

 ret.add(ip+":"+p);

//out.println(ip + ":" + p);

//out.flush();

//} catch (Exception ex) {

//} finally {

//try {

//if (null != client)

//client.close();

//} catch (Exception ex) {

//}

//}

//}

//}

//

//out.close();

//}

public List scanPort(String networkSection,

int startIp, int endIp, String port) {

List ips = new ArrayList();

if (startIp <= 0 || endIp >= 255) {

throw new IllegalArgumentException("startIp<=0 or endIp>=255.");

}

for (int i = startIp; i <= endIp; i++) {

ips.add(networkSection + "." + i);

}

return scanPort(ips,port);

}

public List scanPort(List ips, String port) {

List ret = new ArrayList();

List ports = new ArrayList();

String[] ss = port.split(",");

for (String s : ss) {

if (-1 != s.indexOf('-')) {

String[] range = s.split("-");

for (int i = Integer.parseInt(range[0]), end = Integer

.parseInt(range[1]); i <= end; i++) {

ports.add(i);

}

} else {

ports.add(Integer.parseInt(s));

}

}

Socket client = null;

for (String ip : ips) {

for (Integer p : ports) {

try {

client = new Socket();

client.connect(new InetSocketAddress(ip, p), 300);

ret.add(ip + ":" + p);

if(null!=out){

out.println(ip + ":" + p);

out.flush();

}

} catch (Exception ex) {

//System.out.println(ex.getMessage());

} finally {

try {

if (null != client)

client.close();

} catch (Exception ex) {

}

}

}

}

return ret;

}

}

配置扫描

import java.util.Enumeration;

import java.util.Map;

import java.util.Properties;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.concurrent.ExecutorService;

/**

*

* @author shanl

*

*/

public class SystoolkitConfigure implements Runnable{

private static final String default_configure = "systoolkit_default";

private static String user_configure = "systoolkit";

//private int scanInterval = 1000*60*5;

private int scanInterval = 1000*5;

private static Properties config = new Properties();

boolean isService = false;

/**

* 使用默认文件名的配置文件

*/

public SystoolkitConfigure(){

}

/**

*

* @param userConfig 用户自定义配置文件

*/

public SystoolkitConfigure(String userConfig){

user_configure = userConfig;

}

public void run() {

ResourceBundle confRes = ResourceBundle.getBundle(default_configure);

Enumeration keys = confRes.getKeys();

while(keys.hasMoreElements()){

String key = keys.nextElement();

String value = confRes.getString(key);

if(null!=value) config.setProperty(key, value);

}

Properties sysProp = System.getProperties();

config.putAll(sysProp);

for(;;){

try{

confRes = ResourceBundle.getBundle(user_configure);

keys = confRes.getKeys();

while(keys.hasMoreElements()){

config.setProperty(keys.nextElement(), confRes.getString(keys.nextElement()));

}

}catch(Exception ex){}

if(isService) try{Thread.sleep(scanInterval); }catch(Exception ex){}

else break;

}

}

/**

* 线程方式启动

* @param threadPool 线程池容器，可以为null

*/

public void start(ExecutorService threadPool){

isService = true;

Thread t = new Thread(this,this.getClass().getSimpleName());

if(null==threadPool){

t.start();

}else{

threadPool.execute(t);

}

}

public void stop(){

this.isService = false;

}

/**

* 设置配置文扫描间隔

* @param interval

*/

public void setScanInterval(int interval){

this.scanInterval = interval;

}

/**

* 从配置文件中取值

* @param key

* @return 如果找不到(或这个键就没有值)，则返回""

*/

public static String getValue(String key){

String os = getOS().toLowerCase();

String ret = "";

if(-1!=os.indexOf("windows")){

ret = config.getProperty(key+".windows","");

}else if(-1!=os.indexOf("linux")){

ret = config.getProperty(key+".linux","");

}

if("".equals(ret)){

ret = config.getProperty(key, "");

}

return ret;

}

/**

* 从配置文件中取值，并把${args.key}的格式替换为args.value

* @param key

* @param args 参数

* @return

*/

public static String getValue(String key,Map args){

String value = getValue(key);

if("".equals(value.trim())) return "";

Set>values = args.entrySet();

for(Map.Entry i: values){

value = value .replaceAll("\\${1}\\{{1}"+i.getKey()+"\\}{1}", i.getValue());

}

return value;

}

public static

String getOS(){

return System.getProperty("os.name");

}

}

systoolkit.properties

test=default test.

test.linux=linux test.

test.windows=windows test.

ping.command.linux=ping -c 1 -s 8 ${ip}

ping.command.windows=ping -n 1 -w 1 -l 8 ${ip}

端口扫描测试

/**

* 扫描端口

*/

static void t2(){

new SystoolkitConfigure().run();

Discovery d = new Discovery(System.out);

//d.scanPort("192.168.2", 1, 254, "22,23,80");

List ips = new ArrayList();

ips.add("192.168.2.22");

ips.add("192.168.2.23");

ips.add("192.168.2.54");

ips.add("192.168.2.55");

d.scanPort(ips,"22,23,80,100-200");

}

[root@xxxx ~]# java -jar discovery.jar

192.168.2.1:23

192.168.2.1:80

192.168.2.10:80

192.168.2.23:22

192.168.2.37:23

192.168.2.54:22

192.168.2.54:23

192.168.2.56:80

192.168.2.57:22

192.168.2.57:23

192.168.2.100:22

192.168.2.107:22

192.168.2.141:80

192.168.2.154:22

192.168.2.154:23

192.168.2.182:22

192.168.2.183:22

192.168.2.201:22

ping探测测试

/**

* ping扫描

*/

static void t1(){

new SystoolkitConfigure().run();

Discovery d = new Discovery(System.out);

Map ret = d.ping("192.168.2");

//System.out.println(ret);

List ips = new ArrayList();

ips.add("192.168.2.22");

ips.add("192.168.2.23");

ips.add("192.168.2.54");

ips.add("192.168.2.55");

ret = d.ping(ips);

}

[root@xxxx ~]# java -jar discovery.jar

192.168.2.1:true

192.168.2.2:false

192.168.2.3:false

192.168.2.4:false

192.168.2.5:false

192.168.2.6:true

192.168.2.7:false

192.168.2.8:true

192.168.2.9:false

192.168.2.10:true

192.168.2.11:true

192.168.2.12:false

192.168.2.13:false

192.168.2.14:false

192.168.2.15:false

192.168.2.16:false

192.168.2.17:false

192.168.2.18:true

192.168.2.19:false

192.168.2.20:false

192.168.2.21:false

192.168.2.22:true

192.168.2.23:true

192.168.2.24:false

192.168.2.25:true

192.168.2.26:false

192.168.2.27:true

192.168.2.28:false

192.168.2.29:false

192.168.2.30:true

192.168.2.31:false

192.168.2.32:true

192.168.2.33:false

192.168.2.34:false

192.168.2.35:false

192.168.2.36:false

192.168.2.37:true

李嘉璇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java_PING工具
java之书-资源
04-25 280
PING工具
[Java]ping或扫描端口的工具类
weixin_34010949的博客
10-13 189
2019独角兽企业重金招聘Python工程师标准>>> ...
Windows和Linux下 Java开发ping工具类
weixin_34018202的博客
09-20 186
  package com.test.util; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class PingUtils {public static boolean ping(String ip, int pingTimes, ...
Java代码ping ip工具类
猪之仆的博客
01-04 615
package com.v.photos.utils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.nio.charset.Charset; /** * @Author.
基于Java实现PING的服务器端和客户端设计
毕业作品网站
09-25 2165
发送一个request后，最多等待1秒以便接收PingServer返回的reply消息。如果在该时间内没有收到服务器的reply，则认为该请求或对该请求的reply已经丢失；2.4 将用户发送来的请求request在延迟一段随机选择的时间(小于1s)后返回给客户端，作为收到请求的响应reply；已知技术参数和设计要求 1.编程实现PING的服务器端和客户端，实现操作系统提供的ping命令的类似功能。3.3 为每个请求计算折返时间(RTT)，统计10个请求的平均RTT、最大/小RTT。能够模拟分组传输延迟；
udp_Ping_JAVAping_javaudpping_java_基于UDP的PING_udp_Ping_
10-01
UDP（User Datagram Protocol）是一种无...在给定的项目“udp_Ping_JAVAping_javaudpping_java_基于UDP的PING_udp_Ping”中，你可以找到实现这些功能的具体代码，进一步学习和理解Java如何操作UDP套接字进行数据通信。
javaping.rar_JAVA ping_ping_ping（java）
09-21
1. **使用Raw Socket**：Java的`java.net.Socket`类并不允许直接创建ICMP套接字，但可以通过使用`java.net.SocketAddress`和`java.net.DatagramPacket`来创建一个RAW套接字，绕过TCP/UDP层直接处理IP数据包。...
TCP-Ping_ping_TCP,IP_JAVAping_java.zip
10-10
TCP-Ping是一个基于Java编写的实用工具，它通过模拟TCP连接的方式，对目标IP或端口进行诊断，以检查网络连接的可达性、延迟和丢包情况。与传统的ICMP Ping工具不同，TCP-Ping专注于TCP层面的探测，更适合于检验应用...
java中ping命令ping工具类(循环ping)
05-09
java中ping命令ping工具类(循环ping) java ping ip ping命令 ping工具类 支持linux和windows等所有平台 Ping是Windows下的一个命令 在Unix和Linux下也有这个命令。 ping也属于一个通信协议，是TCP/IP协议的一部分 利用“ping”命令可以检查网络是否连通，可以很好地帮助我们分析和判定网络故障。应用格式：Ping空格IP地址。 该命令还可以加许多参数使用，具体是键入Ping按回车即可看到详细说明。 ping是一个DOS命令，一般用于检测网络通或不通 ，也叫时延，其值越大，速度越慢。 PING (Packet Internet Groper)，因特网包探索器，用于测试网络连接量的程序。Ping发送一个ICMP(Internet Control Messages Protocol）即因特网信报控制协议；回声请求消息给目的地并报告是否收到所 希望的ICMP echo （ICMP回声应答）。
Java实现ping功能
07-09
此项目是spring boot+thymeleaf+maven的Java实现ping命令的功能以及端口检测是否开放的功能
JPing:适用于Java的ICMP Ping实用程序
05-18
Java Ping 概述 这是一个简单的工具，可让您查看是否可以通过ICMP ping而不是Java随附的TCP方法访问远程计算机： InetAddress . getByName(ip) . isReachable(timeout); 在某些Windows机器上的实例中，我注意到使用上述Java API的一些错误读物。 JPing仅适用于Windows计算机，因为在端口7被阻塞时会出现错误的读数； 因此，ICMP不是默认方法，这是“ ping”使用的方法。 如果是在Mac或Linux上，则Java的API在所有情况下都可以使用。 为什么 该工具的主要用途是如果您必须按特定顺序启动或关闭网络（示例关闭顺序：工作站然后是服务器，然后是域控制器，然后是RAID和交换机）。 只需对每个硬件执行ping操作，然后决定需要做些什么。 用 由于该方法是静态的，因此只需使用以下调用，其中host是
Java 工具类 ping Ip 是否通
12-18
通过参数 ip 判断网络是否连接通常，public static boolean getPing(String ip){ // 方法一 最常用的 PING 方法 Runtime runtime = Runtime.getRuntime(); // 获取当前程序的运行进对象 Process process = null; // 声明处理类对象
PING+端口扫描
06-06
先PING扫描，实现活动主机的检测，显示IP地址段的主机开放情况，然后可以输入开放的主机的IP，进行端口扫描，多端口或单端口。 这是我的网络编程的作业，确保没问题，可以编译通过，正常运行。
Delphi-Ping.rar_delphi_delphi ping_ping
09-20
可能的结构包括将ping操作封装为单独的类或函数，将UI逻辑与业务逻辑分离。 10. **性能优化**：对于频繁执行的ping操作，优化代码以减少不必要的计算和内存使用是必要的。 综上所述，Delphi中的ping实现涉及到了...
ping 端口 java_Java ping 主机 端口
weixin_35726374的博客
02-15 801
importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.net.InetAddress;importjava.net.InetSocketAddress;importjava.net.Socket;importjava.util.List;importjava...
JAVA里的PING和TELNET
jackyrongvip的专栏
11-13 4748
JAVA里的PING是在JDK 1.5后用了新的函数isreachable去实现,具体介绍如下:InetAddress对象的常用方法 InetAddress类有很多get方法，用来获取主机名，主机地址等信息。主要有：byte[] getAddress() 返回次InetAddress对象的原始IP地址，保存为一个byte数组String getCanonicalHostNa
java ping类_Java代码ping ip工具类
weixin_39665992的博客
02-13 209
packagecom.v.photos.utils;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStream;importjava.io.InputStreamReader;importja...
ping 端口 java
最新发布
11-09
用和引用提供了两种不同的Java实现ping命令和端口检测的方法。其中，引用使用了HuTool中的NetUtil工具类，引用则是使用了Spring Boot、Thymeleaf和Maven实现的Java应用程序。 如果你想使用HuTool中的NetUtil工具类来实现ping命令和端口检测，可以按照以下步骤进行操作： 1.在你的Java项目中引入HuTool依赖。 2.使用NetUtil.ping(String ip)方法来检测IP地址是否能ping通，或使用NetUtil.isUsableLocalPort(int port)方法来检测端口是否开放。 如果你想使用Spring Boot、Thymeleaf和Maven实现ping命令和端口检测的功能，可以按照以下步骤进行操作： 1.创建一个Spring Boot项目，并在pom.xml文件中添加Thymeleaf和Spring Boot Web依赖。 2.创建一个Controller类，在其中编写ping命令和端口检测的方法。 3.创建一个HTML页面，在其中添加表单元素和JavaScript代码，以便用户输入IP地址和端口号，并将结果显示在页面上。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值