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

最新推荐文章于 2024-06-14 14:08:37 发布
最新推荐文章于 2024-06-14 14:08:37 发布
阅读量181 收藏
点赞数
文章标签： java 操作系统 runtime
原文链接：https://my.oschina.net/tangcoffee/blog/330223
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png



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<String, Boolean> ping(List<String> ips) {
		LinkedHashMap<String, Boolean> ret = new LinkedHashMap<String, Boolean>();
		Map<String, String> args = new HashMap<String, String>();
		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<String, Boolean> ping(String networkSection,
			int startIp, int endIp) {
		List<String> ips = new ArrayList<String>();
		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<String, Boolean> ping(String networkSection) {
		return ping(networkSection, 1, 254);
	}

//	public LinkedHashMap<String, Boolean> scanPort(String networkSection,
//			int startIp, int endIp, String port) {
//		// throw new RuntimeException();
//		LinkedHashMap<String, Boolean> ret = new LinkedHashMap<String, Boolean>();
//		List<Integer> ports = new ArrayList<Integer>();
//		List<String> ips = new ArrayList<String>();
//		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<String> ips, String port, PrintStream out) {
//		List<Integer> ports = new ArrayList<Integer>();
//
//		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<String> scanPort(String networkSection,
			int startIp, int endIp, String port) {
		List<String> ips = new ArrayList<String>();
		
		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<String> scanPort(List<String> ips, String port) {
		List<String> ret = new ArrayList<String>();
		List<Integer> ports = new ArrayList<Integer>();

		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<String> 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<String,String> args){
		String value = getValue(key);
		if("".equals(value.trim())) return "";
		
		Set<Map.Entry<String,String>>values = args.entrySet();
		for(Map.Entry<String,String> 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<String> ips = new ArrayList<String>();
		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<String,Boolean> ret = d.ping("192.168.2");
//		System.out.println(ret);
		
		List<String> ips = new ArrayList<String>();
		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


转载于:https://my.oschina.net/tangcoffee/blog/330223

weixin_34010949
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Ping端口工具.zip
08-26
可以ping IP+端口是否通信，可以用于测试ip地址加端口是否通网
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扫描-使用Nmap
dongqing0812的专栏
05-25 4524
功能： 主要用于探测主机是否开机以及查看端口的监听状态原理使用Nmap作为底层探查工具，具体使用请访问Nmap官网。使用python模块python-nmap封装调用命令完成扫描。通过使用jython接口完成工具类方法的封装。
Windows和Linux下 Java开发ping工具类
weixin_34018202的博客
09-20 177
  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 检测 端口,java检测端口
weixin_36164462的博客
03-20 1069
场景：java检测端口号是不是配占用java检测端口号是否配占用java检测端口号是否被占用的工具类：package com.frank.util;import java.io.IOException;import java.net.InetAddress;import java.net.Socket;import java.net.UnknownHostException;public clas...
java_PING工具
java之书-资源
04-25 250
PING工具
Java代码ping ip工具类
猪之仆的博客
01-04 599
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服务IP工具类(Windows,Linux环境)
下一个奇迹
05-23 5116
public class PingIpUtils { private static Logger logger = LoggerFactory.getLogger(PingIpUtils.class); /** * @param ipAddress ip地址 * @param pingTimes 次数(一次ping,对方返回的ping的结果的次数)
java ping类_Java代码ping ip工具类
weixin_39665992的博客
02-13 201
packagecom.v.photos.utils;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStream;importjava.io.InputStreamReader;importja...
java代码实现端口是否ping通
榔娃
11-19 1947
案例代码： import cn.hutool.core.net.NetUtil; import java.net.URI; import java.net.URISyntaxException; public JSONObject ping() { //获取ip String ip= "127.0.0.1"; boolean ping = false; try { //根据配置的中心端服务ip和端口号,
Java 工具类 ping Ip 是否通
12-18
通过参数 ip 判断网络是否连接通常，public static boolean getPing(String ip){ // 方法一 最常用的 PING 方法 Runtime runtime = Runtime.getRuntime(); // 获取当前程序的运行进对象 Process process = null; // 声明处理类对象
快速Ping扫描工具
04-09
可以快速扫描本地局域网IP状态，查找空闲IP
PING+端口扫描
06-06
先PING扫描，实现活动主机的检测，显示IP地址段的主机开放情况，然后可以输入开放的主机的IP，进行端口扫描，多端口或单端口。 这是我的网络编程的作业，确保没问题，可以编译通过，正常运行。
ping端口工具.zip
05-26
长ping 可用于被禁止ping 的端口
Java 多线程检测可用端口号
m0_49826240的博客
08-12 361
有一台阿里云的 ESC，想看下哪些端口号可以远程访问。 写了一段 Java 代码，使用 Java 多线程，访问 Linux 的端口号，看看哪些 端口号是可以访问。 工具类，判断是否可以访问该 ip + port import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socket; /** * @author axin * @dat
Java代码判断ip、端口是否可用
zhaoshuangjian
08-10 682
Java代码判断ip、端口是否可用
JAVA实现 ping-ip/telnet-端口
Java_THB的博客
08-14 759
JAVA实现 ping-ip/telnet-端口
ping 端口 java_Java ping 主机 端口
weixin_35726374的博客
02-15 792
importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.net.InetAddress;importjava.net.InetSocketAddress;importjava.net.Socket;importjava.util.List;importjava...
【仿真建模-anylogic】FlowchartPort原理解析
最新发布
zhaoyaxuan001的博客
06-14 301
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
快速ping 端口扫描工具
07-06
快速ping端口扫描工具是一种可以快速检测目标主机上哪些端口是开放的工具。它通过使用多线程技术来提高扫描速度，并且可以扫描常见的端口，例如80（HTTP）、443（HTTPS）等。 该工具的工作原理是通过发送网络数据包...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值