「JAVA写WHOIS」java写脚本
今天给各位分享JAVA写WHOIS的知识，其中也会对java写脚本进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、java网络编程与分布式计算 怎么样
- 2、java IP反查域名，我随意输入IP，能得到此IP下所有的域名，例子，思路，资料，什么都要
- 3、怎么用Java实现FTP上传
- 4、如何用Java实现简单whois查询
- 5、whois是什么意思
- 6、各位大哥帮忙做个java作业：用键盘输入一个十进制数编程翻译成二进制数在屏幕输出二进制数。（急急急）
java网络编程与分布式计算 怎么样
本书清晰地介绍了联网的基本原理，在进行网络编程时需要掌握的主要概念，以及在联网时可能遇到的问题和Java的解决方案。同时通过实例来介绍如何运用网络编程技术在Java平台上编写应用程序。本书不仅适合于网络编程的初学者，而且还适合于有一定网络编程经验的程序员。Java网络编程与分布式计算不管你是需要牢固掌握网络编程原理的Java爱好者，还是需要把自己现有的编程技巧应用于Java的网络程序员，本书都将是你的良师益友。在本书中，你不仅可以了解到联网技术中的一些基本概念，而且还可以学习一些实际的应用程序，这些程序运用了成为高效Java网络程序员必须掌握的技巧。同时，作为联网API的进阶指南，本书还可以用做内容全面、范例丰富的参考书。
通过对下列内容的深入介绍，你将深入掌握Java API:
Internet和TCP／IP的体系结构
Java的输入／输出系统
怎样使用UDP和TCP协议编写客户和服务器
多线程应用程序的优点
怎样实现网络协议，并研究客户／服务器实现范例
HTTP以及怎样为Web编写服务器端Java应用程序
RMI和CORBA等分布式计算技术
怎样使用功能强大的JavaMail API访问电子邮件
【图书目录】
第1章 联网原理 1
1.1 什么是网络 1
1.2 网络如何通信 2
1.2.1 编址 2
1.2.2 使用包的数据传输 3
1.3 层间通信 3
1.3.1 第一层—物理层 4
1.3.2 第二层—数据链路层 5
1.3.3 第三层—网络层 5
1.3.4 第四层—传输层 5
1.3.5 第五层—会话层 5
1.3.6 第六层—表示层 5
1.3.7 第七层—应用层 5
1.4 分层的优势 5
1.5 Internet体系结构 6
1.6 Internet应用协议 12
1.6.1 Telnet 12
1.6.2 FTP 12
1.6.3 POP3 12
1.6.4 IMAP 13
1.6.5 SMTP 13
1.6.6 HTTP 13
1.6.7 Finger 13
1.6.8 NNTP 13
1.6.9 WHOIS 13
1.7 TCP/IP协议簇层 13
1.8 安全问题：防火墙与代理服务器 14
1.8.1 防火墙 15
1.8.2 代理服务器 16
1.8.3 开发者的防火墙 16
1.9 小结 16
第2章 Java概述 19
2.1 Java是什么 19
2.2 Java程序设计语言 19
2.2.1 Java的历史和起源 19
2.2.2 Java语言的特性 20
2.3 Java平台 23
2.3.1 Java虚拟机 24
2.3.2 Java运行时环境 24
2.4 Java应用程序接口 25
2.5 考虑Java联网问题 26
2.6 Java网络编程应用 27
2.6.1 网络客户 27
2.6.2 游戏 28
2.6.3 软件代理 28
2.6.4 Web应用 29
2.6.5 分布式系统 30
2.7 Java语言问题 30
2.8 系统属性 34
2.8.1 从命令行传递系统属性 34
2.8.2 编程指定新的系统属性 35
2.9 开发工具 35
2.9.1 集成开发环境 35
2.9.2 Java系统开发包 36
2.10 小结 37
第3章 Internet寻址 39
3.1 局域网地址 39
3.2 IP地址 39
3.2.1 IP地址的结构 40
3.2.2 获取IP地址 41
3.2.3 特殊IP地址 41
3.3 除IP地址以外：域名系统 42
3.3.1 域名是什么 42
3.3.2 域名系统的工作方式 42
3.3.3 域名解析 43
3.4 用Java进行Internet寻址 44
3.4.1 java. net. InetAddress类 44
3.4.2 用InetAddress类来确定本地主机地址 45
3.4.3 使用InetAddress类来找出其他地址 46
3.4.4 Java中的其他地址类型 47
3.5 小结 47
第4章 数据流 49
4.1 概述 49
4.1.1 确切地说，流是什么 49
4.1.2 怎样把流和联网技术联系起来 50
4.2 流的工作方式 50
4.2.1 从输入流中读取数据 51
4.2.2 向输出流写入数据 54
4.3 过滤器流 58
4.3.1 连接过滤器流和已有的流 58
4.3.2 有用的过滤器输入流 59
4.3.3 有用的过滤器输出流 62
4.4 读取器和写入器 65
4.4.1 Unicode字符是什么 65
4.4.2 读取器和写入器的重要性 65
4.4.3 从输入流到读取器 66
4.4.4 低级读取器类型 67
4.4.5 过滤器读取器类型 69
4.4.6 从输出流到写入器 71
4.4.7 低级写入器类型 72
4.4.8 过滤写入器类型 75
4.5 对象持久性和对象序列化 76
4.5.1 什么是对象持久性 76
4.5.2 什么是对象序列化 77
4.5.3 序列化的工作方式 77
4.5.4 把对象读写到流中 78
4.5.5 对象的安全序列化 83
4.5.6 对象序列化和版本控制 83
4.6 小结 84
第5章 用户数据报协议 87
5.1 概述 87
5.2 DatagramPacket类 89
5.2.1 创建DatagramPacket实例 89
5.2.2 使用DatagramPacket对象 90
5.3 DatagramSocket类 90
5.3.1 创建DatagramSocket实例 90
5.3.2 使用DatagramSocket对象 91
5.4 监听UDP包 92
5.5 发送UDP包 93
5.6 用户数据包协议范例 94
5.7 构建UDP客户/服务器 99
5.7.1 构建回显服务 99
5.7.2 构建回显客户 101
5.7.3 运行回显客户和服务器 103
5.8 关于UDP的其他信息 103
5.8.1 缺少可靠交付 104
5.8.2 缺乏可靠包定序 104
5.8.3 缺乏流控制 104
5.9 小结 105
第6章 传输控制协议 107
6.1 概述 107
6.1.1 TCP优于UDP之处 108
6.1.2 使用端口在应用程序间通信 109
6.1.3 套接字操作 110
6.2 TCP和客户/服务器范型 110
6.2.1 客户/服务器范型 110
6.2.2 网络客户 111
6.2.3 网络服务器 111
6.3 TCP套接字和Java 111
6.4 Socket类 112
6.4.1 创建Socket实例 113
6.4.2 使用Socket对象 113
6.4.3 从/向TCP套接字中读取/写入数据 115
6.4.4 套接字选项 116
6.5 创建TCP客户 119
6.6 ServerSocket类 120
6.6.1 创建ServerSocket实例 121
6.6.2 使用ServerSocket 122
6.6.3 接受并处理来自TCP客户的请求 123
6.7 创建TCP服务器 123
6.8 异常处理：套接字特定异常 125
6.8.1 SocketException类 125
6.8.2 BindException类 125
6.8.3 ConnectException类 125
6.8.4 NoRouteToHostException类 126
6.8.5 InterruptedIOException类 126
6.9 小结 126
第7章 多线程应用程序 127
7.1 概述 127
7.1.1 单线程程序设计 127
7.1.2 多进程程序设计 128
7.1.3 多线程程序设计 129
7.2 Java中的多线程 130
7.2.1 用Thread类创建多线程应用程序 130
7.2.2 使用Runnable接口创建多线程应
用程序 132
7.2.3 控制线程 133
7.3 同步 137
7.3.1 方法级同步 137
7.3.2 代码块级同步 141
7.4 线程间通信 142
7.4.1 线程间的通信管道 142
7.4.2 通知等待中的线程发生了某事件 144
7.5 线程组 145
7.5.1 创建线程组 147
7.5.2 使用线程组 147
7.6 线程优先级 150
7.6.1 分配线程优先级 150
7.6.2 获得当前线程优先级 151
7.6.3 限制线程优先级 151
7.7 小结 151
第8章 实现应用协议 153
8.1 概述 153
8.2 应用协议规范 153
8.3 应用协议实现 154
8.3.1 SMTP客户实现 154
8.3.2 POP3客户实现 162
8.3.3 HTTP/1. 0服务器实现 168
8.4 小结 177
第9章 超文本传输协议 179
9.1 概述 179
9.1.1 什么是HTTP 179
9.1.2 HTTP的工作方式 179
9.1.3 Web客户 180
9.1.4 Web服务器 183
9.2 HTTP和Java 186
9.2.1 URL类 186
9.2.2 分析URL对象 188
9.2.3 用URL类检索资源 190
9.2.4 URLConnection类 193
9.2.5 用URLConnection类检索资源 196
9.2.6 使用URLConnection类修改和检
查首部域 199
9.2.7 HttpURLConnection类 202
9.2.8 使用HttpURLConnection类访问
HTTP特有功能 206
9.3 公用网关接口 209
9.3.1 用GET方法发送数据 209
9.3.2 用POST方法发送数据 210
9.3.3 在Java中发送GET请求 210
9.3.4 在Java中发送POST请求 212
9.4 小结 215
第10章 Java servlet 217
10.1 概述 217
10.2 servlet的工作方式 218
10.3 使用servlet 218
10.3.1 GET和POST 220
10.3.2 PUT和DELETE 221
10.3.3 TRACE 221
10.3.4 OPTIONS 221
10.4 运行servlet 221
10.4.1 下载Java Servlet开发包 222
10.4.2 安装servlet引擎 222
10.5 编写简单的servlet 224
10.6 单线程模型 226
10.7 ServletRequest类和HttpServletRequest
类 226
10.8 ServletResponse类和HttpResponse类 228
10.9 ServletConfig类 230
10.10 ServletContext类 231
10.11 servlet异常 232
10.12 cookie 232
10.13 servlet中的HTTP会话管理 235
10.14 小结 237
第11章 远程方法调用 239
11.1 概述 239
11.1.1 什么是远程方法调用 239
11.1.2 比较远程方法调用和远程过程
调用 240
11.2 远程方法调用的工作方式 240
11.3 定义RMI服务接口 242
11.4 实现RMI服务接口 243
11.5 创建存根类和骨架类 244
11.6 创建RMI服务器 245
11.7 创建RMI客户 247
11.8 运行RMI系统 249
11.9 远程方法调用包和类 249
11.10 远程方法调用部署问题 264
11.10.1 动态类加载 264
11.10.2 Java虚拟机之间的差异 266
11.10.3 远程方法调用和applet 267
11.11 利用远程方法调用实现回调 268
11.11.1 面向对象的回调 269
11.11.2 RMI回调 270
11.12 远程对象激活 275
11.12.1 什么是远程对象激活 276
11.12.2 远程对象激活的工作方式 276
11.12.3 创建可激活的远程对象 278
11.12.4 注册可激活远程对象 278
11.13 小结 284
第12章 Java IDL和CORBA 285
12.1 概述 285
12.2 CORBA的体系结构 286
12.2.1 CORBA服务 287
12.2.2 CORBA客户 287
12.3 IDL 288
12.3.1 语言概述 288
12.3.2 IDL数据类型 288
12.3.3 IDL接口 289
12.3.4 IDL模块 289
12.3.5 IDL属性 289
12.3.6 IDL操作 290
12.3.7 IDL异常处理 290
12.4 从IDL到Java 291
12.4.1 一个示例模式 291
12.4.2 把IDL模式映射到Java 291
12.4.3 编写服务者代码 292
12.4.4 编写客户代码 295
12.4.5 把所有东西放到一起 297
12.5 小结 298
第13章 JavaMail 301
13.1 概述 301
13.2 安装JavaMail API 302
13.3 测试JavaMail安装 303
13.4 使用JavaMail API 304
13.4.1 Address类 304
13.4.2 Message类 305
13.4.3 Service类 307
13.4.4 Store类 308
13.4.5 Folder类 309
13.4.6 Transport类 313
13.4.7 Session类 314
13.4.8 用JavaMail发送信息 316
13.4.9 用JavaMail检索信息 319
13.5 JavaMail的高级消息收发功能 323
13.5.1 JavaMail事件处理模型 323
13.5.2 编写JavaMail事件处理器 325
13.5.3 把文件作为附件发送 328
13.6 小结 332
java IP反查域名，我随意输入IP，能得到此IP下所有的域名，例子，思路，资料，什么都要
要解决这个问题，首先要明白域名与ip之间的联系。
我们平时在配置本地ip的时候，都会有一个dns，dns的作用就是将域名解析为ip后，找到对应的ip地址上对应的内容，然后在页面打开展示给你。
你现在想要通过ip来得到域名的话，有两种方式：
一种是你找到一个ip与域名对应的数据，然后根据这个数据来查找；
另外的话就是找一下，看看网络上是否有使用ip来查询并返回域名的接口。
通过这个接口来实现域名反查，但是这种接口一般都是专门做ip解析的公司内部使用的，像万网之类的，像ping和tracert返回的数据都是返回的ip的，不会有域名返回来的。
怎么用Java实现FTP上传
sun.net..，该类库主要提供了用于建立FTP连接的类。利用这些类的方法，编程人员可以远程登录到FTP服务器，列举该服务器上的目录，设置传输协议，以及传送文件。FtpClient类涵盖了几乎所有FTP的功能，FtpClient的实例变量保存了有关建立"代理"的各种信息。下面给出了这些实例变量：
public static boolean useFtpProxy
这个变量用于表明FTP传输过程中是否使用了一个代理，因此，它实际上是一个标记，此标记若为TRUE，表明使用了一个代理主机。
public static String ftpProxyHost
此变量只有在变量useFtpProxy为TRUE时才有效，用于保存代理主机名。
public static int ftpProxyPort此变量只有在变量useFtpProxy为TRUE时才有效，用于保存代理主机的端口地址。
FtpClient有三种不同形式的构造函数，如下所示：
1、public FtpClient(String hostname,int port)
此构造函数利用给出的主机名和端口号建立一条FTP连接。
2、public FtpClient(String hostname)
此构造函数利用给出的主机名建立一条FTP连接，使用默认端口号。
3、FtpClient()
此构造函数将创建一FtpClient类，但不建立FTP连接。这时，FTP连接可以用openServer方法建立。
一旦建立了类FtpClient，就可以用这个类的方法来打开与FTP服务器的连接。类ftpClient提供了如下两个可用于打开与FTP服务器之间的连接的方法。
public void openServer(String hostname)
这个方法用于建立一条与指定主机上的FTP服务器的连接，使用默认端口号。
public void openServer(String host,int port)
这个方法用于建立一条与指定主机、指定端口上的FTP服务器的连接。
打开连接之后，接下来的工作是注册到FTP服务器。这时需要利用下面的方法。
public void login(String username，String password)
此方法利用参数username和password登录到FTP服务器。使用过Intemet的用户应该知道，匿名FTP服务器的登录用户名为anonymous，密码一般用自己的电子邮件地址。
下面是FtpClient类所提供的一些控制命令。
public void cd(String remoteDirectory)：该命令用于把远程系统上的目录切换到参数remoteDirectory所指定的目录。
public void cdUp()：该命令用于把远程系统上的目录切换到上一级目录。
public String pwd()：该命令可显示远程系统上的目录状态。
public void binary()：该命令可把传输格式设置为二进制格式。
public void ascii()：该命令可把传输协议设置为ASCII码格式。
public void rename(String string，String string1)：该命令可对远程系统上的目录或者文件进行重命名操作。
除了上述方法外，类FtpClient还提供了可用于传递并检索目录清单和文件的若干方法。这些方法返回的是可供读或写的输入、输出流。下面是其中一些主要的方法。
public TelnetInputStream list()
返回与远程机器上当前目录相对应的输入流。
public TelnetInputStream get(String filename)
获取远程机器上的文件filename，借助TelnetInputStream把该文件传送到本地。
public TelnetOutputStream put(String filename)
以写方式打开一输出流，通过这一输出流把文件filename传送到远程计算机
package myUtil;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import sun.net.TelnetInputStream;
import sun.net.TelnetOutputStream;
import sun.net.;
/**
* ftp上传，下载
*
* @author why 2009-07-30
*
*/
public class FtpUtil {
private String ip = "";
private String username = "";
private String password = "";
private int port = -1;
private String path = "";
FtpClient ftpClient = null;
OutputStream os = null;
FileInputStream is = null;
public FtpUtil(String serverIP, String username, String password) {
this.ip = serverIP;
this.username = username;
this.password = password;
}
public FtpUtil(String serverIP, int port, String username, String password) {
this.ip = serverIP;
this.username = username;
this.password = password;
this.port = port;
}
/**
* 连接ftp服务器
*
* @throws IOException
*/
public boolean connectServer() {
ftpClient = new FtpClient();
try {
if (this.port != -1) {
ftpClient.openServer(this.ip, this.port);
} else {
ftpClient.openServer(this.ip);
}
ftpClient.login(this.username, this.password);
if (this.path.length() != 0) {
ftpClient.cd(this.path);// path是ftp服务下主目录的子目录
}
ftpClient.binary();// 用2进制上传、下载
System.out.println("已登录到\"" + ftpClient.pwd() + "\"目录");
return true;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
/**
* 断开与ftp服务器连接
*
* @throws IOException
*/
public boolean closeServer() {
try {
if (is != null) {
is.close();
}
if (os != null) {
os.close();
}
if (ftpClient != null) {
ftpClient.closeServer();
}
System.out.println("已从服务器断开");
return true;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
/**
* 检查文件夹在当前目录下是否存在
*
* @param dir
*@return
*/
private boolean isDirExist(String dir) {
String pwd = "";
try {
pwd = ftpClient.pwd();
ftpClient.cd(dir);
ftpClient.cd(pwd);
} catch (Exception e) {
return false;
}
return true;
}
/**
* 在当前目录下创建文件夹
*
* @param dir
* @return
* @throws Exception
*/
private boolean createDir(String dir) {
try {
ftpClient.ascii();
StringTokenizer s = new StringTokenizer(dir, "/"); // sign
s.countTokens();
String pathName = ftpClient.pwd();
while (s.hasMoreElements()) {
pathName = pathName + "/" + (String) s.nextElement();
try {
ftpClient.sendServer("MKD " + pathName + "\r\n");
} catch (Exception e) {
e = null;
return false;
}
ftpClient.readServerResponse();
}
ftpClient.binary();
return true;
} catch (IOException e1) {
e1.printStackTrace();
return false;
}
}
/**
* ftp上传 如果服务器段已存在名为filename的文件夹，该文件夹中与要上传的文件夹中同名的文件将被替换
*
* @param filename
* 要上传的文件（或文件夹）名
* @return
* @throws Exception
*/
public boolean upload(String filename) {
String newname = "";
if (filename.indexOf("/") -1) {
newname = filename.substring(filename.lastIndexOf("/") + 1);
} else {
newname = filename;
}
return upload(filename, newname);
}
/**
* ftp上传 如果服务器段已存在名为newName的文件夹，该文件夹中与要上传的文件夹中同名的文件将被替换
*
* @param fileName
* 要上传的文件（或文件夹）名
* @param newName
* 服务器段要生成的文件（或文件夹）名
* @return
*/
public boolean upload(String fileName, String newName) {
try {
String savefilename = new String(fileName.getBytes("GBK"),
"GBK");
File file_in = new File(savefilename);// 打开本地待长传的文件
if (!file_in.exists()) {
throw new Exception("此文件或文件夹[" + file_in.getName() + "]有误或不存在!");
}
if (file_in.isDirectory()) {
upload(file_in.getPath(), newName, ftpClient.pwd());
} else {
uploadFile(file_in.getPath(), newName);
}
if (is != null) {
is.close();
}
if (os != null) {
os.close();
}
return true;
} catch (Exception e) {
e.printStackTrace();
System.err.println("Exception e in Ftp upload(): " + e.toString());
return false;
} finally {
try {
if (is != null) {
is.close();
}
if (os != null) {
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 真正用于上传的方法
*
* @param fileName
* @param newName
* @param path
* @throws Exception
*/
private void upload(String fileName, String newName, String path)
throws Exception {
String savefilename = new String(fileName.getBytes("ISO-8859-1"), "GBK");
File file_in = new File(savefilename);// 打开本地待长传的文件
if (!file_in.exists()) {
throw new Exception("此文件或文件夹[" + file_in.getName() + "]有误或不存在!");
}
if (file_in.isDirectory()) {
if (!isDirExist(newName)) {
createDir(newName);
}
ftpClient.cd(newName);
File sourceFile[] = file_in.listFiles();
for (int i = 0; i sourceFile.length; i++) {
if (!sourceFile[i].exists()) {
continue;
}
if (sourceFile[i].isDirectory()) {
this.upload(sourceFile[i].getPath(), sourceFile[i]
.getName(), path + "/" + newName);
} else {
this.uploadFile(sourceFile[i].getPath(), sourceFile[i]
.getName());
}
}
} else {
uploadFile(file_in.getPath(), newName);
}
ftpClient.cd(path);
}
/**
* upload 上传文件
*
* @param filename
* 要上传的文件名
* @param newname
* 上传后的新文件名
* @return -1 文件不存在 =0 成功上传，返回文件的大小
* @throws Exception
*/
public long uploadFile(String filename, String newname) throws Exception {
long result = 0;
TelnetOutputStream os = null;
FileInputStream is = null;
try {
java.io.File file_in = new java.io.File(filename);
if (!file_in.exists())
return -1;
os = ftpClient.put(newname);
result = file_in.length();
is = new FileInputStream(file_in);
byte[] bytes = new byte[1024];
int c;
while ((c = is.read(bytes)) != -1) {
os.write(bytes, 0, c);
}
} finally {
if (is != null) {
is.close();
}
if (os != null) {
os.close();
}
}
return result;
}
/**
* 从ftp下载文件到本地
*
* @param filename
* 服务器上的文件名
* @param newfilename
* 本地生成的文件名
* @return
* @throws Exception
*/
public long downloadFile(String filename, String newfilename) {
long result = 0;
TelnetInputStream is = null;
FileOutputStream os = null;
try {
is = ftpClient.get(filename);
java.io.File outfile = new java.io.File(newfilename);
os = new FileOutputStream(outfile);
byte[] bytes = new byte[1024];
int c;
while ((c = is.read(bytes)) != -1) {
os.write(bytes, 0, c);
result = result + c;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (is != null) {
is.close();
}
if (os != null) {
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
/**
* 取得相对于当前连接目录的某个目录下所有文件列表
*
* @param path
* @return
*/
public List getFileList(String path) {
List list = new ArrayList();
DataInputStream dis;
try {
dis = new DataInputStream(ftpClient.nameList(this.path + path));
String filename = "";
while ((filename = dis.readLine()) != null) {
list.add(filename);
}
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
public static void main(String[] args) {
FtpUtil ftp = new FtpUtil("192.168.11.11", "111", "1111");
;
boolean result = ("C:/Documents and Settings/ipanel/桌面/java/Hibernate_HQL.docx", "amuse/audioTest/music/Hibernate_HQL.docx");
System.out.println(result ? "上传成功！" : "上传失败！");
;
/**
* FTP远程命令列表 USER PORT RETR ALLO DELE SITE XMKD CDUP FEAT PASS PASV STOR
* REST CWD STAT RMD XCUP OPTS ACCT TYPE APPE RNFR XCWD HELP XRMD STOU
* AUTH REIN STRU SMNT RNTO LIST NOOP PWD SIZE PBSZ QUIT MODE SYST ABOR
* NLST MKD XPWD MDTM PROT
* 在服务器上执行命令,如果用sendServer来执行远程命令(不能执行本地FTP命令)的话，所有FTP命令都要加上\r\n
* ftpclient.sendServer("XMKD /test/bb\r\n"); //执行服务器上的FTP命令
* ftpclient.readServerResponse一定要在sendServer后调用
* nameList("/test")获取指目录下的文件列表 XMKD建立目录，当目录存在的情况下再次创建目录时报错 XRMD删除目录
* DELE删除文件
*/
}
}
如何用Java实现简单whois查询
package michael.socket;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
* whois查询
* @author michael
* @see
*/
public class WhoisQueryHandler {
/**
* whois.apnic.netbr
* whois.ripe.net
*/
private String server ="whois.ripe.net";
/**
* port
*/
private int port = 43;
/**
* timeout/minute
*/
private int timeout = 0;
/**
* @return the server
*/
public String getServer() {
return server;
}
/**
* @return the port
*/
public int getPort() {
return port;
}
/**
* @return the timeout
*/
public int getTimeout() {
return timeout;
}
/**
* @param pServer the server to set
*/
public void setServer(String pServer) {
server = pServer;
}
/**
* @param pPort the port to set
*/
public void setPort(int pPort) {
port = pPort;
}
/**
* @param pTimeout the timeout to set
*/
public void setTimeout(int pTimeout) {
timeout = pTimeout;
}
/**
* @param ipOrDomain
* @return List
*/
public ListString queryInfoListByWhois(String ipOrDomain) {
Socket qrySocket = null;
BufferedReader br = null;
PrintStream ps = null;
int qryCount = 0;
ListString infoList = new ArrayListString();
infoList.add("查询的对象:"+ ipOrDomain);
while (qryCount 3) {
qryCount++;
try {
qrySocket = new Socket(server, port);
qrySocket.setSoTimeout(timeout * 1000);
ps = new PrintStream(qrySocket.getOutputStream());
ps.println(ipOrDomain);
br = new BufferedReader(new InputStreamReader(qrySocket
.getInputStream()));
String readLine = null;
int lineCount = 0;
System.out.println("Whois query start....");
while ((readLine = br.readLine()) != null lineCount 100) {
System.out.println("readLine ["+ readLine +"]");
if ("".equals(readLine) || readLine.charAt(0) == '%') {
continue;
}
lineCount++;
infoList.add(readLine);
}
System.out.println("whois query info finish");
break;
} catch (Exception e) {
e.printStackTrace();
} finally {
if (null != br) {
try {
br.close();
} catch (Exception e1) {
}
}
if (null != ps) {
try {
ps.close();
} catch (Exception e1) {
}
}
if (null != qrySocket) {
try {
qrySocket.close();
} catch (Exception e1) {
}
}
}
}
return infoList;
}
/**
* @param ipOrDomain
* @return List
*/
public MapString, String queryInfoMapByWhois(String ipOrDomain) {
ListString infoList = this.queryInfoListByWhois(ipOrDomain);
MapString, String infoMap = new LinkedHashMapString, String();
String key ="";
String value ="";
for (String info : infoList) {
if (info.startsWith("") || info.indexOf(':') == -1) {
value = info;
} else {
key = info.substring(0, info.indexOf(':'));
value = info.substring(info.indexOf(':') + 1);
}
if (null == infoMap.get(key)) {
infoMap.put(key, value);
} else {
infoMap.put(key, infoMap.get(key) + value);
}
}
return infoMap;
}
/**
* @param args
*/
public static void main(String[] args) {
WhoisQueryHandler handler = new WhoisQueryHandler();
/**
*"218.202.224.2"br
*"180.168.130.146br
* iteye.combr
* AS9808
*/
String ipOrDomain ="129.42.58.216";
MapString, String map = handler.queryInfoMapByWhois(ipOrDomain);
for (EntryString, String entry : map.entrySet()) {
System.out.println(entry.getKey() +":"+ entry.getValue());
}
}
}
whois是什么意思
whois（读作“Who is”，非缩写）是用来查询域名的IP以及所有者等信息的传输协议。简单说，whois就是一个用来查询域名是否已经被注册，以及注册域名的详细信息的数据库（如域名所有人、域名注册商）。通过whois来实现对域名信息的查询。早期的whois查询多以命令列接口存在，但是现在出现了一些网页接口简化的线上查询工具，可以一次向不同的数据库查询。网页接口的查询工具仍然依赖whois协议向服务器发送查询请求，命令列接口的工具仍然被系统管理员广泛使用。whois通常使用TCP协议43端口。每个域名/IP的whois信息由对应的管理机构保存。
各位大哥帮忙做个java作业：用键盘输入一个十进制数编程翻译成二进制数在屏幕输出二进制数。（急急急）
给你写出来，希望对你学习有帮助：
/*
* @文件名称：Converter.java
* @创建时间：Jun 10, 2010 1:01:56 PM
* @版权信息：Copyright 2010~2015 by Godelegant.
* @修改时间：Jun 10, 2010
*/
import java.util.Scanner;
/**
* 类说明
*
* @简述： 本类的功能
* @作者： godelegant
* @版本： 1.0
* @邮箱： whoisgx@sina.com
*/
public class Converter {
public static void main(String[] args) {
System.out.println("请输入要转化的数");
converter(2);
int[] arr = { 5, 3, 9, 0, 2, 1, 6, 7, 4, 8 };
sort(arr);
}
/**
* 进制转换方法
*/
public static void converter(int type) {
// 使用scanner获取输入
Scanner sc = new Scanner(System.in);
// 获取输入的数,必须是整数，需要其它数，可查看Scanner API
int input = sc.nextInt();
String result = "";
// 转为2进制
if (2 == type) {
result = Integer.toBinaryString(input);
}
// 转为8进制
if (8 == type) {
result = Integer.toOctalString(input);
}
// 转为十进制
if (16 == type) {
result = Integer.toHexString(input);
}
System.out.println("输入的十进制数："+input);
// 输出转化结果
System.out.println("转化为"+type+"进制数："+result);
}
/**
* 排序方法，使用快速排序法
*/
public static void sort(int[] arr) {
int size = arr.length;
for (int i = 0; i size; i++) {
for (int j = i; j size; j++) {
// 交换数
if (arr[i] arr[j]) {
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
}
}
//输出排序结果
for (int i = 0; i size; i++) {
System.out.print(arr[i] + " ");
}
}
}
关于JAVA写WHOIS和java写脚本的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2022-12-15，除非注明，否则均为原创文章，转载请注明出处。