摘要：进行TCP协议网络程序的编写，关键在于ServerSocket套接字的熟练使用，TCP通信中所有的信息传输都是依托ServerSocket类的输入输出流进行的。

本文分享自华为云社区《Java利用TCP协议实现客户端与服务器通信【附通信源码】》，作者：灰小猿。

TCP协议概念

我们知道TCP是可靠而非安全的网络协议。它可以保证数据在从一端送至另一端的时候可以准确的送达，并且抵达的数据的排列顺序和送出时的顺序是相同的。因此在进行TCP协议通信的时候，我们首先应该保证客户端和服务器之间的连接通畅。

而TCP协议程序的编写，仍然是依靠套接字Socket类来实现的，并且利用TCP协议进行通信的两个程序之间是有主次之分的，即一个是服务器的程序，另一个是客户端的程序。因此两者的功能和编写上也略有不同。如下图是服务器与客户端之间进行通信的示意图：
v2-f5ea192ca501e59ef4953aac7839b96a_720w.jpg
以上就是在TCP协议中客户端与服务器建立连接的过程示意图。而在这其中起到关键作用的就是服务器端套接字ServerSocket和客户端套接字Socket。通过这两个套接字来建立服务器和客户端，从而利用其中的函数进行数据的通信。

在ServerSocket类中有很多需要注意的地方，接下来大灰狼和大家分享一下ServerSocket类的具体用法：


ServerSocket类

ServerSocket类存在于http://Java.net包中，表示服务器端的套接字，在使用时需要首先导入这个类，我们也知道ServerSocket类的主要功能就是通过指定的端口等待来自于网络中客户端的请求并且进行连接。

值得注意的是：服务器套接字一次只能与一个客户端套接字进行连接，因此如果存在多台客户端同时发送连接请求，则服务器套接字就会将请求的客户端存放到队列中去，然后从中取出一个套接字与服务器建立的套接字进行连接，但是服务器端能够容纳的客户端套接字也不是无限的，当请求连接的数量大于最大容纳量时，那么多出来的请求就会被拒接，一般来说队列的默认大小是50。

ServerSocket类的构造方法通常会抛出IOException异常，具体有以下几种形式：

  • ServerSocket()：创建非绑定服务器套接字
  • ServerSocket(inr port)：创建绑定到特定端口的服务器套接字
  • ServerSocket(int port, int backlog)：利用指定的backlog创建服务器套接字，并将其绑定到指定的服务器端口上，
  • ServerSocket(int port, int backlog, InetAddress bindAddress)：使用指定的端口，侦听backlog和要绑定到本地的IP地址创建服务器。这种情况适用于计算机上有多个网卡和多个IP地址的情况，用户可以明确的规定ServerSocket在哪块网卡或哪个IP地址上等待用户的连接请求。

以下是ServerSocket类中一些常用的方法：
v2-b266ea007a8a0020f96d1834a1bef9b3_720w.jpg
了解了ServerSocket类的基本方法之后，就是如何进行客户端和服务器进行连接的问题了。

在服务器端我们可以调用ServerSocket类的accpet()方法与请求连接的客户机建立连接，这时会返回一个和客户端相连接的Socket对象，这个时候其实已经连接成功了，使用getInetAddress()方法就可以获取到进行请求的客户机的IP地址。

对于如何进行客户端和服务器端数据的通信，就要用到数据的输入流和输出流了，服务器端的Socket对象使用getOutputStream()方法获取到的输出流，将指向客户端的Socket对象使用getInputStream()方法获取到的输入流。由此就实现在服务器向客户端发送数据的一个过程，同样的道理，客户端端的Socket对象使用getOutputStream()方法获取到的输出流，将指向服务器端的Socket对象使用getInputStream()方法获取到的输入流。从而实现由客户端向服务器发送数据的过程。

注意：accpet()方法会阻塞线程的继续执行，如果在对应的接口没有收到客户端的呼叫，则程序会停留在此处，直到获取到客户端的呼叫才会继续向下执行，但是如果服务器没有收到来自客户端的呼叫请求，并且accpet()方法没有发生阻塞，那么通常情况下就是程序出了问题，一般来说可能是使用了一个已经被其他程序占用了的端口号，导致ServerSocket没有绑定成功！遇到这种情况可以尝试更换新的端口号。

了解了TCP协议的通信过程，接下来就是进行TCP通信程序的书写啦！

在网络通信中，如果只要求客户机向服务器发送信息，不要求服务器向客户端反馈信息的行为称为“单向通信”，要求客户机和服务器双方互相通信的过程称为“双向通信”，双向通信只不过是比单向通信多了一个服务器向客户端发送消息的过程，

接下来分别是服务器端和客户端程序的编写：

服务器端程序
  1. package server_1;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStream;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. public class MyTcp {
  11.         private ServerSocket server;        //设置服务器套接字
  12.         private Socket client;                //设置客户端套接字
  14.         //连接客户端函数
  15.         void getServer()
  16.         {
  17.                 try {
  18.                         server = new ServerSocket(1100);        //建立服务器 端口为1100
  19.                         System.out.println("服务器建立成功！正在等待连接......");
  20.                         client = server.accept();        //调用服务器函数对客户端进行连接                        
  21.                         System.out.println("客户端连接成功！ip为：" + client.getInetAddress());        //返回客户端IP               
  22.                         getClientMessage();                //调用信息传输和接收函数
  24.                 } catch (IOException e) {
  25.                         // TODO Auto-generated catch block
  26.                         e.printStackTrace();
  27.                 }
  29.         }
  31.         void getClientMessage()
  32.         {
  33.                 try {
  34.                         while (true) {
  35.                                 InputStream is = client.getInputStream();        //获取到客户端的输入流
  36.                                 byte[] b = new byte[1024];        //定义字节数组
  37.                                 int len = is.read(b);        //由于信息的传输是以二进制的形式，所以要以二进制的形式进行数据的读取
  38.                                 String data = new String(b, 0,len);
  39.                                 System.out.println("客户端发来消息：" + data);
  41.                                 //定义发送给客户端的输出流
  42.                                 OutputStream put = client.getOutputStream();
  43.                                 String putText = "我已经收到！欢迎你！";
  44.                                 put.write(putText.getBytes());        //将输出流信息以二进制的形式进行写入
  45.                         }
  46.                 } catch (Exception e) {
  47.                         // TODO: handle exception
  48.                 }
  49.                 try {
  50.                         //判断客户端字节流不是空，则关闭客户端
  51.                         if (server != null) {
  52.                                 server.close();
  53.                         }
  54.                 } catch (Exception e) {
  55.                         // TODO: handle exception
  56.                 }
  57.         }
  59.         public static void main(String[] args) {
  60.                 // TODO Auto-generated method stub
  61.                 MyTcp myTcp = new MyTcp();        //调用该类生成对象
  62.                 myTcp.getServer();        //调用方法
  63.         }
  65. }
客户端程序  
  1. package client_1;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.net.UnknownHostException;
  10. public class MyClient {
  11.         private Socket client;        //定义客户端套接字
  13.         //建立客户端函数
  14.         void getClient()
  15.         {
  16.                 try {
  17.                         client = new Socket("127.0.0.1", 1100);        //建立客户端，使用的IP为127.0.0.1，端口和服务器一样为1100
  18.                         System.out.println("客户端建立成功！");
  20.                         setClientMessage();                //调用客户端信息写入函数
  21.                 } catch (UnknownHostException e) {
  22.                         // TODO Auto-generated catch block
  23.                         e.printStackTrace();
  24.                 } catch (IOException e) {
  25.                         // TODO Auto-generated catch block
  26.                         e.printStackTrace();
  27.                 }
  28.         }
  30.         //定义客户端信息写入函数
  31.         void setClientMessage()
  32.         {
  33.                 try {               
  34.                         OutputStream pt = client.getOutputStream();                //建立客户端信息输出流
  35.                         String printText = "服务器你好！我是客户端！";        
  36.                         pt.write(printText.getBytes());                //以二进制的形式将信息进行输出
  38.                         InputStream input = client.getInputStream();        //建立客户端信息输入流
  39.                         byte [] b = new byte[1024];                //定义字节数组
  40.                         int len = input.read(b);        //读取接收的二进制信息流
  41.                         String data = new String(b, 0,len);
  42.                         System.out.println("收到服务器消息：" + data);
  44.                 } catch (IOException e) {
  45.                         // TODO Auto-generated catch block
  46.                         e.printStackTrace();
  47.                 }
  49.                 try {
  50.                         //如果客户端信息流不为空，则说明客户端已经建立连接，关闭客户端
  51.                         if (client != null) {
  52.                                 client.close();
  53.                         }
  54.                 } catch (Exception e) {
  55.                         // TODO: handle exception
  56.                 }
  57.         }
  59.         public static void main(String[] args) {
  60.                 // TODO Auto-generated method stub
  61.                 //生成客户端类对象
  62.                 MyClient myClient  = new MyClient();
  63.                 myClient.getClient();
  64.         }
  66. }
同时要注意：在客户端和服务器搭建成功之后，应该先打开服务器等待连接，再打开客户端进行连接，同样在进行关闭时，应该先关闭客户端，再关闭服务器。


以上面程序为例：

打开服务器等待客户端连接
20200704211756399.gif
打开客户端与服务器连接成功，并且实现双向通信：
20200704211828425.gif
注意：当一台机器上安装了多个网络应用程序时，很可能指定的端口已经被占用，甚至还可能遇到之前运行很好的程序突然卡住的情况，这种情况很可能是端口被别的程序占用了，这时可以运行netstat-help来活的帮助，可以使用命令netstat-an来查看该程序所使用的端口。