网络编程之基础

 

 

 最近几天学习了Java 网络编程部分，感觉整体的流程虽然不是很繁琐，但是也值得好好总结一下。下面主要对Java Socket TCP/UDP 进行下总结。

 

Socket

    Network API是典型的用于基于TCP/IP网络使Java程序与其他程序通讯，Network API依靠Socket进行通讯。Socket可以看成在两个程序进行通讯连接中的一个端点，一个程序将一段信息写入Socket中，该Socket将这段信息发送给另外一个Socket中，使这段信息能传送到其他程序中。

    Socket可以说是一种针对网络的抽象，应用通过它可以来针对网络读写数据。就像通过一个文件的file handler就可以都写数据到存储设备上一样。根据TCP协议和UDP协议的不同，在网络编程方面就有面向两个协议的不同socket，一个是面向字节流的一个是面向报文的。

 

     对socket的本身组成倒是比较好理解。既然是应用通过socket通信，肯定就有一个服务器端和一个客户端。所以它必然就包含有一个对应的IP地址。另外，在这个地址上server要提供一系列的服务，于是就需要有一系列对应的窗口来提供服务。所以就有一个对应的端口号(Port)。端口号是一个16位的二进制数字，那么范围就是从（0-65535）。IP地址加端口号基本上就构成了socket。

 

     Socket类表现了客户端套接字，它是属于一台或两台计算机的两个TCP通讯端口之间的通讯通道。端口可以连接到本地系统的另一个端口，这样可以避免使用另一台计算机，但是大多数网络软件将使用两台计算机。但是TCP套接字不能与两台以上的计算机通讯。如果需要这种功能，客户端应用程序必须建立多个套接字连接，每台计算机一个套接字。

下面这幅图可以描绘出socket和整个TCP/IP之间的关系：

     我们来分析一下上面的关系图，Host A上的程序A将一段信息写入Socket中，Socket的内容被Host A的网络管理软件访问，并将这段信息通过Host A的网络接口卡发送到Host B，Host B的网络接口卡接收到这段信息后，传送给Host B的网络管理软件，网络管理软件将这段信息保存在Host B的Socket中，然后程序B才能在Socket中阅读这段信息。

 

构造函数　　
　　java.net.Socket类有几个构造函数。其中两个构造函数允许使用布尔型参数指定是否使用UDP或TCP套接字，我们不赞成使用它们。这儿没有使用这两个构造函数，并且没有列举在此处--如果需要UDP功能，请使用DatagramSocket。
　　

　　try
　　{
　　// 连接到指定的主机和端口
　　Socket mySocket = new Socket ( "www.baidu.com", 80);
　　
　　// ......
　　}
　　catch (Exception e)
　　{
　　System.err.println ("Err：" + e);
　　}

　　但是还有很多构造函数可以用于不同的情形。除非特别指出，所有的构造函数都是公共的。
　　
　　· protected Socket ()-使用当前套接字产生组件提供的默认实现建立不连接的套接字。开发者一般不应该使用这个方法，因为它不允许指定主机名称和端口。
　　
　　· Socket (InetAddress address, int port)产生 java.io.IOException异常。
　　
　　· java.lang.SecurityException-建立连接到指定的IP地址和端口的套接字。如果不能建立连接，或连接到主机违反了安全性约束条件（例如某个小的服务程序试图连接到某台计算机而不是载入它的计算机时），就产生这种异常。
　　
　　· Socket (InetAddress address, int port, InetAddress localAddress, int localPort)产生java.io.IOException、java.lang.SecurityException异常-建立连接到指定的地址和端口的套接字，并把它绑定到特定的本地地址和本地端口。默认情况下，使用一个自由（空）的端口，但是在多地址主机环境（例如本地主机有两个或多个的计算机）中，该方法也允许你指定一个特定的端口号、地址。
　　
　　· protected Socket (SocketImpl implementation)--使用特定的套接字的实现（implementation）建立未连接的套接字。通常情况下开发者不应该使用这个方法，因为它允许指定主机名称和端口。
　　
　　· Socket (String host, int port)产生java.net.UnknownHostException、java.io.IOException、java.lang.SecurityException异常--建立连接到特定主机和端口的套接字。这个方法允许指定一个字符串而不是一个InetAddress。如果指定的主机名称不能够解析，就不能建立连接，如果违反了安全性约束条件就产生异常。
　　
　　· Socket (String host, int port, InetAddress localAddress, int localPort)产生java.net.UnknownHostException、java.io.IOException、java.lang.SecurityException异常--建立连接到特定主机和端口的套接字，并绑定到特定的本地端口和地址。它允许指定字符串形式的主机名称，而不是指定InetAddress实例，同时它允许指定一个将绑定的本地地址和端口。这些本地参数对于多地址主机（如果可以通过两个或更多IP地址访问的计算机）是有用的。如果主机名称不能解析，就不能建立连接，如果违反了安全性约束条件会产生异常。

　　
　　1、建立套接字
　　
　　在正常环境下，建立套接字的时候它就连接了某台计算机和端口。尽管有一个空的构造函数，它不需要主机名称或端口，但是它是受保护的（protected），在正常的应用程序中不能够调用它。此外，不存在用于在以后指定这些细节信息的connect()方法，因此在正常的环境下建立套接字的时候就应该连接了。如果网络是好的，在建立连接的时候，调用套接字构造函数将立即返回，但是如果远程计算机没有响应，构造函数方法可能会阻塞一段时间。这是随着系统的不同而不同的，它依赖于多种因素，例如正在使用的操作系统和默认的网络超时设置（例如本地局域网中的一些计算机一般比Internet上的计算机响应得快）。你甚至不能肯定套接字将阻塞多长的时间，但是这是非正常的行为，并且它不会频繁出现。即使如此，在关键事务系统中把此类调用放在第二个线程中或许更合适，这样可以防止应用程序停止。
　　
　　注意
　　
　　在较低的层次，套接字是由套接字产生组件（socket factory）产生的，它是一个负责建立适当的套接字实现的特殊的类。在正常环境下，将会产生标准的java.net.Socket，但是在一些特殊的情形中，例如使用自定义套接字的特殊的网络环境（例如通过使用特殊的代理服务器穿透防火墙），套接字产生组件实际上可能返回一个套接字子类（subclass）。对于错综复杂的Java网络编程比较熟悉，明确为了建立自定义套接字和套接字产生组件的有经验的开发者可以去了解套接字产生组件的细节信息。对于这个主题的更多信息，你可以查看java.net.SocketFactory和java.net.SocketImplFactory类的Java API文档。

　　
　　2、使用套接字
　　
　　套接字可以执行大量的事务，例如读取信息、发送数据、关闭连接、设置套接字选项等等。此外，下面提供的方法可以获取套接字的信息（例如地址和端口位置）：
　　
　　方法
　　
　　· void close()产生java.io.IOException异常--关闭套接字连接。关闭连接可能允许也可能不允许继续发送剩余的数据，这依赖于SO_LINGER套接字选项的设定。我们建议开发者在关闭套接字连接之前清除所有的输出流。
　　
　　· InetAddress getInetAddress()--返回连接到套接字的远程主机的地址。
　　
　　· InputStream getInputStream()产生java.io.IOException异常--返回一个输入流，它从该套接字连接到的应用程序读取信息。
　　
　　· OutputStream getOutputStream()产生java.io.IOException异常--返回一个输出流，它向套接字连接到的应用程序写入信息。
　　
　　· boolean getKeepAlive()产生java.net.SocketException异常--返回SO_KEEPALIVE套接字选项的状态。
　　
　　· InetAddress getLocalAddress()--返回与套接字关联的本地地址（在多地址计算机中有用）。
　　
　　· int getLocalPort()--返回该套接字绑定在本地计算机上的端口号。
　　
　　· int getPort()--返回套接字连接到的远程服务的端口号。
　　
　　· int getReceiveBufferSize()产生java.net.SocketException异常--返回套接字使用的接收缓冲区大小，由SO_RCVBUF套接字选项的值决定。
　　
　　· int getSendBufferSize()产生java.net.SocketException异常--返回套接字使用的发送缓冲区大小，由SO_SNDBUF套接字选项的值决定。
　　
　　· int getSoLinger()产生java.net.SocketException异常--返回SO_LINGER套接字选项的值，它控制连接终止的时候未发送的数据将排队多长时间。
　　
　　· int getSoTimeout()产生java.net.SocketException异常--返回SO_TIMEOUT套接字选项的值，它控制读取操作将阻塞多少毫秒。如果返回值为0，计时器就被禁止了，该线程将无限期阻塞（直到数据可以使用或流被终止）。
　　
　　· boolean getTcpNoDelay()产生java.net.SocketException异常--如果TCP_NODELAY套接字选项的设置打开了返回"true"，它控制是否允许使用Nagle算法。
　　
　　· void setKeepAlive(boolean onFlag)产生java.net.SocketException异常--允许或禁止SO_KEEPALIVE套接字选项。
　　
　　· void setReceiveBufferSize(int size)产生java.net.SocketException异常--修改SO_RCVBUF套接字选项的值，它为操作系统的网络代码推荐用于接收输入的数据的缓冲区大小。并不是每种系统都支持这种功能或允许绝对控制这个特性。如果你希望缓冲输入的数据，我们建议你改用BufferedInputStream或BufferedReader。
　　
　　· void setSendBufferSize(int size)产生java.net.SocketException异常--修改SO_SNDBUF套接字选项的值，它为操作系统的网络代码推荐用于发送输入的数据的缓冲区大小。并不是每种系统都支持这种功能或允许绝对控制这个特性。如果你希望缓冲输入的数据，我们建议你改用BufferedOutputStream或Buffered Writer。
　　
　　· static void setSocketImplFactory (SocketImplFactory factory)产生java.net.SocketException、java.io.IOException、java. lang.SecurityException异常--为JVM指定一个套接字实现的产生组件，它可以已经存在，也可能违反了安全性约束条件，无论是哪种情况都会产生异常。只能指定一个产生组件，当建立套接字的时候都会使用这个产生组件。
　　
　　· void setSoLinger(boolean onFlag, int duration)产生java.net. SocketException、java.lang.IllegalArgumentException异常--激活或禁止SO_LINGER套接字选项（根据布尔型参数onFlag的值），并指定按秒计算的持续时间。如果指定负值，将产生异常。
　　
　　· void setSoTimeout(int duration)产生java.net.SocketException异常--修改SO_TIMEOUT套接字选项的值，它控制读取操作将阻塞多长时间（按毫秒计）。0值会禁止超时设置，引起无限期阻塞。如果发生了超时，当套接字的输入流上发生读取操作的时候，会产生java.io.IOInterruptedException异常。这与内部的TCP计时器是截然不同的，它触发未知报文包的重新发送过程。
　　
　　· void setTcpNoDelay(boolean onFlag)产生java.net.SocketException异常--激活或禁止TCP_NODELAY套接字选项，它决定是否使用Nagle算法。
　　
　　· void shutdownInput()产生java.io.IOException异常--关闭与套接字关联的输入流，并删除所有发送的更多的信息。对输入流的进一步的读取将会遭遇流的结束标识符。

 

     网络应用中基本上都是：TCP(Transmission Control Protocol传输控制协议)和UDP(User Datagram Protocol用户数据报协议)。TCP是面向连接的通信协议；UDP是无连接的通信协议。

 

　 Java分别为TCP和UDP提供了相应的类：

TCP是java.net.ServerSocket(用于服务器端)；

java.net.Socket(用于客户端)；

UDP是java.net.DatagramSocket。

 

下面分别对TCPheUDP做详细介绍

 

1、UDP

     UDP和TCP有两个典型的区别，一个就是它不需要建立连接，另外就是它在每次收发的报文都保留了消息的边界。

 

1.1、DatagramSocket

　　DatagramSocket有如下构造方法:

　　1、DatagramSocket() ：构造数据报套接字并将其绑定到本地主机上任何可用的端口。

　　2、DatagramSocket(int port)：创建数据报套接字并将其绑定到本地主机上的指定端口。

　　3、DatagramSocket(int port, InetAddress laddr)：创建数据报套接字，将其绑定到指定的本地地址。即指定网卡发送和接收数据。

　　如果在创建DatagramSocket对象时，没有指定网卡的IP 地址，在发送数据时,底层驱动程序会自动选择一块网卡去发送,在接收数据时，会接收所有的网卡收到的与端口一致的数据。

　　发送信息时,可以不指定端口号，接收信息时，要指定端口号,因为要接收指定的数据。

　　发送数据使用DatagramSocket.send(DatagramPacket p)方法,接收数据使用DatagramSocket.receive(DatagramPacket p)方法。

 

1.2、DatagramPacket

　　DatagramPacket类有如下构造方法：

　　1、DatagramPacket(byte[] buf, int length)：构造 DatagramPacket，用来接收长度为length的数据包。

　　2、DatagramPacket(byte[] buf, int length, InetAddress address, int port)：构造数据报包,用来将长度为length的包发送到指定主机上的指定端口号。

　　接收数据时使用第一次构造方法,发送数据时使用第二种构造方法。

 

1.3、InetAddress

　　Java中对IP地址进行包装的类

　　DatagramPacket.getAddress()可以获取发送或接收方的IP地址.DatagramPacket.getPort()可以获取发送或接收方的端口。

 

server端

因为UDP协议不需要建立连接，它的过程如下：

1、 构造DatagramSocket实例，指定本地端口。

2、 通过DatagramSocket实例的receive方法接收DatagramPacket.DatagramPacket中间就包含了通信的内容。

3、 通过DatagramSocket的send和receive方法来收和发DatagramPacket.

典型的交互流程代码如下：

// 1. 构建DatagramSocket实例，指定本地端口。
DatagramSocket socket = new DatagramSocket(servPort);

// 2. 构建需要收发的DatagramPacket报文
DatagramPacket packet = new DatagramPacket(new byte[ECHOMAX], ECHOMAX);

while(true)
{
	// 3. 收报文
	socket.receive(packet);
	System.out.println("Handling client at " + packet.getAddress().getHostAddress()
	    + " on port " + packet.getPort());
	// 4. 发报文
	socket.send(packet);
	packet.setLength(ECHOMAX);
}

 

client端

UDP客户端的步骤也比较简单，主要包括下面3步：

1、构造DatagramSocket实例。

2、通过DatagramSocket实例的send和receive方法发送DatagramPacket报文。

3、结束后，调用DatagramSocket的close方法关闭。

因为和TCP不同，UDP发送报文的时候可以在同一个本地端口随意发送给不同的服务器，一般不需要在UDP的DatagramSocket的构造函数中指定目的服务器的地址。

另外，UDP客户端还有一个重要的不同就是，TCP客户端发送echo连接消息之后会在调用read方法的时候进入阻塞状态，而UDP这样却不行。因为UDP中间是可以允许报文丢失的。如果报文丢失了，进程一直在阻塞或者挂起的状态，则进程会永远没法往下走了。所以会一般设置一个setSoTimeout方法，指定在多久的时间内没有收到报文就放弃。也可以通过指定一个数字，循环指定的次数来读取报文，读到就返回，否则就放弃。

 

 一个典型的UDP Client代码示例如下：

// 1. 构造UDP DatagramSocket对象
DatagramSocket socket = new DatagramSocket();
// 2。指定timeout时间，防止进入无限等待状态
socket.setSoTimeout(TIMEOUT);
// 3. 构造收发的报文对象
DatagramPacket sendPacket = new DatagramPacket(bytesToSend,
    bytesToSend.length, serverAddress, servPort);
DatagramPacket receivePacket =
    new DatagramPacket(new byte[bytesToSend.length], bytesToSend.length);
// 4.指定尝试的次数
int tries = 0;
boolean receivedResponse = false;
 do
{
	socket.send(sendPacket);
	try
	{
		socket.receive(receivePacket);
 
		if(!receivePacket.getAddress().equals(serverAddress))
		{
			throw new IOException("Received packet from an unknown source");
		}
		receivedResponse = true;
	}
	catch(InterruptedIOException e)
	{
		tries += 1;
		System.out.println("Timed out, " + (MAXTRIES - tries) + "");
	}
}while((!receivedResponse) && (tries < MAXTRIES));
// 根据是否接收到报文进行反馈
if(receivedResponse)
{
	System.out.println("Received: " + new String(receivePacket.getData()));
}
else
{
	System.out.println("No response -- giving up.");
}
// 5. 关闭socket
socket.close();

 

 

2、TCP

     TCP主要是面向连接的协议，它包含有建立和拆除连接，保证数据流的顺序和正确性等功能。每次对TCP中间的数据操作相当于对一个数据流进行访问。它最典型的特征就是那三次握手的建立连接过程。

 

2.1、ServerSocket

　　编写TCP网络服务程序,首先要用到java.net.ServerSocket类用以创建服务器Socket.它的常用构造方法有：

　　1、ServerSocket(int port)：创建绑定到特定端口的服务器套接字。

　　2、ServerSocket(int port, int backlog)：利用指定的backlog(服务器忙时保持连接请求的等待客户数量)，创建服务器套接字并将其绑定到指定的本地端口号。

　　3、ServerSocket(int port, int backlog， InetAddress bindAddr):使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。

 

　　2.2、Socket

　　客户端要与服务器建立连接,必须先创建一个Socket对象,它的常用构造方法有：

　　1、Socket(String host, int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。

　　2、Socket(InetAddress address， int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口号。

　　3、Socket(InetAddress address, int port，InetAddress localAddr, int localPort)：创建一个套接字并将其连接到指定远程端口上的指定远程地址。

　　4、Socket(String host, int port, InetAddress localAddr, int localPort)：创建一个套接字并将其连接到指定远程主机上的指定远程端口。

　　对于通常情况的应用,使用第1个构造方法来创建客户端的Socket对象，并与服务器建立连接,是非常简单和方便的。

 

　　服务器端程序调用ServerSocket.accept方法等待客户端的连接请求，一旦accept接收了客户端连接请求，该方法返回一个与该客户端建立了专线连接的Socket对象，不用程序去创建这个Socket对象。建立了连接的两个Socket是以IO流的方式进行数据交换的，Java提供了Socket.getInputStream返回Socket的输入流对象,Socket.getOutputStream返回Socket的输出流对象。

 

 

Server端

Server端所要做的事情主要是建立一个通信的端点，然后等待客户端发送的请求。典型的处理步骤如下：

1、构建一个ServerSocket实例，指定本地的端口。这个socket就是用来监听指定端口的连接请求的。

2、重复如下几个步骤：

a. 调用socket的accept()方法来获得下面客户端的连接请求。通过accept()方法返回的socket实例，建立了一个和客户端的新连接。

b. 通过这个返回的socket实例获取InputStream和OutputStream,可以通过这两个stream来分别读和写数据。

c. 结束的时候调用socket实例的close()方法关闭socket连接。

 

 这个流程的典型示例代码如下：

//1. 构造ServerSocket实例，指定服务端口。
ServerSocket servSock = new ServerSocket(servPort);


while(true)
{
	   // 2.调用accept方法，建立和客户端的连接
           Socket clntSock = servSock.accept();
           SocketAddress clientAddress =    
                clntSock.getRemoteSocketAddress();
           System.out.println("Handling client at " + clientAddress);

	    // 3. 获取连接的InputStream,OutputStream来进行数据读写
            InputStream in = clntSock.getInputStream();
            OutputStream out = clntSock.getOutputStream();

            while((recvMsgSize = in.read(receiveBuf)) != -1)
            {
                out.write(receiveBuf, 0, recvMsgSize);
            }   
	    // 4.操作结束，关闭socket.
            clntSock.close();
}  

 

 

Client端

客户端的请求过程稍微有点不一样：

1、构建Socket实例，通过指定的远程服务器地址和端口来建立连接。

2、通过Socket实例包含的InputStream和OutputStream来进行数据的读写。

3、操作结束后调用socket实例的close方法，关闭。

 

示例代码如下：

 

// 1.根据指定的server地址和端口，建立socket连接。
Socket socket = new Socket(server, servPort);

// 2. 根据socket实例获取InputStream, OutputStream进行数据读写。
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
out.write(data);

//3.操作结束，关闭socket.
socket.close();

 

总结：

     TCP的server和client之间通信就好比两个人打电话，需要互相知道对方的电话号码，然后开始对话。所以在两者的连接过程中间需要指定端口和地址。

     UDP的server和client之间的通信就像两个人互相发信。我只需要知道对方的地址，然后就发信过去。对方是否收到我不知道，也不需要专门对口令似的来建立连接。

 

    TCP与UDP区别：

TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。

 

   TCP与UDP的选择  ：

    如果比较UDP包和TCP包的结构，很明显UDP包不具备TCP包复杂的可靠性与控制机制。与TCP协议相同，UDP的源端口数和目的端口数也都支持一台主机上的多个应用。一个16位的UDP包包含了一个字节长的头部和数据的长度，校验码域使其可以进行整体校验。

    很明显，当数据传输的性能必须让位于数据传输的完整性、可控制性和可靠性时，TCP协议是当然的选择。当强调传输性能而不是传输的完整性时，如：音频和多媒体应用，UDP是最好的选择。在数据传输时间很短，以至于此前的连接过程成为整个流量主体的情况下，UDP也是一个好的选择。