Sockets有两种主要的操作方式：面向连接的和无连接的。面向连接的sockets操作就像一部电话，他们必须建立一个连接和一人呼叫。所有的事情在到达时的顺序与它们出发时的顺序时一样。无连接的sockets操作就像是一个邮件投递，没有什么保证，多个邮件可能在到达时的顺序与出发时的顺序不一样。
到底用哪种模式是由应用程序的需要决定的。如果可靠性更重要的话，用面向连接的操作会好一些。比如文件服务器需要保证他们的数据的正确性和有序性。如果一些数据丢失了，系统的有效性将会失去。一些服务器，比如间歇性地发送一些数据块。如果数据丢了的话，服务器并不想要再重新发过一次。因为当数据到达的时候，它可能已经过时了。确保数据的有序性和正确性需要额外的操作的内存消耗，额外的费用将会降低系统的回应速率。
无连接的操作使用数据报协议（UDP）。一个数据报是一个独立的单元，它包含了所有的这次投递的信息。把它想象成一个信封，它有目的地址和要发送的内容。这个模式下的socket不需要连接一个目的的socket，它只是简单地投出数据报。无连接的操作是快速的和高效的，但是数据安全性不佳。
面向连接的操作使用TCP协议。一个这个模式下的socket必须在发送数据之前与目的地的socket取得一个连接。一旦连接建立了，sockets就可以使用一个流接口：打开-读-写-关闭。所有发送的信息都会在另一端以同样的顺序被接收。面向连接的操作比无连接的操作效率更低，但是数据的安全性更高。SUN一直是网络建设的支持者，所以在Java中支持sockets就不足为奇了。实际上，Java降低了建立一个sockets程序的难度。每一个传输模式都被封装到了不同的类中。面向连接的类将会首先被我们讨论。
Java中面向连接的类
在Java中面向连接的类有两种形式，它们分别是客户端和服务器端。客户端这一部分是最简单的，所以我们先讨论它。
列表9.1列出了一个简单的客户端的程序。它向一个服务器发出一个请求，取回一个HTML文档，并把它显示在控制台上。
9.1一个简单的socket客户端
import java.io.*;
import java.net.*;
/**
* 一个简单的从服务器取回一个HTML页面的程序
* 注意:merlin是本地机器的名字
*/
public class SimpleWebClient {
public static void main(String args[])
{
try
{
// 打开一个客户端socket连接
Socket clientSocket1 = new Socket("merlin", 80);
System.out.println("Client1: " + clientSocket1);
// 取得一个网页
getPage(clientSocket1);
}
catch (UnknownHostException uhe)
{
System.out.println("UnknownHostException: " + uhe);
}
catch (IOException ioe)
{
System.err.println("IOException: " + ioe);
}
}
/**
*通过建立的连接请求一个页面,显示回应然后关闭socket
*/
public static void getPage(Socket clientSocket)
{
try
{
// 需要输入和输出流
DataOutputStream outbound = new DataOutputStream(
clientSocket.getOutputStream() );
DataInputStream inbound = new DataInputStream(
clientSocket.getInputStream() );
// 向服务器发出HTTP请求
outbound.writeBytes("GET / HTTP/1.0
");
// 读出回应
String responseLine;
while ((responseLine = inbound.readLine()) != null)
{
// 把每一行显示出来
System.out.println(responseLine);
if ( responseLine.indexOf("") != -1 )
break;
}
// 清除
outbound.close();
inbound.close();
clientSocket.close();
}
catch (IOException ioe)
{
System.out.println("IOException: " + ioe);
}
}
}
回忆一下，一个客户端向一个正在监听的服务器socket发出一个连接。客户端的sockets是用Socket类建立的.下面的程序建立了一个客户端的socket并且连接到了一个主机：
Socket clientSocket = new Socket("merlin", 80);
第一个参数是你想要连接的主机的名称，第二个参数是端口号。一个主机名称指定了目的的名称。端口号指定了由哪个应用程序来接收.在我们的情况下，必须指定80，因为它是默认的HTTP协议的端口。另外部分默认的端口如: echo 7，daytime 13，ftp 21，telnet 23，smtp 25，finger 79，http 80，pop3 110。
因为Socket类是面向连接的，它提供了一个可供读写的流接口。java.io包中的类可以用来访问一个已连接的socket：
DataOutputStream outbound = new DataOutputStream(
clientSocket.getOutputStream() );
DataInputStream inbound = new DataInputStream( clientSocket.getInputStream()
);
一旦流建立了，一般的流操作就可以做了：
outbound.writeBytes("GET / HTTP/1.0
);
String responseLine;
while ( (responseLine = inbound.readLine()) != null)
{
System.out.println(responseLine);
}
以上的小程序请求了一个WEB页面并且把它显示出来。当程序完成之后，连接必须关闭。
outbound.close();
inbound.close();
clientSocket.close();
注意socket流必须首先关闭。所有的的socket流必须在socket关闭之前关闭。这个小程序非常地简单，但是所有的客户端程序都必须遵首下面的基本的步骤：
1.建立客户端socket连接
2.得到socket的读和写的流
3.利用流
4.关闭流
5.关闭socket
使用一个服务器端的socket稍微有一点复杂，它将在下面讲到。
列表9.2 一个简单的服务器程序
/**
* 一个监听端口并提供HTML文档的程序.
*/
class SimpleWebServer {
public static void main(String args[])
{
ServerSocket serverSocket = null;
Socket clientSocket = null;
int connects = 0;
try
{
// 建立一个服务器socket
serverSocket = new ServerSocket(80, 5);
while (connects < 5)
{
// 等待连接
clientSocket = serverSocket.accept();
//服务连接
ServiceClient(clientSocket);
connects++;
}
serverSocket.close();
}
catch (IOException ioe)
{
System.out.println("Error in SimpleWebServer: " + ioe);
}
}
public static void ServiceClient(Socket client) throws IOException
{
DataInputStream inbound = null;
DataOutputStream outbound = null;
try
{
// 得到IO流
inbound = new DataInputStream( client.getInputStream());
outbound = new DataOutputStream( client.getOutputStream());
//格式化输出(回应头和很少的HTML文档)
StringBuffer buffer = new StringBuffer();
String inputLine;
while ((inputLine = inbound.readLine()) != null)
{
//如果到了HTTP请求的尾部,就发送回应
if ( inputLine.equals("") )
{
outbound.writeBytes(buffer.toString());
break;
}
}
}catch (IOException ioe)
{
System.out.println("Error in SimpleWebServer: " + ioe);
}
finally
{
// 清除
System.out.println("Cleaning up connection: " + client);
outbound.close();
inbound.close();
client.close();
client.close();
}
}
}
服务器并不是主动地建立连接。相反地，他们是被动地监听一个客户端的连接请求然后给他们服务。服务器是由类ServerSocket来建立的.下面的程序建立了一个服务器端socket并把它绑定到80端口：
ServerSocket serverSocket = new ServerSocket(80, 5);
第一个参数是服务器要监听的端口，第二个参数是可选的。API文档中说明了这是一个监听时间，但是在传统的socket程序中第二个参数是监听深度。一个服务器可以同时接收多个连接请求,但是每次只能处理一个。监听堆是一个无回答的连接请求队列。上面的请求建立一个连接来处理最后五个请求。如果省略了后面的一个参数，则默认值是50。
ServerSocket serverSocket = new ServerSocket(80, 5);
一旦socket建立了并开始监听连接，进来的连接将会建立并放在监听堆。accetp()方法把在堆中的连接取出来。
Socket clientSocket = serverSocket.accept();
这个方法返回一个用来与来访者对话的客户端连接。服务器本身不可能建立对话，相反地，服务器socket会使用accept()方法来产生一个新的socket。服务器socket依旧打开并排列新的连接请求.
与客户端socket一样。下面的一步建立输入和输出流:
DataInputStream inbound = new DataInputStream( clientSocket.getInputStream() );
DataOutputStream outbound = new DataOutputStream( clientSocket.getOutputStream() );
一般的I/O操作可以在新建的流中运用。在服务器回应前它等待客户端发送一个空白的行。当会话结束时，服务器关闭流和客户端socket。如果在队列中没有请求将会出现什么情况呢？那个方法将会等待一个请求的到来。这个行为叫阻塞。accept()方法将会阻塞服务器线程直到一个呼叫到来。当5个连接处理完闭之后，服务器退出。在队列中的任何呼叫将会被取消。
所有的服务器都要有以下的基本的步骤：
1.建立一个服务器socket并开始监听
2.使用accept()方法取得新的连接
3.建立输入和输出流
4.在已有的协议上产生会话
5.关闭客户端流和socket
6.回到第二步或者到第七步
7.关闭服务器socket
这个应用程序被当作一个重复的服务器。因为它只有在处理完一个进程以后才会接受另一个连接。更多的复杂服务器是并发的。它为每一个请求分配一个线程，而不是来一个处理一个。所以看起来它在同时处理多人请求。所有的商业的服务器都是并发的服务器。
Java数据报类
不像面向连接的类，数据报的客户端和服务器端的类在表面上是一样的。下面的程序建立了一个客户和服务器商的数据报sockets:
DatagramSocket serverSocket = new DatagramSocket( 4545 );
DatagramSocket clientSocket = new DatagramSocket();
服务器用参数4545来指定端口号，由于客户端将要呼叫服务器，客户端可以利用可利用的端口。如果省略第二个参数,程序会让操作系统分配一个可用的端口。客户端可以请求一个指定的端口，但是如果其它的应用程序已经绑定到这个端口之上，请求将会失败。如果你的意图不是作为一个服务器，最好不要指定端口。由于流不能由交谈得到，那么我么如何与一个数据报Socket进行对话？答案在于数据报类。
接收数据报
DatagramPacket类是用来通过DatagramSocket类接收和发送数据的类。packet类包括了连接信息和数据.就如前面所说的一样，数据报是自身独立的传输单元。DatagramPacket类压缩了这些单元。下面的程序表示了用一个数据报socket来接收数据:
DatagramPacket packet = new DatagramPacket(new byte[512], 512);
clientSocket.receive(packet);
packet的构建器需要知道将得到的数据放在哪儿。一个512字节的缓存被建立并且作为构建器的第二个参数。第二个构建器参数是缓存的大小。就像ServerSocket类的accept()方法一样，receive()方法在数据可用之前将会阻塞。
发送数据报
发送数据报是非常地简单地，所有需要的只是一个地址。地址是由InetAddress类来建立的。这个类没有公共的构建器，但是它有几个static的方法，可以用来建立这个类的实例。下面的列表列出了建立InetAddress类的实例的方法:
Public InetAddress Creation Methods
InetAddress getByName(String host);
InetAddress[] getAllByName(String host);
InetAddress getLocalHost();
得到本地主机的地址是非常有用的。只有前面两个方法是用来发送数据包的getByName()和getAllByName()需要目的主机的地址。第一个方法仅仅只是返回第一个符合条件的东西。第二个方法是必须的，因为一台计算机可能有多个地址。在这种情况下，这台计算机被称为multi-homed。所有的建立的方法都被标记为static，它们必须像下面这样得到调用:
InetAddress addr1 = InetAddress.getByName("merlin");
InetAddress addr2[] = InetAddress.getAllByName("merlin");
InetAddress addr3 = InetAddress.getLocalHost();
所有的这些调用都可以掷出一个UnknownHostException违例。如果一台计算机没有连接上DNS服务器，或者主机的确没有找到，这个违例就会被掷出。如果一台计算机没有一个激活的TCP/IP配置，getLocalHost()也为失败并掷出一个违例.
一旦一个地址被确定了，数据报就可以被送出了。下面的程序传输了一个字符串给目的socket:
String toSend = "This is the data to send!";
byte[] sendbuf = new byte[ toSend.length() ];
toSend.getBytes( 0, toSend.length(), sendbuf, 0 );
DatagramPacket sendPacket = new DatagramPacket( sendbuf, sendbuf.length,addr, port);
clientSocket.send( sendPacket );
首先,字符串必须被转换成一个字节数组。然后，一个新的DatagramPacket实例必须被建立。注意构建器的最后两个参数。因为要发送一个包，所以地址和端口必须被给定。一个applet可能可以知道它的服务器的地址，但是服务器如何知道它的客户机的地址呢？当任何一个包被收到后，返回的地址和端口会被解压出来，并通过getAddress()和getPort()方法得到。这就是一个服务器如何回应一个客户端的包：
DatagramPacket sendPacket = new DatagramPacket( sendbuf,
sendbuf.length,
recvPacket.getAddress(),
recvPacket.getPort() );
serverSocket.send( sendPacket );
不像面向连接的操作，数据报服务器其实比数据报客户端更简单:
数据报服务器
一个数据报服务器的基本步骤：
1.在一个指定的端口上建立一个数据报socket
2.用receive方法等待进来的包
3.用特定的协议来回应收到的包
4.回到第二步或继续第二步
5.关闭数据报socket
列表9.3 演示了一个简单的数据报回应服务器。它将回应它收到的包。
import java.io.*;
import java.net.*;
public class SimpleDatagramServer
{
public static void main(String[] args){
DatagramSocket socket = null;
DatagramPacket recvPacket, sendPacket;
try{
socket = new DatagramSocket(4545);
while (socket != null){
recvPacket= new DatagramPacket(new byte[512], 512);
socket.receive(recvPacket);
sendPacket = new DatagramPacket(
recvPacket.getData(), recvPacket.getLength(),
recvPacket.getAddress(), recvPacket.getPort() );
socket.send( sendPacket );
}
}
catch (SocketException se){
System.out.println("Error in SimpleDatagramServer: " + se);
}
catch (IOException ioe){
System.out.println("Error in SimpleDatagramServer: " + ioe);
}
}
}
简单的WEB服务器
一个简单的WEB服务器将由列表9.2这样构建。当然，还必须要对方法和回应事件进行改进。简单的服务器不会分析和存储请求头。新的WEB服务器将分析和存储请求，为以后的处理作准备。为了达到这个目的，你必须有一个包含HTTP请求的类。
HTTPrequest类
列表9.5列出了一个完整的HTTPrequest类.这个类必须包括一个请求头所需的所有信息。
import java.io.*;
import java.util.*;
import java.net.*;
import NameValue;
/**
* 这个类有一个HTTP请求的所有信息
*/
public class HTTPrequest
{
public String version;
public String method;
public String file;
public Socket clientSocket;
public DataInputStream inbound;
public NameValue headerpairs[];
/**
* 建立一个这个类的实例
*/
public HTTPrequest(){
version = null;
method = null;
file = null;
clientSocket = null;
inbound = null;
inbound = null;
headerpairs = new NameValue[0];
}
/**
* 加入一个名称/值对到核心数组
*/
public void addNameValue(String name, String value){
try{
NameValue temp[] = new NameValue[ headerpairs.length + 1 ];
System.arraycopy(headerpairs, 0, temp, 0, headerpairs.length);
temp[ headerpairs.length ] = new NameValue(name, value);
headerpairs = temp;
}
catch (NullPointerException npe){
System.out.println("NullPointerException while adding name-value:" + npe);
}
}
/**
* 以字符串的形式归还这个类
*/
public String toString(){
String s = method + " " + file + " " + version + "
";
for (int x = 0; x < headerpairs.length; x++ )
s += headerpairs[x] + "
";
return s;
}
}
NameValue类简单地存储了两个字符串：name 和 value。当一个新的对象要被加入时，一个新的数组将被分配。新的数组接受了旧的数组和新的成员。旧的数组然后被一个新建的对象覆盖了。
没有评论:
发表评论