Java套接字编程(上)
副标题#e#
用Java开拓网络软件很是利便和强大，Java的这种气力来历于他独占的一套强大的用于网络的 API，这些API是一系列的类和接口，均位于包java.net和javax.net中。在这篇文章中我们将先容套接字(Socket)慨念，同时以实例说明如何利用Network API哄骗套接字，在完本钱文后，你就可以编写网络低端通讯软件。
什么是套接字(Socket)？
Network API是典范的用于基于TCP/IP网络Java措施与其他措施通讯，Network API依靠Socket举办通讯。Socket可以当作在两个措施举办通讯毗连中的一个端点，一个措施将一段信息写入Socket中，该Socket将这段信息发送给别的一个Socket中，使这段信息能传送到其他措施中。如图1
我们来阐明一下图1，Host A上的措施A将一段信息写入Socket中，Socket的内容被Host A的网络打点软件会见，并将这段信息通过Host A的网络接口卡发送到Host B，Host B的网络接口卡吸收到这段信息后，传送给Host B的网络打点软件，网络打点软件将这段信息生存在Host B的Socket中，然后措施B才气在Socket中阅读这段信息。
假设在图1的网络中添加第三个主机Host C，那么Host A怎么知道信息被正确传送到Host B而不是被传送到Host C中了呢？基于TCP/IP网络中的每一个主机均被赋予了一个独一的IP地点，IP地点是一个32位的无标记整数，由于没有转酿成二进制，因此凡是以小数点脱离，如：198.163.227.6，正如所见IP地点均由四个部门构成，每个部门的范畴都是0-255，以暗示8位地点。
值得留意的是IP地点都是32位地点，这是IP协议版本4（简称Ipv4）划定的，今朝由于IPv4地点已近耗尽，所以IPv6地点正逐渐取代Ipv4地点，Ipv6地点则是128位无标记整数。
假设第二个措施被插手图1的网络的Host B中，那么由Host A传来的信息如何能被正确的传给措施B而不是传给新插手的措施呢？这是因为每一个基于TCP/IP网络通讯的措施都被赋予了独一的端口和端标语，端口是一个信息缓冲区，用于保存Socket中的输入/输出信息，端标语是一个16位无标记整数，范畴是0-65535，以区别主机上的每一个措施（端标语就像衡宇中的房间号），低于256的短标语保存给尺度应用措施，好比pop3的端标语就是110，每一个套接字都组合进了IP地点、端口、端标语，这样形成的整体就可以区别每一个套接字t，下面我们就来谈谈两种套接字：流套接字和自寻址数据套接字。
流套接字（Stream Socket）
无论何时，在两个网络应用措施之间发送和吸收信息时都需要成立一个靠得住的毗连，流套接字依靠TCP协议来担保信息正确达到目标地，实际上，IP包有大概在网络中丢失可能在传送进程中产生错误，任何一种环境产生，作为接管方的 TCP将接洽发送方TCP从头发送这个IP包。这就是所谓的在两个流套接字之间成立靠得住的毗连。
流套接字在C/S措施中饰演一个必须的脚色，客户机措施（需要会见某些处事的网络应用措施）建设一个饰演处事器措施的主机的IP地点和处事器措施（为客户端应用措施提供处事的网络应用措施）的端标语的流套接字工具。
客户端流套接字的初始化代码将IP地点和端标语通报给客户端主机的网络打点软件，打点软件将IP地点和端标语通过NIC通报给处事器端主机；处事器端主机读到颠末NIC通报来的数据，然后查察处事器措施是否处于监听状态，这种监听依然是通过套接字和端口来举办的；假如处事器措施处于监听状态，那么处事器端网络打点软件就向客户机网络打点软件发出一个努力的响应信号，吸收到响应信号后，客户端流套接字初始化代码就给客户措施成立一个端标语，并将这个端标语通报给处事器措施的套接字（处事器措施将利用这个端标语识别传来的信息是否是属于客户措施）同时完成流套接字的初始化。
假如处事器措施没有处于监听状态，那么处事器端网络打点软件将给客户端通报一个消极信号，收到这个消极信号后，客户措施的流套接字初始化代码将抛出一个异常工具而且不成立通讯毗连，也不建设流套接字工具。这种景象就像打电话一样，当有人的时候通讯成立，不然电话将被挂起。
这部门的事情包罗了相关联的三个类：InetAddress, Socket, 和 ServerSocket。 InetAddress工具描画了32位或128位IP地点，Socket工具代表了客户措施流套接字，ServerSocket代表了处事措施流套接字，所有这三个类均位于包java.net中。
#p#副标题#e#
InetAddress类
InetAddress类在网络API套接字编程中饰演了一个重要脚色。参数通报给流套接字类和自寻址套接字类结构器或非结构器要领。InetAddress描写了32位或64位IP地点，要完成这个成果，InetAddress类主要依靠两个支持类Inet4Address 和 Inet6Address，这三个类是担任干系，InetAddrress是父类，Inet4Address 和 Inet6Address是子类。
由于InetAddress类只有一个结构函数，并且不能通报参数，所以不能直接建设InetAddress工具，好比下面的做法就是错误的：
InetAddress ia = new InetAddress ();
但我们可以通过下面的5个工场要领建设来建设一个InetAddress工具或InetAddress数组：
#p#分页标题#e#
. getAllByName(String host)要领返回一个InetAddress工具的引用，每个工具包括一个暗示相应主机名的单独的IP地点，这个IP地点是通过host参数通报的，对付指定的主机假如没有IP地点存在那么这个要领将抛出一个UnknownHostException 异常工具。
. getByAddress(byte [] addr)要领返回一个InetAddress工具的引用，这个工具包括了一个Ipv4地点或Ipv6地点，Ipv4地点是一个4字节数组，Ipv6地点是一个16字节地点数组，假如返回的数组既不是4字节的也不是16字节的，那么要领将会抛出一个UnknownHostException异常工具。
. getByAddress(String host, byte [] addr)要领返回一个InetAddress工具的引用，这个InetAddress工具包括了一个由host和4字节的addr数组指定的IP地点，可能是host和16字节的addr数组指定的IP地点，假如这个数组既不是4字节的也不是16位字节的，那么该要领将抛出一个UnknownHostException异常工具。
. getByName(String host)要领返回一个InetAddress工具，该工具包括了一个与host参数指定的主机相对应的IP地点，对付指定的主机假如没有IP地点存在，那么要领将抛出一个UnknownHostException异常工具。
. getLocalHost()要领返回一个InetAddress工具，这个工具包括了当地机的IP地点，思量到当田主机既是客户措施主机又是处事器措施主机，为制止杂乱，我们将客户措施主机称为客户主机，将处事器措施主机称为处事器主机。
上面讲到的要领均提到返回一个或多个InetAddress工具的引用，实际上每一个要领都要返回一个或多个Inet4Address/Inet6Address工具的引用，挪用者不需要知道引用的子范例，相反挪用者可以利用返回的引用挪用InetAddress工具的非静态要领，包罗子范例的多态以确保重载要领被挪用。
InetAddress和它的子范例工具处理惩罚主机名到主机IPv4或IPv6地点的转换，要完成这个转换需要利用域名系统，下面的代码示范了如何通过挪用getByName(String host)要领得到InetAddress子类工具的要领，这个工具包括了与host参数相对应的IP地点：
InetAddress ia = InetAddress.getByName ("www.bianceng.cn"));
一但得到了InetAddress子类工具的引用就可以挪用InetAddress的各类要领来得到InetAddress子类工具中的IP地点信息，好比，可以通过挪用getCanonicalHostName()从域名处事中得到尺度的主机名；getHostAddress()得到IP地点，getHostName()得到主机名，isLoopbackAddress()判定IP地点是否是一个loopback地点。
List1 是一段示范代码：InetAddressDemo
// InetAddressDemo.java
import java.net.*;
class InetAddressDemo
{
public static void main (String [] args) throws UnknownHostException
{
String host = "localhost";
if (args.length == 1)
host = args [0];
InetAddress ia = InetAddress.getByName (host);
System.out.println ("Canonical Host Name = " +
ia.getCanonicalHostName ());
System.out.println ("Host Address = " +
ia.getHostAddress ());
System.out.println ("Host Name = " +
ia.getHostName ());
System.out.println ("Is Loopback Address = " +
ia.isLoopbackAddress ());
}
}
当无呼吁行参数时，代码输出雷同下面的功效：
Canonical Host Name = localhost
Host Address = 127.0.0.1
Host Name = localhost
Is Loopback Address = true
InetAddressDemo给了你一个指定主机名作为呼吁行参数的选择，假如没有主机名被指定，那么将利用localhost(客户机的)，InetAddressDemo通过挪用getByName(String host)要领得到一个InetAddress子类工具的引用，通过这个引用得到了尺度主机名，主机地点，主机名以及IP地点是否是loopback地点的输出。
Socket类
当客户措施需要与处事器措施通讯的时候，客户措施在客户机建设一个socket工具，Socket类有几个结构函数。两个常用的结构函数是 Socket(InetAddress addr, int port) 和 Socket(String host, int port)，两个结构函数都建设了一个基于Socket的毗连处事器端流套接字的流套接字。对付第一个InetAddress子类工具通过addr参数得到处事器主机的IP地点，对付第二个函数host参数包被分派到InetAddress工具中，假如没有IP地点与host参数相一致，那么将抛出UnknownHostException异常工具。两个函数都通过参数port得到处事器的端标语。假设已经成立毗连了，网络API将在客户端基于Socket的流套接字中绑缚客户措施的IP地点和任意一个端标语，不然两个函数城市抛出一个IOException工具。
#p#分页标题#e#
假如建设了一个Socket工具，那么它大概通过挪用Socket的 getInputStream()要领从处事措施得到输入流读传送来的信息，也大概通过挪用Socket的 getOutputStream()要领得到输出流来发送动静。在读写勾当完成之后，客户措施挪用close()要领封锁流和流套接字，下面的代码建设了一个处事措施主机地点为198.163.227.6，端标语为13的Socket工具，然后从这个新建设的Socket工具中读取输入流，然后再封锁流和Socket工具。
Socket s = new Socket ("198.163.227.6", 13);
InputStream is = s.getInputStream ();
// Read from the stream.
is.close ();
s.close ();
接下面我们将示范一个流套接字的客户措施，这个措施将建设一个Socket工具，Socket将会见运行在指定主机端口10000上的处事措施，假如会见乐成客户措施将给处事措施发送一系列呼吁并打印处事措施的响应。List2使我们建设的措施SSClient的源代码：
Listing 2: SSClient.java
// SSClient.java
import java.io.*;
import java.net.*;
class SSClient
{
public static void main (String [] args)
{
String host = "localhost";
// If user specifies a command-line argument, that argument
// represents the host name.
if (args.length == 1)
host = args [0];
BufferedReader br = null;
PrintWriter pw = null;
Socket s = null;
try
{
// Create a socket that attempts to connect to the server
// program on the host at port 10000.
s = new Socket (host, 10000);
// Create an input stream reader that chains to the socket's
// byte-oriented input stream. The input stream reader
// converts bytes read from the socket to characters. The
// conversion is based on the platform's default character
// set.
InputStreamReader isr;
isr = new InputStreamReader (s.getInputStream ());
// Create a buffered reader that chains to the input stream
// reader. The buffered reader supplies a convenient method
// for reading entire lines of text.
br = new BufferedReader (isr);
// Create a print writer that chains to the socket's byte-
// oriented output stream. The print writer creates an
// intermediate output stream writer that converts
// characters sent to the socket to bytes. The conversion
// is based on the platform's default character set.
pw = new PrintWriter (s.getOutputStream (), true);
// Send the DATE command to the server.
pw.println ("DATE");
// Obtain and print the current date/time.
System.out.println (br.readLine ());
// Send the PAUSE command to the server. This allows several
// clients to start and verifies that the server is spawning
// multiple threads.
pw.println ("PAUSE");
// Send the DOW command to the server.
pw.println ("DOW");
// Obtain and print the current day of week.
System.out.println (br.readLine ());
// Send the DOM command to the server.
pw.println ("DOM");
// Obtain and print the current day of month.
System.out.println (br.readLine ());
// Send the DOY command to the server.
pw.println ("DOY");
// Obtain and print the current day of year.
System.out.println (br.readLine ());
}
catch (IOException e)
{
System.out.println (e.toString ());
}
finally
{
try
{
if (br != null)
br.close ();
if (pw != null)
pw.close ();
if (s != null)
s.close ();
}
catch (IOException e)
{
}
}
}
}
运行这段措施将会获得下面的功效：
Tue Jan 29 18:11:51 CST 2002
TUESDAY
29
29
#p#分页标题#e#
SSClient建设了一个Socket工具与运行在主机端口10000的处事措施接洽，主机的IP地点由host变量确定。SSClient将得到Socket的输入输出流，环绕BufferedReader的输入流和PrintWriter的输出流对字符串举办读写操纵就变得很是容易，SSClient个处事措施发出各类date/time呼吁并获得响应，每个响应均被打印，一旦最后一个响应被打印，将执行Try/Catch/Finally布局的Finally子串，Finally子串将在封锁Socket之前封锁BufferedReader 和 PrintWriter。
在SSClient源代码编译完成后，可以输入java SSClient 来执行这段措施，假如有符合的措施运行在差异的主机上，回收主机名/IP地点为参数的输入方法，好比www.sina.com.cn是运行处事器措施的主机，那么输入方法就是java SSClient www.sina.com.cn。
能力
Socket类包括了很多有用的要领。好比getLocalAddress()将返回一个包括客户措施IP地点的InetAddress子类工具的引用;getLocalPort()将返回客户措施的端标语;getInetAddress()将返回一个包括处事器IP地点的InetAddress子类工具的引用；getPort()将返回处事措施的端标语。
ServerSocket类
由于SSClient利用了流套接字，所以处事措施也要利用流套接字。这就要建设一个ServerSocket工具，ServerSocket有几个结构函数，最简朴的是ServerSocket(int port)，当利用ServerSocket(int port)建设一个ServerSocket工具，port参数通报端标语，这个端口就是处事器监听毗连请求的端口，假如在这时呈现错误将抛出IOException异常工具，不然将建设ServerSocket工具并开始筹备吸收毗连请求。
接下来处事措施进入无限轮回之中，无限轮回从挪用ServerSocket的accept()要领开始，在挪用开始后accept()要领将导致挪用线程阻塞直到毗连成立。在成立毗连后accept()返回一个最近建设的Socket工具，该Socket工具绑定了客户措施的IP地点或端标语。
由于存在单个处事措施与多个客户措施通讯的大概，所以处事措施响应客户措施不该该花许多时间，不然客户措施在得随处事前有大概花许多时间来期待通讯的成立，然而处事措施和客户措施的会话有大概是很长的（这与电话雷同），因此为加速对客户措施毗连请求的响应，典范的要领是处事器主机运行一个靠山线程，这个靠山线程处理惩罚处事措施和客户措施的通讯。
为了示范我们在上面谈到的慨念并完成SSClient措施，下面我们建设一个SSServer措施，措施将建设一个ServerSocket工具来监听端口10000的毗连请求，假如乐成处事措施将期待毗连输入，开始一个线程处理惩罚毗连，并响应来自客户措施的呼吁。下面就是这段措施的代码：
Listing 3: SSServer.java
// SSServer.java
import java.io.*;
import java.net.*;
import java.util.*;
class SSServer
{
public static void main (String [] args) throws IOException
{
System.out.println ("Server starting...\n");
// Create a server socket that listens for incoming connection
// requests on port 10000.
ServerSocket server = new ServerSocket (10000);
while (true)
{
// Listen for incoming connection requests from client
// programs, establish a connection, and return a Socket
// object that represents this connection.
Socket s = server.accept ();
System.out.println ("Accepting Connection...\n");
// Start a thread to handle the connection.
new ServerThread (s).start ();
}
}
}
class ServerThread extends Thread
{
private Socket s;
ServerThread (Socket s)
{
this.s = s;
}
public void run ()
{
BufferedReader br = null;
PrintWriter pw = null;
try
{
// Create an input stream reader that chains to the socket's
// byte-oriented input stream. The input stream reader
// converts bytes read from the socket to characters. The
// conversion is based on the platform's default character
// set.
InputStreamReader isr;
isr = new InputStreamReader (s.getInputStream ());
// Create a buffered reader that chains to the input stream
// reader. The buffered reader supplies a convenient method
// for reading entire lines of text.
br = new BufferedReader (isr);
// Create a print writer that chains to the socket's byte-
// oriented output stream. The print writer creates an
// intermediate output stream writer that converts
// characters sent to the socket to bytes. The conversion
// is based on the platform's default character set.
pw = new PrintWriter (s.getOutputStream (), true);
// Create a calendar that makes it possible to obtain date
// and time information.
Calendar c = Calendar.getInstance ();
// Because the client program may send multiple commands, a
// loop is required. Keep looping until the client either
// explicitly requests termination by sending a command
// beginning with letters BYE or implicitly requests
// termination by closing its output stream.
do
{
// Obtain the client program's next command.
String cmd = br.readLine ();
// Exit if client program has closed its output stream.
if (cmd == null)
break;
// Convert command to uppercase, for ease of comparison.
cmd = cmd.toUpperCase ();
// If client program sends BYE command, terminate.
if (cmd.startsWith ("BYE"))
break;
// If client program sends DATE or TIME command, return
// current date/time to the client program.
if (cmd.startsWith ("DATE") || cmd.startsWith ("TIME"))
pw.println (c.getTime ().toString ());
// If client program sends DOM (Day Of Month) command,
// return current day of month to the client program.
if (cmd.startsWith ("DOM"))
pw.println ("" + c.get (Calendar.DAY_OF_MONTH));
// If client program sends DOW (Day Of Week) command,
// return current weekday (as a string) to the client
// program.
if (cmd.startsWith ("DOW"))
switch (c.get (Calendar.DAY_OF_WEEK))
{
case Calendar.SUNDAY : pw.println ("SUNDAY");
break;
case Calendar.MONDAY : pw.println ("MONDAY");
break;
case Calendar.TUESDAY : pw.println ("TUESDAY");
break;
case Calendar.WEDNESDAY: pw.println ("WEDNESDAY");
break;
case Calendar.THURSDAY : pw.println ("THURSDAY");
break;
case Calendar.FRIDAY : pw.println ("FRIDAY");
break;
case Calendar.SATURDAY : pw.println ("SATURDAY");
}
// If client program sends DOY (Day of Year) command,
// return current day of year to the client program.
if (cmd.startsWith ("DOY"))
pw.println ("" + c.get (Calendar.DAY_OF_YEAR));
// If client program sends PAUSE command, sleep for three
// seconds.
if (cmd.startsWith ("PAUSE"))
try
{
Thread.sleep (3000);
}
catch (InterruptedException e)
{
}
}
while (true);
{
catch (IOException e)
{
System.out.println (e.toString ());
}
finally
{
System.out.println ("Closing Connection...\n");
try
{
if (br != null)
br.close ();
if (pw != null)
pw.close ();
if (s != null)
s.close ();
}
catch (IOException e)
{
}
}
}
}
运行这段措施将获得下面的输出：
Server starting...
Accepting Connection...
Closing Connection...
#p#分页标题#e#
SSServer的源代码声明白一对类：SSServer 和ServerThread；SSServer的main()要领建设了一个ServerSocket工具来监听端口10000上的毗连请求，假如乐成, SSServer进入一个无限轮回中，瓜代挪用ServerSocket的 accept() 要领来期待毗连请求，同时启动靠山线程处理惩罚毗连（accept()返回的请求）。线程由ServerThread担任的start()要领开始，并执行ServerThread的run()要领中的代码。
#p#分页标题#e#
一旦run()要领运行，线程将建设BufferedReader, PrintWriter和 Calendar工具并进入一个轮回，这个轮回由读（通过BufferedReader的 readLine()）来自客户措施的一行文本开始，文本（呼吁）存储在cmd引用的string工具中，假如客户措施过早的封锁输出流，会产生什么呢？谜底是：cmd将得不到赋值。
留意必需思量到这种环境：在处事措施正在读输入流时，客户措施封锁了输出流，假如没有对这种环境举办处理惩罚，那么措施将发生异常。
一旦编译了SSServer的源代码，通过输入Java SSServer来运行措施，在开始运行SSServer后，就可以运行一个或多个SSClient措施。
