【JavaEE 初阶】⽹络编程套接字

一、⽹络编程基础

1.应用层
操作系统提供的一组 api =>socket api(传输层给应用层提供)

2.传输层    两个核心协议.

• TCP
• UDP

差别非常大,编写代码的时候,也是不同的风格 
因此, socket api 提供了两套 

TCP      有连接,   可靠传输,         面向字节流,     全双工
UDP      无连接,   不可靠传输,     面向数据报,     全双工

(1)有连接/无连接    (抽象的概念,虚拟的/逻辑上的连接)
要进行网络通信, 物理上的连接(网线啥的)

• 对于 TCP 来说, TCP 协议中,就保存了对端的信息
  • A 和 B 通信, A 和 B 先建立连接
  •  让 A 保存B 的信息,B 保存 A 的信息 (彼此之间知道,谁是和他建立连接的那个)
• 对于 UDP 来说, UDP 协议本身,不保存对方的信息     就是 无连接

(2) 可靠传输 vs 不可靠传输
    网络上,数据是非常容易出现丢失的情况(丢包)
    光信号/电信号，都可能受到外界的干扰

(3)面向字节流vs 面向数据报
面向字节流, 读写数据的时候,是以字节为单位
面向数据报,读写数据的时候,以一个数据报为单位 (不是字符)    一次必须读写一份udp数据报，不能是半个

• 支持任意长度-->粘包问题
• 不存在粘包-->长度限制

(4)全双工vs半双工

一个通信链路,支持 双向通信 (能读,也能写)
一个通信链路,只支持单向通信(要么读,要么写)

1.为什么需要⽹络编程？

⸺丰富的⽹络资源

        ⽤⼾在浏览器中，打开在线视频⽹站，如优酷看视频，实质是通过⽹络，获取到⽹络上的⼀个视频资源。

        与本地打开视频⽂件类似，只是视频⽂件这个资源的来源是⽹络。

        相⽐本地资源来说，⽹络提供了更为丰富的⽹络资源：

          所谓的⽹络资源，其实就是在⽹络中可以获取的各种数据资源 ， ⽽所有的⽹络资源，都是通过⽹络编程来进⾏数据传输的。

2.什么是⽹络编程

        ⽹络编程，指⽹络上的主机，通过不同的进程，以编程的⽅式实现⽹络通信（或称为⽹络数据传输）。

        当然，我们只要满⾜进程不同就⾏；所以即便是同⼀个主机，只要是不同进程，基于⽹络来传输数据，也属于⽹络编程。

        特殊的，对于开发来说，在条件有限的情况下，⼀般也都是在⼀个主机中运⾏多个进程来完成⽹络编程。

但是，我们⼀定要明确，我们的⽬的是提供⽹络上不同主机，基于⽹络来传输数据资源：

• 进程A：编程来获取⽹络资源
• 进程B：编程来提供⽹络资源

3.⽹络编程中的基本概念

(1)发送端和接收端

在⼀次⽹络数据传输时：

• 发送端：数据的发送⽅进程，称为发送端。发送端主机即⽹络通信中的源主机。
• 接收端：数据的接收⽅进程，称为接收端。接收端主机即⽹络通信中的⽬的主机。
• 收发端：发送端和接收端两端，也简称为收发端。

注意：发送端和接收端只是相对的，只是⼀次⽹络数据传输产⽣数据流向后的概念。

(2)请求和响应

⼀般来说，获取⼀个⽹络资源，涉及到两次⽹络数据传输：

• 第⼀次：请求数据的发送
• 第⼆次：响应数据的发送。

好⽐在快餐店点⼀份炒饭：

先要发起请求：点⼀份炒饭，再有快餐店提供的对应响应：提供⼀份炒饭

(3)客⼾端和服务端

• 服务端：在常⻅的⽹络数据传输场景下，把提供服务的⼀⽅进程，称为服务端，可以提供对外服务。
• 客⼾端：获取服务的⼀⽅进程，称为客⼾端。

对于服务来说，⼀般是提供：

• 客⼾端获取服务资源
• 客⼾端保存资源在服务端

好⽐在银⾏办事：

• 银⾏提供存款服务：⽤⼾（客⼾端）保存资源（现⾦）在银⾏（服务端）
• 银⾏提供取款服务：⽤⼾（客⼾端）获取服务端资源（银⾏替⽤⼾保管的现⾦）

(4)常⻅的客⼾端服务端模型

最常⻅的场景，客⼾端是指给⽤⼾使⽤的程序，服务端是提供⽤⼾服务的程序：

1.  客⼾端先发送请求到服务端
2. 服务端根据请求数据，执⾏相应的业务处理
3. 服务端返回响应：发送业务处理结果
4. 客⼾端根据响应数据，展⽰处理结果（展⽰获取的资源，或提⽰保存资源的处理结果）

二、Socket套接字

1.概念

        Socket套接字，是由系统提供⽤于⽹络通信的技术，是基于TCP/IP协议的⽹络通信的基本操作单元。

        基于Socket套接字的⽹络程序开发就是⽹络编程。

2.分类

Socket套接字主要针对传输层协议划分为如下三类：

• 流套接字：使⽤传输层TCP协议

     TCP，即Transmission Control Protocol（传输控制协议），传输层协议。

     以下为TCP的特点（细节后续再学习）：

• 有连接
• 可靠传输
• ⾯向字节流
• 有接收缓冲区，也有发送缓冲区
• ⼤⼩不限

        对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是⽆边界的数据，可以多次发送，也可以分开多次接收。

• 数据报套接字：使⽤传输层UDP协议

UDP，即User Datagram Protocol（⽤⼾数据报协议），传输层协议。

以下为UDP的特点（细节后续再学习）：

• ⽆连接
• 不可靠传输
• ⾯向数据报
• 有接收缓冲区，⽆发送缓冲区
• ⼤⼩受限：⼀次最多传输64k

        对于数据报来说，可以简单的理解为，传输数据是⼀块⼀块的，发送⼀块数据假如100个字节，必须⼀次发送，接收也必须⼀次接收100个字节，⽽不能分100次，每次接收1个字节。

• 原始套接字

原始套接字⽤于⾃定义传输层协议，⽤于读写内核没有处理的IP协议数据。

我们不学习原始套接字，简单了解即可。

三、Java数据报套接字通信模型

        对于UDP协议来说，具有⽆连接，⾯向数据报的特征，即每次都是没有建⽴连接，并且⼀次发送全部数据报，⼀次接收全部的数据报。

        java中使⽤UDP协议通信，主要基于 DatagramSocket 类来创建数据报套接字，并使⽤ DatagramPacket 作为发送或接收的UDP数据报。

        对于⼀次发送及接收UDP数据报的流程如下：

        以上只是⼀次发送端的UDP数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请求，没有响应。

        对于⼀个服务端来说，重要的是提供多个客⼾端的请求处理及响应，流程如下：

Java流套接字通信模型

Socket编程注意事项

1. 客⼾端和服务端：开发时，经常是基于⼀个主机开启两个进程作为客⼾端和服务端，但真实的场景，⼀般都是不同主机。
2. 注意⽬的IP和⽬的端⼝号，标识了⼀次数据传输时要发送数据的终点主机和进程
3.  Socket编程我们是使⽤流套接字和数据报套接字，基于传输层的TCP或UDP协议，但应⽤层协议， 也需要考虑，这块我们在后续来说明如何设计应⽤层协议。
4. 关于端⼝被占⽤的问题 : 如果⼀个进程A已经绑定了⼀个端⼝，再启动⼀个进程B绑定该端⼝，就会报错，这种情况也叫端⼝被占⽤。

对于java进程来说，端⼝被占⽤的常⻅报错信息如下：

此时需要检查进程B绑定的是哪个端⼝，再查看该端⼝被哪个进程占⽤。以下为通过端⼝号查进程的⽅

式：

• 在cmd输⼊ netstat -ano | findstr 端⼝号 ，则可以显⽰对应进程的pid。如以下命 令显⽰了8888进程的pid

• 在任务管理器中，通过pid查找进程

解决端⼝被占⽤的问题：

• 如果占⽤端⼝的进程A不需要运⾏，就可以关闭A后，再启动需要绑定该端⼝的进程B
• 如果需要运⾏A进程，则可以修改进程B的绑定端⼝，换为其他没有使⽤的端⼝。

四、UDP数据报套接字编程

1.API 介绍

(1）DatagramSocket

DatagramSocket 是UDP Socket⽤于发送和接收UDP数据报。

DatagramSocket 构造⽅法：

方法签名	方法说明
DatagramSocket()	创建一个UDP数据报套接字的Socket，绑定到本机指定的端口(一般用于客户端)
DatagramSocket(int port)	创建一个UDP数据报套接字的Socket，绑定到本机指定的端口(一般用于服务端)

DatagramSocket ⽅法：

方法签名	方法说明
void receive(DatagramPacket p)	从此套接字接收数据报(如果没有接收到数据报，该方法会阻塞等待)
void send(DatagramPacket p)	从此套接字发送数据报包(不会阻塞等待，直接发送)
void close()	关闭此数据报套接字

(2）DatagramPacket

DatagramPacket是UDP Socket发送和接收的数据报。

DatagramPacket 构造⽅法：

方法签名	方法说明
DatagramPacket(bytel] buf, int length)	构造-个DatagramPacket以用来接收数据报，接收的数据保存在字节数组(第一个参数buf)中，接收指定长度(第二个参数length)
DatagramPacket(bytel] buf, int offset, int length,SocketAddress address)	构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组(第一个参数buf)中，从0到指定长度(第二个参数length)。address指定目的主机的IP和端口号

DatagramPacket ⽅法：

方法签名	方法说明
InetAddress getAddress()	从接收的数据报中，获取发送端主机IP地址;或从发送的数据报中，获取接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端口号;或从发送的数据报中，获取接收端主机端口号
byte[] getData()	获取数据报中的数据

构造UDP发送的数据报时，需要传⼊ SocketAddress ，该对象可以使⽤ InetSocketAddress

来创建。

(3）InetSocketAddress

InetSocketAddress （ SocketAddress 的⼦类 ）构造⽅法：

方法签名	方法说明
InetSocketAddress(InetAddress addr, int port)	创建⼀个Socket地址，包含IP地址和端⼝号

2.代码示例

(1）UdpEchoServer

创建socket对象

private DatagramSocket socket=null;
public UdpEchoServer(int port)throws SocketException{//指定固定端口号，使用服务器socket = new DatagramSocket(port);
}

socket 对象代表网卡文件.

读这个文件等于从网卡收数据, 写这个文件等于让网卡发数据 

主循环

//1.读取请求并解析

//DatagramPacket表示一个udp数据报，此处传入的字节数组，相当于保存udp的载荷部分DatagramPacket requestPacket=new DatagramPacket(new byte[4096],4096);
//输出型参数，事前调用空的对象，receive把它从网卡读入进行处理,填充参数socket.receive(requestPacket);
//把读取的二进制数据转换成字符串String request=new String(requestPacket.getData(),0, requestPacket.getLength());

a)构造 DatagramPacket 对象.
DatagramPacket 就代表 UDP 数据包.
报头 + 载荷(new 字节数组保存).

b) 调用 receive .
理解输出型参数

c)把 udp 数据包载荷取出来, 构造成一个 String
1)通过requestPacket,getData()拿到 DatagramPacket 中的字节数组 
2)拿到有效数据的长度requestPacket .getLength()
3)根据字节数组,构造出一个 new String

//2.根据请求，计算响应（key）echo服务器，不需要计算响应，直接返回

    String response=process(request);//后续如果需要进行服务器数据处理，可以采用单独改变此方法private String process(String request) {return request;}

//3.把相应返回给客户端

//不能使用response.length(),这个表示string中字符的个数
//response.getBytes().length,这个表示string中字节的个数
//requestPacket.getSocketAddress()获取报头部分的返回ip和端口号DatagramPacket responsePacket=new DatagramPacket(response.getBytes(),response.getBytes().length
,requestPacket.getSocketAddress());
//此处不能直接发送，udp协议自身没有保存对方的信息（不知道发给谁)
//需要指定目的ip和目的端口，收到请求的源ip和源端口即所需socket.send(responsePacket);

1)response.getBytes()
拿到字符串中的字节数组
2)response.getBytes().length
拿到字节数组的长度
而不是使用字符串长度(单位 字符)
3)requestPacket.getSocketAddress()
这个方法返回的对象中同时包含 IP 和端口
4) new DatagramPacket 是要干啥??
构造响应数据报,上面的是“请求数据报
5)  socket.send(responsePacket);
把构造好的数据报发送出去前提是报头中包含了目的ip和目的端口

//4.打印日志

System.out.printf("[%s:%d]req:%s,resp:%s",requestPacket.getAddress().toString(),
requestPacket.getPort(),request,response);

Q:socket不用close吗?
A:文件要关闭,考虑清楚这个文件对象的 生命周期是怎样的 
此处的 socket 对象, 伴随整个 udp 服务器, 自始至终 
如果服务器关闭 (进程结束)，进程结束时就会自动释放 PCB 的文件描述符表中的所有资源,也不需要手动调用 close 了.

Q:此时没有发送请求or没有客户端，那么服务器程序此时应该怎么样呢？

A:应该在receive处阻塞等待

整体程序

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;public class UdpEchoServer {private DatagramSocket socket=null;public UdpEchoServer(int port)throws SocketException{//指定固定端口号，使用服务器socket = new DatagramSocket(port);}//启动服务器public void start() throws IOException {System.out.println("启动服务器");while(true){//循环一次相当于处理一次请求，处理请求为以下三个过程//1.读取请求并解析//DatagramPacket表示一个udp数据报，此处传入的字节数组，相当于保存udp的载荷部分DatagramPacket requestPacket=new DatagramPacket(new byte[4096],4096);//输出型参数，事前调用空的对象，receive把它从网卡读入进行处理,填充参数socket.receive(requestPacket);//把读取的二进制数据转换成字符串String request=new String(requestPacket.getData(),0, requestPacket.getLength());//2.根据请求，计算响应（key）echo服务器，不需要计算响应，直接返回String response=process(request);//3.把相应返回给客户端//不能使用response.length(),这个表示string中字符的个数//response.getBytes().length,这个表示string中字节的个数//requestPacket.getSocketAddress()获取报头部分的返回ip和端口号DatagramPacket responsePacket=new DatagramPacket(response.getBytes(),response.getBytes().length,requestPacket.getSocketAddress());//此处不能直接发送，udp协议自身没有保存对方的信息（不知道发给谁)//需要指定目的ip和目的端口，收到请求的源ip和源端口即所需socket.send(responsePacket);//4.打印日志System.out.printf("[%s:%d]req:%s,resp:%s\n",requestPacket.getAddress().toString(),requestPacket.getPort(),request,response);}}//后续如果需要进行服务器数据处理，可以采用单独改变此方法public String process(String request) {return request;}public static void main(String[] args) throws IOException {UdpEchoServer server=new UdpEchoServer(9090);server.start();}
}

(2）UdpEchoClient

创建socket对象

 private DatagramSocket socket=null;//和服务端不一样，还需要客户端地址,udp本身不保存对端信息，咱们自己保存一下
private String serverIp;
private int serverPort;public UdpEchoClient(String serverIp,int serverPort)throws SocketException  {this.serverIp=serverIp;this.serverPort=serverPort;socket=new DatagramSocket();//一定不能写端口号，如果固定端口号，一旦该端口被用了，那么当被其他程序占用时，这个程序就会运行失效}

主循环

//1.从控制台读取用户输入的内容

 System.out.println("请输入要发送的内容");
if(!scanner.hasNext()){break;}
String request = scanner.next();

//2.把请求发送给服务端，需要构造请求数据包

 //构造时，不光要有载荷，也要有对应的端口和ipDatagramPacket requestPacket = new DatagramPacket(request.getBytes(), 
request.getBytes().length,InetAddress.getByName(serverIp), serverPort);

//3.发送数据报

socket.send(requestPacket);

//4.接受服务器的回应

DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(responsePacket);
//将从服务器读取的数据进行解析，打印出来
String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
System.out.println(response);

整体程序

import java.io.IOException;
import java.net.*;
import java.util.Scanner;public class UdpEchoClient {private DatagramSocket socket=null;//和服务端不一样，还需要客户端地址,udp本身不保存对端信息，咱们自己保存一下private String serverIp;private int serverPort;public UdpEchoClient(String serverIp,int serverPort)throws SocketException  {this.serverIp=serverIp;this.serverPort=serverPort;socket=new DatagramSocket();//一定不能写端口号，如果固定端口号，一旦该端口被用了，那么当被其他程序占用时，这个程序就会运行失效}public void start() throws IOException {Scanner scanner = new Scanner(System.in);while(true) {//1.从控制台读取用户输入的内容System.out.println("请输入要发送的内容");if(!scanner.hasNext()){break;}String request = scanner.next();//2.把请求发送给服务端，需要构造请求数据包//构造时，不光要有载荷，也要有对应的端口和ipDatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,InetAddress.getByName(serverIp), serverPort);//3.发送数据报socket.send(requestPacket);//4.接受服务器的回应DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);socket.receive(responsePacket);//将从服务器读取的数据进行解析，打印出来String response = new String(responsePacket.getData(), 0, responsePacket.getLength());System.out.println(response);}}public static void main(String[] args) throws IOException {UdpEchoClient client=new UdpEchoClient("127.0.0.1",9090);// 环回ip，表示当前主机，无论真实ip是什么，都可以用它替代，相当于thisclient.start();}}

(3）UDP Dict Server

编写⼀个英译汉的服务器. 只需要重写 process

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;public class UdpDictServer extends UdpEchoServer {private HashMap<String,String>dict=new HashMap<>();public UdpDictServer(int port) throws SocketException {super(port);//初始化词典dict.put("小狗","dog");dict.put("小猫","cat");dict.put("小鸭子","duck");dict.put("小兔子","rabbit");}@Overridepublic String process(String request){return dict.getOrDefault(request,"未找到该词条");}public static void main(String[] args) throws IOException {UdpDictServer dictServer=new UdpDictServer(9090);dictServer.start();}
}

五、TCP流套接字编程

和刚才UDP类似. 实现⼀个简单的英译汉的功能

1.API 介绍

(1）ServerSocket

ServerSocket 是创建TCP服务端Socket的API。

ServerSocket 构造⽅法：

方法签名	方法说明
ServerSocket(int port)	创建一个服务端流套接字Socket，并绑定到指定端口

ServerSocket ⽅法：

方法签名	方法说明
Socket accept()	开始监听指定端口(创建时绑定的端口)，有客户端连接后，返回一个服务端Socket对象， 并基于该Socket建立与客户端的连接，否则阻塞等待
void close()	关闭此套接字

(2）Socket

        Socket 是客⼾端Socket，或服务端中接收到客⼾端建⽴连接（accept⽅法）的请求后，返回的服务端Socket。

        不管是客⼾端还是服务端Socket，都是双⽅建⽴连接以后，保存的对端信息，及⽤来与对⽅收发数据的。

Socket 构造⽅法：

方法签名	方法说明
Socket(String host, int port)	创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接

Socket ⽅法：

方法签名	方法说明
InetAddress getlnetAddress()	返回套接字所连接的地址
InputStream getinputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

代码⽰例

TCP Echo Server

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class TcpEchoServer {private ServerSocket serversocket=null;public TcpEchoServer(int port) throws IOException {serversocket=new ServerSocket(port);}public void start() throws IOException {System.out.println("启动服务器");//这种情况一般不会是用fixedThreadPool，意味着同时处理的客户端数目固定了ExecutorService  executorService= Executors.newCachedThreadPool();while (true){//tcp要先处理客户端发来的连接//通过读写clientsocket和客户端进行通信//如果客户端没有发送消息，accept会阻塞//主线程负责accept，每次accept一个客户端，就创建一个线程，由新线程负责处理客户的请求Socket clientSocket= serversocket.accept();//使用多线程的方式来调整
//           Thread thread=new Thread(()->{
//               try {
//                   processConnect(clientSocket);
//               } catch (IOException e) {
//                   throw new RuntimeException(e);
//               }
//           });
//           thread.start();//使用线程池来调整executorService.submit(()->{try {processConnect(clientSocket);} catch (IOException e) {throw new RuntimeException(e);}});}}
//处理一个客户端的连接，可能会涉及多个客户端的连接和响应private void processConnect(Socket clientSocket) throws IOException {System.out.printf("[%s,%d]客户端上线!\n",clientSocket.getInetAddress(),clientSocket.getPort());try(InputStream inputStream=clientSocket.getInputStream();OutputStream outputStream=clientSocket.getOutputStream()){Scanner scanner=new Scanner(inputStream);PrintWriter printWriter=new PrintWriter(outputStream);while(true){//1.读取请求并解析，可以借助read，也可以借助scanner来辅助完成if(!scanner.hasNext()){System.out.printf("[%s,%d]客户端下线\n",clientSocket.getInetAddress(),clientSocket.getPort());break;}String request=scanner.next();//2.根据请求计算响应String response=process(request);//3.返回响应printWriter.println(response);printWriter.flush();//等价于 outputStream.write(response.getBytes());//4.写日志System.out.printf("[%s,%d]req:%s.resp:%s\n",clientSocket.getInetAddress(),clientSocket.getPort(),request,response);}} catch (IOException e) {throw new RuntimeException(e);}finally {clientSocket.close();}}private String process(String request) {return request;}public static void main(String[] args) throws IOException {TcpEchoServer tcpEchoServer=new TcpEchoServer(9090);tcpEchoServer.start();}
}

TCP Echo Client

import javax.imageio.IIOException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.SocketException;
import java.util.Scanner;public class TcpEchoClient {private Socket clientsocket=null;public TcpEchoClient(String SeverIp, int ServerPort)throws IOException {//直接把字符串的ip设置进来clientsocket=new Socket(SeverIp,ServerPort);}public void start(){Scanner scanner=new Scanner(System.in);try(InputStream inputStream=clientsocket.getInputStream();OutputStream outputStream=clientsocket.getOutputStream()) {//为了方便操作，套壳操作Scanner scannerNet=new Scanner(inputStream);PrintWriter printWriter=new PrintWriter(outputStream);while(true){//1.从控制台读取用户输入String request=scanner.next();//2.直接送给服务器printWriter.println(request);//这一步只是写到缓冲区里面，还要刷新一下才能发送printWriter.flush();//3.读取响应String response=scannerNet.next();//4.打印至控制台System.out.println(response);}} catch (IOException e) {throw new RuntimeException(e);}}public static void main(String[] args) throws IOException {TcpEchoClient tcpEchoClient=new TcpEchoClient("127.0.0.1",9090);tcpEchoClient.start();}}

服务器引⼊多线程

如果只是单个线程, ⽆法同时响应多个客⼾端.

此处给每个客⼾端都分配⼀个线程.

 

//使用多线程的方式来调整
Thread thread=new Thread(()->{try {processConnect(clientSocket);} catch (IOException e) {throw new RuntimeException(e);}
});
thread.start();

服务器引⼊线程池

为了避免频繁创建销毁线程, 也可以引⼊线程池.

  //使用线程池来调整
executorService.submit(()->{try {processConnect(clientSocket);
} catch (IOException e) {throw new RuntimeException(e);
}});

1. 读写数据通过Socket,通过Socket内置的InputStream和 OutputStream,读写基本单位是字节
2. 当前在编写客户端服务器的时候,是需要约定请求/响应之间的分隔符的.(\n)
3. 服务器这边accept得到的socket对象,记得及时关闭
4. 要处理多个客户端,需要搭配多线程/线程池

⻓短连接

TCP发送数据时，需要先建⽴连接，什么时候关闭连接就决定是短连接还是⻓连接：

• 短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能⼀次收发数据。
• ⻓连接：不关闭连接，⼀直保持连接状态，双⽅不停的收发数据，即是⻓连接。也就是说，⻓连接可以多次收发数据。

对⽐以上⻓短连接，两者区别如下：

• 建⽴连接、关闭连接的耗时：短连接每次请求、响应都需要建⽴连接，关闭连接；⽽⻓连接只需要 第⼀次建⽴连接，之后的请求、响应都可以直接传输。相对来说建⽴连接，关闭连接也是要耗时的，⻓连接效率更⾼。
• 主动发送请求不同：短连接⼀般是客⼾端主动向服务端发送请求；⽽⻓连接可以是客⼾端主动发送请求，也可以是服务端主动发。
• 两者的使⽤场景有不同：短连接适⽤于客⼾端请求频率不⾼的场景，如浏览⽹⻚等。⻓连接适⽤于客⼾端与服务端通信频繁的场景，如聊天室，实时游戏等。

六、扩展了解 

基于BIO（同步阻塞IO）的⻓连接会⼀直占⽤系统资源。对于并发要求很⾼的服务端系统来说，这样的消耗是不能承受的。

由于每个连接都需要不停的阻塞等待接收数据，所以每个连接都会在⼀个线程中运⾏。

⼀次阻塞等待对应着⼀次请求、响应，不停处理也就是⻓连接的特性：⼀直不关闭连接，不停的处理请求。

实际应⽤时，服务端⼀般是基于NIO（即同步⾮阻塞IO）来实现⻓连接，性能可以极⼤的提升。