一、Socket

       首先，我们需要了解一下socket。

       在上一篇文章当中，我们了解了TCP-IP五层协议模型初识网络：IP、端口、网络协议、TCP-IP五层模型_革凡成圣211的博客-CSDN博客TCP/IP五层协议详解https://blog.csdn.net/weixin_56738054/article/details/128666970?spm=1001.2014.3001.5502

        在这篇文章当中，可以得知，应用层是面向客户的层面。如果发起网络通信，那么应用层需要向传输层发送应用层报文。

       那么，应用层如果想给传输层发送报文，那么就一定需要调用操作系统提供的一些api，那么，建立起应用层和传输层之间的联系的这些api，就是socket。严格意义上面来说，这些socket的api属于传输层。

TCP、UPD协议就是socket的api提供的两种风格。 

 二、TCP、UDP协议的区别

 UPDP协议，概括一下，就是以下几个特点:无连接、不可靠传输、面向数据报、全双工。

 TCP协议，概括一下，就是以下几个特点:有连接、可靠传输、面向字节流、全双工。

有连接&无连接

       这里，想举一个比较形象的例子来说明:

       发短信、发微信这一类的通信、我们通常视为无连接的网络通信。

       原因:当我们发送一条消息的时候，仅仅只负责发出，无论接收方是否收得到、有无作出回应，都会照样发送。不确保接收方是否接收到消息

       而打电话这样的连接方式，就是属于典型的有连接。为什么呢？因为打电话的时候，一定要双方都可以接听电话，才可以互传信息。确保接收方会接收到消息

       总结一下：UDP协议当中，发送方和接收方的运输层进程之间没有建立"握手"，只负责把应用层的协议打包成UDP报文段然后发送，不关注接收方是否能接收到需要发送的信息，因此，UDP协议被视为无连接的协议。

       而TCP协议，在开始传输数据之前，需要经过三次握手，确保接收方一定可以接收到消息，因此TCP协议是有连接的协议

可靠传输&不可靠传输

      所谓的可靠性与不可靠性，实际上就是发送方是否得知接收方已经接收到需要发送的信息。

      例如：在微信，QQ通话当中，发送方仅仅负责发送，但是它无法得知接收方是否已经接收到消息，这种情况下面，我们就认为协议是不可靠的。

      如果发送消息的时候，新增了"已读不回"等类似的功能，确定接收方已经接收到发送方传输的内容，说明协议是可靠的。

 面向数据报&面向字节流

       UDP协议，是面向数据报的协议。

       在上一篇文章当中，我们提到了，传输层协议是以"数据报"为基本单位进行传输的，操作系统不会对消息进行拆分。也就是，直接把应用层传输过来的报文打包成UPD数据段，然后传输到网络层。

       TCP协议，是面向字节流的协议。

       TCP把数据看成一个无结构，但是有序的字节流。

       当使用TCP协议进行传输的时候，一条应用层消息可能会被操作系统分组成多个TCP报文。也就是一个完整的应用层传输过来的一句话，有可能会被操作系统拆分成多个TCP数据段，也有可能仅仅是一个数据段。

       例如应用层打算发送Hi This is JIM这一条消息到传输层的时候，有可能这一条消息被拆分成两个TCP段:

也有可能仅仅是一个TCP段：

 而对于UDP协议，不会对消息进行拆分：

 全双工

       一个通信通道，可以双向传输（既可以发送，又可以接收）

       我们常见的高速公路，一般都是双向六车道，或者双向八车道这样的类型的。这个场景就可以理解为全双工，同时支持发送和接收。

       而半双工，可以理解为不支持发送和接收信号同时进行。例如青藏铁路，因为施工难度极大，并且当时修建铁路的条件有限，因此建立的场景为单向通行的。可以理解为"半双工"。

三、Java当中对于传输层的一些api

     ①DatagramSocket

       在操作系统当中，一切皆为文件。

       使用这个类，表示一个socket对象。在操作系统当中，也是把这个socket当成一个文件来处理的。相当于进程的文件描述符表上面的某一项。

       普通的文件对应的硬件设备为硬盘，而socket文件，对应的硬件设备为网卡。

       一个socket对象，就可以和另外一个主机进行通信了；如果需要和多个主机通信，就需要使用多个socket对象。

      构造方法：

      如果没有指定端口（左图），那么系统会自动分配一个没有被占用的端口。

      如果指定了端口（右图），那么就会把socket和对应的端口关联起来。

      send/receive方法:

      这两个方法，分别代表socket发送、接收应用层的报文的方法。

      其中，需要发送/接收的DatagramPackett就是一个应用层报文。

      close()方法

      用于关闭文件描述符表项，释放进程当中的文件描述符表项所占用的空间。

     ②DatagramPacket

      表述udp当中传输的一个应用层报文。构造这个对象，可以指定一些具体的数据进去。

      构造方法:

 四、实现一个UDP客户端-服务端的代码

        编写之前，我们首先需要做一个假设，此处的UDP的客户端，是运行在客户的手中的，也就是访问某个网站/app的普通用户。

         而服务端，是运行在程序员的电脑当中的

 UDP服务端

       首先，需要明确服务端是需要做什么的。

       步骤①：读取客户端的响应

       步骤②:  根据请求计算响应

       步骤③:  把响应返回给客户端

       需要指定的属性:DatagramSocket socket;用于为客户端提供socket来接收应用层传输来的应用层报文。

       构造方法当中初始化socket对象，并且指定本机当中需要建立通信的端口号。

       需要注意的是，应用层与传输层建立连接的时候，一定要指定socket的端口号，如果不指定，选用无参数的构造方法，那样就无法明确UDP与哪个需要联系的应用层端口建立联系，无法正常通信。

/*** udp服务端* @author 25043*/
public class UdpEchoServer {/*** 与应用层建立联系的datagramSocket对象*/private DatagramSocket datagramSocket;/*** 服务器当中一定要关联一个端口号* 端口号@param port* 异常@throws SocketException*/public UdpEchoServer(int port) throws SocketException {//构造一个对象//让这个socket和客户端主机当中的进程建立联系//port就是对应客户端主机的进程iddatagramSocket=new DatagramSocket(port);}

UDP服务端代码编写

步骤1、

创建应用层报文对象(DatagramSocket receiveSocket)并且在构造方法当中指定一个字节类型的数组，来存储客户端发送来的应用层报文的信息。

DatagramPacket receivePacket=new DatagramPacket(new byte[4096],4096);

 步骤2、

       使用socket来接收这个报文(reveive方法)，并且为这个字节类型的数组填充信息。其中，下划线的部分，是在reveive方法内部进行填充的。

datagramSocket.receive(receivePacket);

  下面，图解一下这个receive方法:

         此处，数据经过层层分用，到达了udp传输层协议。

         当应用程序调用receive方法的时候，相当于执行到了内核udp相关的代码。

         前面的文章当中提到了，udp报文到达传输层的时候，会把udp数据段当中的载荷(也就是去掉udp数据报头之后的内容)取出来，取出来的是应用层的数据，存放到byte数组当中。

         需要注意的是，如果此时服务端没有收到客户端发送过来的数据，那么程序就会在receive方法处阻塞等待。这种阻塞等待，类似于Scanner的等待，就是"等待IO"。

 步骤3、

截取receivePacket当中实际的应用层报文的实际字节数组的长度（调用receivePacket.getData()方法）

 //截取到实际数据，例如应用层发来的"hello"被存放在byte数组当中的时候，可能仅仅占用了//一点点的空间，因此截取的实际长度为"hello"字节数组的长度// packet.getLength()//获取到数据报的实际长度部分String request=new String(receivePacket.getData(),0, receivePacket.getLength());

步骤4、

调用process方法，模拟客户端对报文作出响应。假设返回一个新的字符串(response)

 //这里模拟一下回显服务器String response=process(request);public String process(String request){return "udp服务端已经响应:"+request;}

步骤5、

再次构造应用层报文对象(DatagramSocket responseSocket)，在构造方法当中，指定需要返回给客户端的信息,包括:

         ①response转化为的字节数组

         ②字节数组的实际长度

         ③应用层的IP地址、端口号信息（避免客户端发错响应）

//把需要回应的字符串转化为字节数组
byte[] receiveBytes=response.getBytes();
//获取到这个字节数组的长度
int receiveLength=receiveBytes.length;
//获取到对应客户端的IP和端口号(SocketAddress)
SocketAddress address =receivePacket.getSocketAddress();
//构造返回给客户端的socket对象
DatagramPacket responsePacket=new DatagramPacket(receiveBytes,receiveLength,address);

步骤6、

把responseSocket发送给客户端

//发送给应用层
datagramSocket.send(responsePacket);

步骤7、 

启动服务端

（由于此时还没有客户端给服务端发送数据，因此服务端会在receive方法这里阻塞等待）

  此时指定服务端的端口号为9090。

public static void main(String[] args) throws IOException {UdpEchoServer udpEchoServer=new UdpEchoServer(9090);udpEchoServer.start();}

 整体服务端代码:

/*** udp服务端* @author 25043*/
public class UdpEchoServer {/*** 与应用层建立联系的datagramSocket对象*/private DatagramSocket datagramSocket;/*** 服务器当中一定要关联一个端口号* 端口号@param port* 异常@throws SocketException*/public UdpEchoServer(int port) throws SocketException {//构造一个对象//让这个socket和客户端主机当中的进程建立联系//port就是对应服务端主机的进程端口号datagramSocket=new DatagramSocket(port);}public void start() throws IOException {System.out.println("服务器启动");while (true){//用于接收应用层的内容的字节数组一定要长度足够长DatagramPacket receivePacket=new DatagramPacket(new byte[4096],4096);datagramSocket.receive(receivePacket);//截取到实际数据，例如应用层发来的"hello"被存放在byte数组当中的时候，可能仅仅占用了//一点点的空间，因此截取的实际长度为"hello"字节数组的长度// packet.getLength()//获取到数据报的实际长度部分String request=new String(receivePacket.getData(),0, receivePacket.getLength());//这里模拟一下回显服务器String response=process(request);//把需要回应的字符串转化为字节数组byte[] receiveBytes=response.getBytes();//获取到这个字节数组的长度int receiveLength=receiveBytes.length;//获取到对应客户端的IP和端口号(SocketAddress)SocketAddress address =receivePacket.getSocketAddress();//构造返回给客户端的socket对象DatagramPacket responsePacket=new DatagramPacket(receiveBytes,receiveLength,address);//发送客户端datagramSocket.send(responsePacket);//输出处理结果System.out.println("客户端IP:"+receivePacket.getAddress()+";客户端端口:"+receivePacket.getPort());}}public String process(String request){return "服务端已经响应:"+request;}
}

启动服务端

 可以看到，服务端一直在reveive方法处阻塞等待，等待客户端发送数据：

UDP客户端 

       客户端主要负责的工作就是和服务端建立通信，并且为服务端的receive方法内部输送数据(DatagramPacket)，等待服务端的send方法发送数据(DatagramPacket)并且作出回应。

       客户端的参数

       在客户端服务器当中初始化socket对象。

       既然要发送消息，那么肯定需要知道服务端的端口号+Ip地址 

/*** UDP客户端* @author 25043*/
public class UdpEchoClient {/***与服务端建立联系的socket*/private DatagramSocket socket;/*** 服务端的ip*/private String serverIp;/*** 服务端的端口号*/private int serverPort;/*** 指定服务器的ip以及端口* 服务器的ip@param serverIp* 服务器的端口i@param serverPort* 抛出的异常@throws SocketException*/public UdpEchoClient(String serverIp,int serverPort) throws SocketException {socket=new DatagramSocket();this.serverIp=serverIp;this.serverPort=serverPort;}}

 如果客户端给服务端发送一次请求，

 那么源ip就是客户端ip，源端口号就是客户端的端口；

 目的ip就是服务端的ip地址，目的端口号就是服务端的端口号。

        现在，我们已知的情况就是:

        由于此时客户端和服务端都运行在本机上面，因此客户端和服务端的ip地址都是127.0.0.1。

        启动服务端的的时候，我们已经指定了socket的端口号为9090.那么服务端的进程端口号就是9090.

     可以看到，在这里的客户端，没有指定端口号。

      虽然没有指定，但是我们还是可以了解到一些默认的信息:

     一次通信当中，涉及到的ip和端口号有两组。

      源ip、源端口号。

     目的ip、目的端口号。

       在前面，我们提到的知识当中，如果没有指定端口号，那么在初始化客户端的socket的时候，会被操作系统默认绑定一个没有被其他进程占用的端口号。

      为什么客户端不需要指定一个特定的端口号呢？

      原因就是，如果客户端在编写代码的时候指定了一个端口号，那么这个端口号如果此时被电脑上面的其他进程占用了，就无法正常和服务端通信。

      会抛出一个异常，无法占用端口的异常。

      既然客户端不用指定一个特定的端口号，但是为什么服务端需要指定一个特定的端口号呢？

       客户端，是不可控的。

       客户端，在实际的应用场景当中，是运行在客户的电脑/手机当中的，也许运行着许许多多的应用程序程序（进程），并且哪些进程运行多久，这些完全取决于用户，而不取决于程序员。

       因此无法确定哪个客户端端口什么时间被占用，也就不好指定客户端的端口号。

       既然这样，那就不如让操作系统随机为客户端分配一个空闲的进程（端口号）就好了。

       而服务端，是可控的。

       服务端是运行在程序员的电脑当中的，

       因此，服务端进程占用哪些端口，这些是可以被程序员自己控制的，程序员可以在编写服务端代码的时候，手动控制端口的占用情况。

       如果不设置服务端的端口，那么操作系统会随机为服务端分配一个端口，这样，反而提高了程序员管理代码的难度。

      启动客户端(start方法)

       步骤1、

       从控制台获取用户的输入：

 System.out.println("客户您好，请输入您想向服务器发送的内容:");String request=input.next();

       步骤2、构造UDP请求

       此处的DatagramPacket需要包含request转化的byte[]数组及其长度

       还需要包含服务端的IP、端口号。

//构造UDP请求//转化为字节数组byte[] requestBytes=request.getBytes();int length=requestBytes.length;//指定服务端的Ip以及端口号DatagramPacket requestPacket=new DatagramPacket(requestBytes,length,InetAddress.getByName(serverIp),serverPort);

       步骤3、发送数据包（DatagramPacket）

       到服务端的receive方法当中：

//发送到服务端的receive方法当中socket.send(requestPacket);

       步骤4、构造DatagramPacket并且读取服务器的响应

        此处，将要初始化一定长度的空的字节数组，然后传入到receive方法当中，等待服务器为这个传入的数组填充内容。

 //读取服务器的UDP响应DatagramPacket responsePacket=new DatagramPacket(new byte[4096],4096);//接收服务端的响应socket.receive(responsePacket);

        步骤5、构造响应字符串

//构造响应的字符串String response=new String(responsePacket.getData(),0,responsePacket.getLength());//输出响应的字符串System.out.println(response);

下面，图解一下客户端&服务端通信的整个流程：

 服务端（先启动）：

 客户端（后启动）

 启动服务器

客户端启动：

 可以看到，在启动了服务端、客户端之后，客户端已经收到了服务端的响应了。