java基础——Java Socket编程(一) Socket编程原理及基本概念

转载来源： https://blog.csdn.net/yjp19871013/article/details/53537398

 

 本篇文章完全是一个铺垫，是为了后面文章提供理论基础，没有这些基础，谈论Socket编程和后续的具体功能实现，都是纸上谈兵，所以还请很少接触Socket编程的看官耐心看完这篇文章，相信对各位有好处。

      看一下网络的分层结构，如下图：

基于TCP/IP协议族的网络，被分为四层，分别为应用层，传输层，网际层以及网络接口层，每一层都设计了相应的协议，我们常用的一些协议(如HTTP，FTP等)，都是属于应用层协议，他们大多是基于传输层的TCP，UDP设计出来的。

        我们的主角Socket，它是应用层之下，传输层之上的一个接口层，也就是操作系统提供给用户访问网络的系统接口，我们可以借助于Socket接口层，对传输层，网际层以及网络接口层进行操作，来实现我们不同的应用层协议，举几个例子，如HTTP是基于TCP实现的，ping和tracerouter是基于ICMP实现的，libpcap(用wireshare做过网络抓包的可能更熟悉)则是直接读取了网络接口层的数据，但是他们的实现，都是借助于Socket完成的。可见，对于应用层，我们想实现网络功能，归根究底都是要通过Socket来实现的，否则，我们无法访问处于操作系统的传输层，网际层以及网络接口层。考虑的本文以及本文之后的其他文章，我们暂时只关注Socket访问传输层的流程，其他的方面可以参看相关书籍，这里推荐《TCP/IP详解 卷一》以及《UNIX网络编程》(UNP)，虽然是Linux C语言开发的书，但是对网络编程讲解的很透彻。这里也向这位大家致敬，虽英年早逝，留给大家的财富不可估量。

        再来了解一下TCP和UDP，两者最大的区别在于，TCP是可靠的，也就是说，我们通过TCP发送的数据，网络协议栈会保证数据可靠的传输到对端，而UDP是不可靠的，如果出现丢包，协议栈不会做任何处理，可靠性的保证交由应用层处理。因此，TCP的性能会比UDP低，但是可靠性会比UDP好很多。除此之外，两者在传输数据时，也有形式上的不同，TCP的数据是流，大家可以类比文件流，而UDP则是基于数据包，也就是说数据会被打成包发送，可能大家会有疑问，这个有什么差别吗？当然有，一个最大的问题就是，TCP没有数据边界，每次接收数据以字节为单位，如果想区分两次发送的数据，除非在数据中加入分割字符(如http的\r\n\r\n)，否则，TCP无法区分数据边界，而UDP每次发送的数据都被打为一个独立的数据包，因此几次发送的数据边界很清晰，我们每次接收也是按照数据包为单位进行接收。对于不同的编程语言或平台，虽然Socket的接口可能不同，但是都提供了基于TCP发送数据的接口以及基于UDP发送数据的接口。

         另外，还有一个概念，对于一个Socket以 客户端的IP及端口号<=>服务器端的IP以及端口号 唯一标识。

        由于后面几篇文章基本上都是基于TCP的，所以这里为了让大家知道Socket是个什么东西，先以UDP为例，后面再详细了解基于TCP的Socket编程。我们使用Java Socket，基于UDP协议，实现字母的大写转换，整个流程是客户端发送字符串给服务器，服务器将字符串转换为全部大写后，发送回客户端，客户端进行显示。

首先看一下服务器端的代码：

 

1. package com.yjp.server;  
2.   
3. import java.io.IOException;  
4. import java.net.DatagramPacket;  
5. import java.net.DatagramSocket;  
6. import java.net.InetAddress;  
7. import java.net.SocketException;  
8. import java.net.UnknownHostException;  
9.   
10. public class ToUpperUDPServer {  
11.       
12.     //服务器IP  
13.     public static final String SERVER_IP = "127.0.0.1";  
14.       
15.     //服务器端口号  
16.     public static final int SERVER_PORT = 10005;  
17.       
18.     //最多处理1024个字符  
19.     public static final int MAX_BYTES = 1024;  
20.       
21.     //UDP使用DatagramSocket发送数据包  
22.     private DatagramSocket serverSocket;  
23.       
24.     /*** 
25.      * 启动服务器 
26.      * @param 服务器监听的端口号，服务器ip无需指定，系统自动分配 
27.      */  
28.     public void startServer(String serverIp, int serverPort) {  
29.         try {  
30.             //创建DatagramSocket  
31.             InetAddress serverAddr = InetAddress.getByName(serverIp);  
32.             serverSocket = new DatagramSocket(serverPort, serverAddr);  
33.               
34.             //创建接收数据的对象  
35.             byte[] recvBuf = new byte[MAX_BYTES];  
36.             DatagramPacket recvPacket = new DatagramPacket(recvBuf , recvBuf.length);  
37.               
38.             //死循环，一直运行服务器  
39.             while (true) {  
40.                 //接收数据，会在这里阻塞，直到有数据到来  
41.                 try {  
42.                     serverSocket.receive(recvPacket);  
43.                 } catch (IOException e) {  
44.                     e.printStackTrace();  
45.                 }  
46.                   
47.                   
48.                 String recvStr = new String(recvPacket.getData(), 0, recvPacket.getLength());  
49.                   
50.                 //拿到対端的ip和端口  
51.                 InetAddress clientAddr = recvPacket.getAddress();  
52.                 int clientPort = recvPacket.getPort();  
53.                   
54.                 //回传数据  
55.                 String upperString = recvStr.toUpperCase();  
56.                 byte[] sendBuf = upperString.getBytes();  
57.                 DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, clientAddr, clientPort);  
58.                 try {  
59.                     serverSocket.send(sendPacket);  
60.                 } catch (IOException e) {  
61.                     e.printStackTrace();  
62.                 }  
63.             }  
64.               
65.         } catch (SocketException e) {  
66.             e.printStackTrace();  
67.         } catch (UnknownHostException e2) {  
68.             e2.printStackTrace();  
69.         } finally {  
70.             //记得关闭Socket  
71.             if (null != serverSocket) {  
72.                 serverSocket.close();  
73.                 serverSocket = null;  
74.             }  
75.         }  
76.     }  
77.       
78.     public static void main(String[] args) {  
79.         ToUpperUDPServer server = new ToUpperUDPServer();  
80.         server.startServer(SERVER_IP, SERVER_PORT);  
81.     }  
82. }  

服务器通过static final常量公开了自己的ip地址以及端口号，还有可以处理的最大字符数，之后，基于给定的ip和port，创建Socket，开始接收数据，收到数据后，转化为大写，返回给客户端。

 

再来看看客户端：

1. package com.yjp.client;  
2.   
3. import java.io.IOException;  
4. import java.net.DatagramPacket;  
5. import java.net.DatagramSocket;  
6. import java.net.InetAddress;  
7. import java.net.SocketException;  
8. import java.net.UnknownHostException;  
9.   
10. import com.yjp.server.ToUpperUDPServer;  
11.   
12. public class ToUpperUDPClient {  
13.       
14.     private DatagramSocket clientSocket;  
15.       
16.     public String toUpperRemote(String serverIp, int serverPort, String str) {  
17.         String recvStr = "";  
18.           
19.         try {  
20.             //创建UDP Socket  
21.             clientSocket = new DatagramSocket();  
22.               
23.             //向服务器发送数据  
24.             byte[] sendBuf;  
25.             sendBuf = str.getBytes();  
26.             InetAddress serverAddr = InetAddress.getByName(serverIp);  
27.             DatagramPacket sendPacket   
28.                 = new DatagramPacket(sendBuf ,sendBuf.length , serverAddr , serverPort);  
29.             try {  
30.                 clientSocket.send(sendPacket);  
31.             } catch (IOException e) {  
32.                 e.printStackTrace();  
33.             }  
34.               
35.             //接收服务器的响应  
36.             byte[] recvBuf = new byte[ToUpperUDPServer.MAX_BYTES];  
37.             DatagramPacket recvPacket  
38.                 = new DatagramPacket(recvBuf , recvBuf.length);  
39.             try {  
40.                 clientSocket.receive(recvPacket);  
41.             } catch (IOException e) {  
42.                 e.printStackTrace();  
43.             }  
44.               
45.             //显示响应  
46.             recvStr = new String(recvPacket.getData() , 0 ,recvPacket.getLength());  
47.         } catch (SocketException e1) {  
48.             e1.printStackTrace();  
49.         } catch (UnknownHostException e2) {  
50.             e2.printStackTrace();  
51.         } finally {  
52.             if (null != clientSocket) {  
53.                 clientSocket.close();  
54.                 clientSocket = null;  
55.             }  
56.         }  
57.           
58.         return recvStr;  
59.     }  
60.       
61.     public static void main(String[] args) {  
62.         ToUpperUDPClient client = new ToUpperUDPClient();  
63.         String recvStr = client.toUpperRemote(ToUpperUDPServer.SERVER_IP, ToUpperUDPServer.SERVER_PORT, "aaaAAAbbbBBBcccCCC");  
64.         System.out.println("收到:" + recvStr);  
65.     }  
66. }  

客户端通过借助于服务器端的常量，获知服务器的IP以及端口号，然后向该服务器发送字符串，然后接收服务器的响应，输出响应，响应结果如下所示：

 

收到:AAAAAABBBBBBCCCCCC