6.网络编程套接字(下)
文章目录
- 4.TCP流套接字编程
- 4.1ServerSocket API
- 4.2Socket API
- 4.3TCP中的长短连接
- 4.4示例一:一发一收(长连接)
- 4.4.1TCP服务端
- 4.4.2TCP客户端
- 4.5示例二:请求响应(短连接)
- 4.5.1TCP服务端
- 4.5.2TCP客户端
- 4.6再谈协议
- 4.6.1回顾并理解为什么需要协议
- 4.6.2封装/分用 vs 序列化/反序列化
- 4.6.3如何设计协议
- 4.7示例三:多线程+自定义协议
- 4.7.1本示例中的自定义协议
- 4.7.2执行流程(xml json protobuffer)
- 4.7.3请求类
- 4.7.4响应类
- 4.7.5TCP服务端
- 4.7.6TCP客户端
- 4.8长连接 vs 短连接
- 4.9UDP vs TCP
大家好,我是晓星航。今天为大家带来的是 网络编程套接字(下) 相关的讲解!😀
4.TCP流套接字编程
有连接(打电话)
可靠传输(有已读功能(例如抖音消息已读不回QAQ🎃))
面向字节流(数据传输就和文件读写IO 类似,"流式"的)
全双工(一个通信通道,可以双向传输。 既可以发送又可以接收) - 一根网线,里面其实有 8 根线
和刚才UDP类似. 实现一个简单的英译汉的功能
4.1ServerSocket API
ServerSocket
是创建TCP服务端Socket的API。
ServerSocket
构造方法:
ServerSocket
方法:
4.2Socket API
Socket
是客户端Socket,或服务端中接收到客户端建立连接(accept方法)的请求后,返回的服务端 Socket。
不管是客户端还是服务端Socket,都是双方建立连接以后,保存的对端信息,及用来与对方收发数据的。
Socket
构造方法:
Socket
方法:
服务器和客户端的 Socket 不是一个Socket,可以把他们理解成两部正在通信的电话。
4.3TCP中的长短连接
TCP发送数据时,需要先建立连接,什么时候关闭连接就决定是短连接还是长连接:
短连接:每次接收到数据并返回响应后,都关闭连接,即是短连接。也就是说,短连接只能一次收发数据。
长连接:不关闭连接,一直保持连接状态,双方不停的收发数据,即是长连接。也就是说,长连接可以多次收发数据。
对比以上长短连接,两者区别如下:
- 建立连接、关闭连接的耗时:短连接每次请求、响应都需要建立连接,关闭连接;而长连接只需要 第一次建立连接,之后的请求、响应都可以直接传输。相对来说建立连接,关闭连接也是要耗时 的,长连接效率更高。
- 主动发送请求不同:短连接一般是客户端主动向服务端发送请求;而长连接可以是客户端主动发送 请求,也可以是服务端主动发。
- 两者的使用场景有不同:短连接适用于客户端请求频率不高的场景,如浏览网页等。长连接适用于 客户端与服务端通信频繁的场景,如聊天室,实时游戏等。
扩展了解:
基于BIO(同步阻塞IO)的长连接会一直占用系统资源。对于并发要求很高的服务端系统来说,这样的 消耗是不能承受的。
由于每个连接都需要不停的阻塞等待接收数据,所以每个连接都会在一个线程中运行。
一次阻塞等待对应着一次请求、响应,不停处理也就是长连接的特性:一直不关闭连接,不停的 处理请求。
实际应用时,服务端一般是基于NIO(即同步非阻塞IO)来实现长连接,性能可以极大的提升。
4.4示例一:一发一收(长连接)
以下为一个客户端一次数据发送,和服务端多次数据接收(一次发送一次接收,可以接收多次),即只 有客户端请求,但没有服务端响应的示例:
4.4.1TCP服务端
package network;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("启动服务器");//此处使用 CacheThreadPool,使用 FixedThreadPool 不太合适 (线程数不太应该是有固定的......)ExecutorService threadPool = Executors.newCachedThreadPool();while (true) {//使用这个 clientSocket 和具体的客户端进行交流Socket clientSocket = serverSocket.accept();//此处使用多线程来处理。
// Thread t = new Thread(()->{
// processConnection(clientSocket);
// });
// t.start();//使用线程池threadPool.submit(()->{processConnection(clientSocket); });}}//使用这个方法来处理一个连接//这一个连接对应到一个客户端,但是这里可能会涉及到多次交互private void processConnection(Socket clientSocket) {System.out.printf("[%s:%d] 客户端上线!\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());//基于上述 socket 对象和客户端进行通信try (InputStream inputStream = clientSocket.getInputStream();OutputStream outputStream = clientSocket.getOutputStream()){//由于我们要处理多个请求和响应,也是使用循环来进行。while (true) {//1.读取请求Scanner scanner = new Scanner(inputStream);if (!scanner.hasNext()) {//没有下个数据,说明读完了。(客户端关闭了连接)System.out.printf("[%s:%d] 客户端下线!\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());break;}//注意!!! 此处使用 next 是一直读取到换行符/空格/其他空白符结束,但是最终返回结果里不包含上述 空白符。String request = scanner.next();//2.根据请求构造响应String response = process(request);//3.返回响应结果// OutputStream 没有 write String 这样的功能, 可以把 String 里的字节数组拿出来,进行写入;// 也可以用字符流来转换一下。PrintWriter printWriter = new PrintWriter(outputStream);//此处使用 println 来写入,让结果带有一个 \n 换行,方便对端来接收解析printWriter.println(response);//flush 用来刷新缓冲区,保证当前写入的数据,确实是发送出去了printWriter.flush();System.out.printf("[%s:%d] req: %s; resp: %s \n",clientSocket.getInetAddress().toString(),clientSocket.getPort(),request,response);}} catch (IOException e) {e.printStackTrace();} finally {//更合适的做法,是把 close 放到 finally 里面,保证一定能够执行到!!!try {clientSocket.close();} catch (IOException e) {e.printStackTrace();}}}public String process(String request) {return request;}public static void main(String[] args) throws IOException {TCPEchoServer server = new TCPEchoServer(9090);server.start();}
}
运行后,服务端就启动了,控制台输出如下:
可以看出,此时代码是阻塞等待在 server.accept()
代码行,直到有新的客户端申请建立连接。
在我们客户端启动后,服务器这里显示我们客户端上线了。
在客户端输入 hello
之后,服务器直接返回响应结果回去。
在我们客户端输入 exit
之后,我们的服务端显示客户端下线了。
代码解析:
效果是 “接收连接”,前提是,得有客户端来建立连接!!!
客户端在构造 Socket 对象的时候,就会指定服务器的 IP 和 端口
如果没有客户端来连接,此时 accept 就会阻塞等待
这个代码中,使用到一个 clientSocket.此时任意一个客户端连上来,都会返回/创建一个 Socket 对象。(Socket 就是文件)每次创建一个 clientSocket 对象,就要占用一个文件描述符表的位置。
因此在使用完毕之后,就需要进行"释放"。
当前启动服务器后,先启动客户端1,可以看到正常的上线提示。再启动客户端2,此时发现没有任何提示了。
客户端1 进行发送消息,都ok。 客户端2 发送消息,没有任何提示。
解决方法1:
当 客户端1 退出之后。 此时客户端2 就一切正常了!
解决方法2:
此时我们改进一下代码加入线程池:
可以看到在我们修改了服务器中的循环为线程池后,此时我们的服务器就可以检测到多个客户端的上线了。
注意:这里虽然使用了线程池了,但是还不够,我们服务器如果此时有成千上万个客户端,那么就是成千上万个线程。这个事情对于我们机器来说,就是一个很大的负担!
为了解决这个问题,我们可以进行 IO多路复用
IO多路转接
。
所谓的 IO多路复用
,就是充分利用等待时间,做别的事情。给线程安排个集合,这个集合就放了一堆连接。这个线程主要负责监听这个集合,哪个连接有数据来了,线程就来处理哪个连接。(API 中 提供了一组 NIO 这样的类封装了上述多路复用的 API select,poll,epoll)
eg:
一个快递员要取三个餐,A顾客想吃 热干面,B顾客想吃 肉夹馍,C顾客想吃 猪脚饭。
如果是单线程完成的话,快递员就要先取热干面,再取肉夹馍,最后取猪脚饭 才能进行送单。
如果是多线程的话,快递员召唤分身,分别去取热干面、肉夹馍、和猪脚饭然后汇合一起送单。(很明显效率要更高)
但是我们这里真实的做法是,利用等待时间来取餐,我们先去三个地方进行点餐,然后再去首先做好的餐品处取餐,然后再去第二个地方取餐,最后去第三个地方取餐,这个做法就是我们的 IO多路复用
!
4.4.2TCP客户端
package network;import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;public class TCPEchoClient {private Socket socket = null;public TCPEchoClient(String serverIP, int serverPort) throws IOException {//Socket 构造方法,能够识别 点分十进制格式的 IP 地址,比 DatagramPacket 更方便//new 这个对象的同时,就会进行socket = new Socket(serverIP,serverPort);}public void start() {System.out.println("客户端启动!");Scanner scanner = new Scanner(System.in);try (InputStream inputStream = socket.getInputStream();OutputStream outputStream = socket.getOutputStream()){while (true) {//1.先从键盘上读取用户输入的内容System.out.print("> ");String request = scanner.next();if (request.equals("exit")) {System.out.println("goodbye");break;}//2.把读取到的内容构造成请求,发送给服务器PrintWriter printWriter = new PrintWriter(outputStream);printWriter.println(request);//此处加上 flush 保证数据确实发送出去了printWriter.flush();//3.读取服务区的响应Scanner respScanner = new Scanner(inputStream);String response = respScanner.next();//4.把响应内容显示到界面上System.out.println(response);}} catch (IOException e) {e.printStackTrace();}}public static void main(String[] args) throws IOException {TCPEchoClient client = new TCPEchoClient("127.0.0.1",9090);client.start();}
}
上图表示我们服务器成功启动啦!
在客户端输入 hello
后,我们的客户端立即就返回了一个 hello
在我们客户端输入 exit
之后,我们的客户端就退出了程序。
代码解析:
这个对象构造过程,就会触发 TCP 建立连接的过程。(打电话开始拨号了)
如果客户端没这个代码,服务器就会在 accept 这里阻塞,无法产生出 clientSocket 了。
4.5示例二:请求响应(短连接)
示例一只是客户端请求和服务端接收,并没有包含服务端的返回响应。以下是对应请求和响应的改造:
构造一个展示服务端本地某个目录(BASE_PATH)的下一级子文件列表的服务
(1)客户端先接收键盘输入,表示要展示的相对路径(相对BASE_PATH的路径)
(2)发送请求:使用客户端Socket的输出流发送TCP报文。即输入的相对路径。
(3)服务端接收并处理请求:使用服务端Socket的输入流来接收请求报文,根据请求的路径,列出下 一级子文件及子文件夹。
(4)服务端返回响应:使用服务端Socket的输出流来发送响应报文。即遍历子文件和子文件夹,每个 文件名一行,返回给客户端。
(5)客户端接收响应:使用客户端Socket的输入流来接收响应报文。简单的打印输出所有的响应内 容,即文件列表。
4.5.1TCP服务端
package org.example.tcp.demo2;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {//服务器socket要绑定固定的端口private static final int PORT = 8888;//本地文件目录要展示的根路径private static final String BASE_PATH = "E:/TMP";public static void main(String[] args) throws IOException {// 1.创建一个服务端ServerSocket,用于收发TCP报文ServerSocket server = new ServerSocket(PORT);// 不停的等待客户端连接while(true) {System.out.println("------------------------------------------------
---");System.out.println("等待客户端建立TCP连接...");// 2.等待客户端连接,注意该方法为阻塞方法Socket socket = server.accept();System.out.printf("客户端IP:%s%n",
socket.getInetAddress().getHostAddress());System.out.printf("客户端端口号:%s%n", socket.getPort());// 5.接收客户端的数据,需要从客户端Socket中的输入流获取InputStream is = socket.getInputStream();// 为了方便获取字符串内容,可以将以上字节流包装为字符流BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));// 客户端请求只发送一行数据,我们也只需要读取一行String request = br.readLine();// 6.根据请求处理业务:本地目录根路径+请求路径,作为要展示的目录,列出下一级子文
件//请求的文件列表目录System.out.printf("客户端请求的文件列表路径为:%s%n", BASE_PATH +
request);File dir = new File(BASE_PATH + request);//获取下一级子文件,子文件夹File[] children = dir.listFiles();// 7.返回响应给客户端:通过客户端socket中的输出流发送响应数据OutputStream os = socket.getOutputStream();// 为了方便输出字符串作为发送的内容,可以将以上字节流包装为字符流PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF8"));// 7-1.返回的响应内容:每个文件及目录名称为一行if(children != null){for (File child : children) {pw.println(child.getName());}}// 7-2.有缓冲区的IO操作,真正传输数据,需要刷新缓冲区pw.flush();// 7-3.双方关闭连接:服务端是关闭客户端socket连接socket.close();}}
}
以上服务端运行结果和示例一是一样的:
---------------------------------------------------
等待客户端建立TCP连接...
4.5.2TCP客户端
package org.example.tcp.demo2;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class TcpClient {//服务端IP或域名private static final String SERVER_HOST = "localhost";//服务端Socket进程的端口号private static final int SERVER_PORT = 8888;public static void main(String[] args) throws IOException {// 准备要发送的数据:这里调整为键盘输入作为发送的内容Scanner scanner = new Scanner(System.in);while(true) {System.out.println("------------------------------------------------
---");System.out.println("请输入要展示的目录:");// 每输入新行(回车),就作为发送的TCP请求报文String request = scanner.nextLine();// 3.创建一个客户端流套接字Socket,并与对应IP的主机上,对应端口的进程建立连接Socket socket = new Socket(SERVER_HOST, SERVER_PORT);// 4.发送TCP数据,是通过socket中的输出流进行发送OutputStream os = socket.getOutputStream();// 为了方便输出字符串作为发送的内容,可以将以上字节流包装为字符流PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF8"));// 4-1.发送数据:pw.println(request);// 4-2.有缓冲区的IO操作,真正传输数据,需要刷新缓冲区pw.flush();// 8.接收返回的响应数据:通过socket中的输入流获取System.out.println("接收到服务端响应:");InputStream is = socket.getInputStream();// 为了方便获取字符串内容,可以将以上字节流包装为字符流BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));String line;// 一直读取到流结束:TCP是基于流的数据传输,一定要服务端关闭Socket输出流才表示客
户端接收的IO输入流结束while ((line = br.readLine()) != null) {System.out.println(line);}// 9.双方关闭连接:客户端关闭socket连接socket.close();}}
}
客户端启动后会等待输入要展示的路径:
---------------------------------------------------
请输入要展示的目录:
在输入想查看的目录路径后,会接收并打印服务端响应的文件列表数据:
---------------------------------------------------
请输入要展示的目录:
/
接收到服务端响应:
1
2
60441b1b8a74be3695ccc0d970693815
8f25103aa249707ee4ab17635142cd0e
---------------------------------------------------
请输入要展示的目录:
此时服务端也会打印接收到的客户端请求数据:
---------------------------------------------------
等待客户端建立TCP连接...
客户端IP:127.0.0.1
客户端端口号:52493
客户端请求的文件列表路径为:E:/TMP/
---------------------------------------------------
等待客户端建立TCP连接...
目前TCP客户端和服务端实现的功能和UDP差不多,但都存在几个问题:
- 对于服务端来说,处理一次请求并返回响应后,才能再次处理下一次请求和响应,效率是比较低 的。这个问题比较好解决:可以使用多线程,每次的请求与响应都在线程中处理。这样多个客户端 请求的话,可以在多个线程中并发并行的执行。
- 服务端解析请求,是只读取了一行,而客户端解析响应,是一直读取到流结束。可以想想为什么解 析请求时,没有读取到流结束?
目前的业务,双方都已约定好业务是展示目录下的文件列表,且都只需要一种数据:请求传输的数 据代表要展示的目录;响应传输的数据代表文件列表:每一行为一个文件名。
如要提供更多的业务,如文件重命名,文件删除等操作时,就不能了。此时就需要提供更多的字段 来标识。一般我们需要设计更强大的协议。
4.6再谈协议
4.6.1回顾并理解为什么需要协议
以上我们实现的UDP和TCP数据传输,除了UDP和TCP协议外,程序还存在应用层自定义协议,可以想 想分别都是什么样的协议格式。
对于客户端及服务端应用程序来说,请求和响应,需要约定一致的数据格式:
- 客户端发送请求和服务端解析请求要使用相同的数据格式。
- 服务端返回响应和客户端解析响应也要使用相同的数据格式。
- 请求格式和响应格式可以相同,也可以不同。
- 约定相同的数据格式,主要目的是为了让接收端在解析的时候明确如何解析数据中的各个字段。
- 可以使用知名协议(广泛使用的协议格式),如果想自己约定数据格式,就属于自定义协议。
4.6.2封装/分用 vs 序列化/反序列化
一般来说,在网络数据传输中,发送端应用程序,发送数据时的数据转换(如java一般就是将对象转换 为某种协议格式),即对发送数据时的数据包装动作来说:
- 如果是使用知名协议,这个动作也称为封装
- 如果是使用小众协议(包括自定义协议),这个动作也称为序列化,一般是将程序中的对象转换为 特定的数据格式。
接收端应用程序,接收数据时的数据转换,即对接收数据时的数据解析动作来说:
- 如果是使用知名协议,这个动作也称为分用
- 如果是使用小众协议(包括自定义协议),这个动作也称为反序列化,一般是基于接收数据特定的 格式,转换为程序中的对象
4.6.3如何设计协议
对于协议来说,重点需要约定好如何解析,一般是根据字段的特点来设计协议:
对于定长的字段:
- 可以基于长度约定,如int字段,约定好4个字节即可
对于不定长的字段:
- 可以约定字段之间的间隔符,或最后一个字段的结束符,如换行符间隔,\3符号结束等等
- 除了该字段“数据”本身,再加一个长度字段,用来标识该“数据”长度;即总共使用两个字段:
- “数据”字段本身,不定长,需要通过“长度”字段来解析;
- “长度”字段,标识该“数据”的长度,即用于辅助解析“数据”字段;
4.7示例三:多线程+自定义协议
以下我们将示例二的业务做以下扩展:
- 提供多种操作:展示目录下文件列表,文件重命名,删除文件,上传文件,下载文件
- 在不同的操作中,需要抽象出请求和响应的字段,也即是说,要约定客户端服务端统一的请求协 议,同时也要约定服务端与客户端统一的响应协议
4.7.1本示例中的自定义协议
以下为我们TCP请求数据的协议格式,这里简单起见,约定为换行符及结束符:
请求类型
操作的文件或目录路径
数据 \3
说明如下:
- 以上总共包含3个字段,前2个字段需要按换行符读取,最后一个字段需要按结束符读取
- 请求类型标识是什么操作:展示目录下文件列表,文件重命名,删除文件,上传文件,下载文件
- 重命名、上传文件操作,需要“数据”字段,其他操作可以置为空字符串
- “数据”字段为最后一个字段,使用\3结束符,这样在数据本身有换行符也能正确处理
以下为响应数据的协议格式:
状态码(标识是否操作成功)
数据(展示列表时,返回目录下的文件列表,或下载文件的数据)\3
以下为展示文件列表操作的自定义协议(请求、响应格式)
以下操作将展示服务端根目录下的子文件及子文件夹:
请求数据格式如下:
1
/
\3
响应数据格式如下:
200
\1
\2
\3
\1.txt
\2.txt\3
以下为上传文件操作的自定义协议(请求、响应格式)
需要先在客户端指定上传的服务端目录,及客户端要上传的文件路径,以下操作将会把客户端
Main.java
文件内容上传到服务端根目录 E:/TMP
下的 /1
目录下:
请求数据格式如下:
4
/1
package org.example;
public class Main {
……略
}\3
响应数据格式如下:
200
\3
4.7.2执行流程(xml json protobuffer)
约定好请求和响应的数据格式,也就是应用层协议,大家按照约定好的格式来发送和接收,以下为执行流程
- xml:
- json:
上述 xml 和 json 都是按照文本的方式来组织的。
优点:可读性好,用户不需要借助其他的工具,肉眼就能看懂数据的含义
缺点:效率不高,尤其是占用较多的网络带宽(xml 中要额外传很多的标签 json 中要额外传很多的 key 对于服务器来说,最贵的硬件资源,不是cpu更不是内存,而是网络带宽!!!)
- protobuffer (谷歌)
二进制表示数据的方式,针对上述的数据信息,通过二进制的方式进行压缩表示了。
优点:占用空间小,传输的带宽也就降低了
缺点:肉眼观察不了,直接用记事本打开是一串011001类似的乱码
4.7.3请求类
先按照约定的请求协议封装请求类:
- 每个字段为一个属性:操作类型,操作路径,数据
- 完成服务端解析请求封装:按约定的方式读,先按行读取前2个字段,再按结束符读第3个字段
- 完成客户端发送请求封装:按约定的方式写,前2个字段按行输出,第3个字段以\3结束
package org.example.tcp.demo3;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
public class Request {//操作类型:1(展示目录文件列表),2(文件重命名),3(删除文件),4(上传文件),5(下载
文件)private Integer type;//操作的目录路径private String url;//数据private String data;//服务端解析请求时:根据约定好的格式来解析public static Request serverParse(InputStream is) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF8"));Request request = new Request();//前2行分别为操作类型和操作路径request.type = Integer.parseInt(br.readLine());request.url = br.readLine();//使用list保存字符List<Character> list = new ArrayList<>();//数据:循环读取while(true){//一个字符一个字符的读char c = (char) br.read();//一直读取到结束符\3if(c == '\3')break;list.add(c);}//拼接数据StringBuilder sb = new StringBuilder();for (char c : list){sb.append(c);}request.data = sb.toString();return request;}//客户端发送请求到服务端public void clientWrite(OutputStream os) throws IOException {PrintWriter pw = new PrintWriter(os);pw.println(type);pw.println(url);pw.write(data+"\3");// 4-2.有缓冲区的IO操作,真正传输数据,需要刷新缓冲区pw.flush();}@Overridepublic String toString() {return "Request{" +"type=" + type +", url='" + url + '\'' +", data='" + data + '\'' +'}';}public Integer getType() {return type;}public void setType(Integer type) {this.type = type;}public String getUrl() {return url;}public void setUrl(String url) {this.url = url;}public String getData() {return data;}public void setData(String data) {this.data = data;}
}
4.7.4响应类
按照约定的响应协议封装响应类:
- 每个字段为一个属性:响应状态码
- 完成客户端解析响应封装:按约定的方式读,先按行读取第1个字段,再按结束符读第2个字段
- 完成服务端发送响应封装:按约定的方式写,第1个字段按行输出,第2个字段以\3结束
package org.example.tcp.demo3;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
public class Response {//响应的状态码,200表示操作成功,404表示没有找到该路径的文件或目录private int status;//数据private String data;//客户端解析服务端返回的响应数据public static Response clientParse(InputStream is) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF8"));Response response = new Response();response.status = Integer.parseInt(br.readLine());//使用list保存字符List<Character> list = new ArrayList<>();//数据:循环读取while(true){//一个字符一个字符的读char c = (char) br.read();//一直读取到结束符\3if(c == '\3')break;list.add(c);}//拼接数据StringBuilder sb = new StringBuilder();for (char c : list){sb.append(c);}response.data = sb.toString();return response;}//服务端返回响应给客户端public void serverWrite(OutputStream os) throws IOException {PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));pw.println(status);pw.write(data+"\3");// 4-2.有缓冲区的IO操作,真正传输数据,需要刷新缓冲区pw.flush();}@Overridepublic String toString() {return "Response{" +"status=" + status +", data='" + data + '\'' +'}';}public int getStatus() {return status;}public void setStatus(int status) {this.status = status;}public String getData() {return data;}public void setData(String data) {this.data = data;}
}
4.7.5TCP服务端
以下完成服务端代码:
ServerSocket.accept()
为建立客户端服务端连接的方法,为提高效率,使用多线程- 先要解析请求数据,即
Request
已封装好的服务端解析请求,返回Request
对象 - 返回响应数据,需要根据不同的请求字段,做不同的业务处理,并返回对应的响应内容
- 如果操作的url路径再服务端根目录 E:/TMP 下找不到,则返回响应状态码404
- 正常执行完,返回200响应状态码;要注意根据不同操作类型来执行不同的业务
package org.example.tcp.demo3;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.file.Files;
import java.util.UUID;
public class TcpServer {//服务器socket要绑定固定的端口private static final int PORT = 8888;//本地文件目录要展示的根路径private static final String BASE_PATH = "E:/TMP";public static void main(String[] args) throws IOException {// 1.创建一个服务端ServerSocket,用于收发TCP报文ServerSocket server = new ServerSocket(PORT);// 不停的等待客户端连接while(true) {// 2.等待客户端连接,注意该方法为阻塞方法Socket socket = server.accept();new Thread(new Runnable() {@Overridepublic void run() {try {System.out.println("------------------------------------
---------------");System.out.println("客户端建立TCP连接...");System.out.printf("客户端IP:%s%n",
socket.getInetAddress().getHostAddress());System.out.printf("客户端端口号:%s%n", socket.getPort());// 5.接收客户端的数据,需要从客户端Socket中的输入流获取
InputStream is = socket.getInputStream();// 解析为请求对象
Request request = Request.serverParse(is);System.out.println("服务端收到请求:"+request);// 6.根据请求处理业务:处理完成返回响应对象
Response response = build(request);// 7.返回响应给客户端:通过客户端socket中的输出流发送响应数据
OutputStream os = socket.getOutputStream();// 7-1.返回的响应内容:按照约定格式输出响应对象中的内容
System.out.println("服务端返回响应:"+response);response.serverWrite(os);// 7-3.双方关闭连接:服务端是关闭客户端socket连接
socket.close();} catch (IOException e) {e.printStackTrace();}}}).start();}}//根据请求处理业务,返回响应对象public static Response build(Request request){Response response = new Response();response.setStatus(200);File url = new File(BASE_PATH+request.getUrl());//该路径的文件或目录不存在if(!url.exists()){response.setStatus(404);response.setData("");return response;}try {switch (request.getType()){//1展示目录文件列表case 1: {File[] children = url.listFiles();if(children == null){response.setData("");}else{//拼接要返回的数据:文件列表
StringBuilder sb = new StringBuilder();for (int i = 0; i < children.length; i++) {File child = children[i];//文件路径截取掉服务端本地路径前缀sb.append(child.getAbsolutePath().substring(BASE_PATH.length())+"\n");}response.setData(sb.toString());}break;}//2文件重命名case 2: {url.renameTo(new
File(url.getParent()+File.separator+request.getData()));break;}//3删除文件case 3: {url.delete();break;}//上传文件case 4: {//上传到请求的操作路径目录下,保存的文件名简单的以随机字符串uuid生成即
可FileWriter upload = new
FileWriter(url.getAbsolutePath()+File.separator+ UUID.randomUUID());upload.write(request.getData());upload.flush();upload.close();break;}//下载文件case 5: {String data = new String(Files.readAllBytes(url.toPath()));response.setData(data);break;}}} catch (IOException e) {e.printStackTrace();}return response;}
}
4.7.6TCP客户端
以下为客户端代码:
- 先要建立和服务端的连接,连接服务端的IP和端口
- 根据输入来构建请求数据:
- 先接收操作类型和操作路径
- 重命名操作时,需要指定修改的文件名
- 文件上传操作时,需要指定上传的客户端本地文件路径
- 解析响应数据,并根据响应来执行相应的业务,我们这里暂时简单的解析为 Response 对象,并打印即可
package org.example.tcp.demo3;
import java.io.*;
import java.net.Socket;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Scanner;
public class TcpClient {//服务端IP或域名private static final String SERVER_HOST = "localhost";//服务端Socket进程的端口号private static final int SERVER_PORT = 8888;public static void main(String[] args) throws IOException {// 准备要发送的数据:这里调整为键盘输入作为发送的内容Scanner scanner = new Scanner(System.in);while(true) {//根据键盘输入构造一个请求对象,包含操作类型,操作路径,长度和数据Request request = build(scanner);// 3.创建一个客户端流套接字Socket,并与对应IP的主机上,对应端口的进程建立连接Socket socket = new Socket(SERVER_HOST, SERVER_PORT);// 4.发送TCP数据,是通过socket中的输出流进行发送OutputStream os = socket.getOutputStream();// 4-1.发送请求数据:按照约定的格式输出请求对象中的内容System.out.println("客户端发送请求:"+request);request.clientWrite(os);// 8.接收返回的响应数据:通过socket中的输入流获取InputStream is = socket.getInputStream();// 根据约定的格式获取响应数据Response response = Response.clientParse(is);System.out.println("客户端收到响应:"+response);// 9.双方关闭连接:客户端关闭socket连接socket.close();}}//客户端发送请求时,根据键盘输入构造一个请求对象public static Request build(Scanner scanner) throws IOException {System.out.println("---------------------------------------------------
");System.out.println("请输入要操作的类型:1(展示目录文件列表),2(文件重命名),
3(删除文件),4(上传文件),5(下载文件)");Request request = new Request();int type = Integer.parseInt(scanner.nextLine());System.out.println("请输入要操作的路径:");String url = scanner.nextLine();String data = "";//只需要操作类型和操作路径的请求,长度和数据构造为空的if(type == 2){//重命名操作,需要输入重命名的名称System.out.println("请输入要重命名的名称:");data = scanner.nextLine();}else if(type == 4){//文件上传,需要提供上传的文件路径System.out.println("请输入要上传的文件路径:");String upload = scanner.nextLine();data = new String(Files.readAllBytes(Paths.get(upload)));}else if(type != 1 && type !=3 && type!=5){System.out.println("只能输入1-5的数字,请重新输入");return build(scanner);}request.setType(type);request.setUrl(url);request.setData(data);return request;}
}
4.8长连接 vs 短连接
短连接:客户端每次给服务器发消息,先建立连接,再发送请求,读取响应,关闭连接。下次再发送,则重新建立连接。(连一次读一次断一次)
长连接:客户端每次建立连接之后,连接不着急断开,然后再发送请求,读取响应;再发送请求,读取响应;若干轮之后,客户端确实短时间之内不再需要使用这个连接了,此时再断开。(连一次读多次,不需要再断开)

在具体代码中,我们将里面的
while (true){}
这个条件去掉就是短连接啦!
如果带上 while (true){}
就是长连接!
4.9UDP vs TCP
UDP
无连接(发微信发qq信息)
不可靠传输(没有已读功能)
面向数据报 (数据传输则以一个个的"数据报"为基本单位。 一个数据报可能是若干个字节,带有一定的格式的)
全双工(一个通信通道,可以双向传输。 既可以发送又可以接收)- 一根网线,里面其实有 8 根线
TCP
有连接(打电话)
可靠传输(有已读功能(例如抖音消息已读不回QAQ🎃))
面向字节流(数据传输就和文件读写IO 类似,"流式"的)
全双工(一个通信通道,可以双向传输。 既可以发送又可以接收) - 一根网线,里面其实有 8 根线
感谢各位读者的阅读,本文章有任何错误都可以在评论区发表你们的意见,我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞,你的每一次鼓励都是作者创作的动力哦!😘
相关文章:

6.网络编程套接字(下)
文章目录 4.TCP流套接字编程4.1ServerSocket API4.2Socket API4.3TCP中的长短连接4.4示例一:一发一收(长连接)4.4.1TCP服务端4.4.2TCP客户端 4.5示例二:请求响应(短连接)4.5.1TCP服务端4.5.2TCP客户端 4.6再…...

4.3-内置后置PostProcess处理器深度讲解
在reader里面注册了很多Bean定义 reader会调取register()来注册配置类 调用上句,就会把配置类注册到BeanDefinitionMap中去 配置类有了、解析配置类的处理器有了 然后, 在第三步refresh() 进行IOC容器刷新中的invokeBeanPostProcessors(beanFactory…...

LeetCode(力扣)45. 跳跃游戏 IIPython
LeetCode45. 跳跃游戏 II 题目链接代码 题目链接 https://leetcode.cn/problems/jump-game-ii/description/ 代码 class Solution:def jump(self, nums: List[int]) -> int:if len(nums) 1:return 0curdis 0nextdis 0step 0for i in range(len(nums)):nextdis max(…...

mysql5.8 免安装版(压缩包)win10 安装
目录 1、下载MySQL5.82、如何安装、配置my.ini配置注意 3初始化mysql3.1. 初始化mysql3.2. 安装mysql服务3.3. 启动mysql3.4. 登录mysql3.5. 修改root密码3.6. 配置远程连接 Mysql5.8安装踩坑记录,推荐使用Docker安装,我是电脑虚拟化可能会蓝屏没用这个功…...

STM32-HAL库06-硬件IIC驱动FM24CL16B非易失存储器
STM32-HAL库06-IIC驱动FM24CL16B非易失存储器 一、所用材料: STM32VGT6自制控制板 STM32CUBEMX(HAL库软件) MDK5 二、所学内容: 通过HAL库的硬件IIC对FM24CL16B存储器进行写与读取操作。 三、CUBEMX配置: 第一步…...

python-wordcloud词云
导入模块 from wordcloud import WordCloud import jieba import imageio import matplotlib.pyplot as plt from PIL import ImageGrab import numpy as npwordcloud以空格为分隔符号,来将文本分隔成单词 PIL pillow模块 img imageio.imread(image.png)这行代码…...

单元测试与自测
单元测试在百度百科的定义: 自测在百度百科的定义: 单元测试是测一个类或一个函数,自立门第main函数,不依赖于项目,预期的是这个类或函数是没有问题的。程序编码完成之后至各种测试再到用户使用出现的任何bug都是单元测…...

2023-09-12 LeetCode每日一题(课程表 IV)
2023-03-29每日一题 一、题目编号 1462. 课程表 IV二、题目链接 点击跳转到题目位置 三、题目描述 你总共需要上 numCourses 门课,课程编号依次为 0 到 numCourses-1 。你会得到一个数组 prerequisite ,其中 prerequisites[i] [ai, bi] 表示如果你…...

RabbitMQ基础
目录 MQ MQ概述 MQ 的优势 1.应用解耦 2.异步提速 3.削峰填谷 MQ 的劣势 1.系统可用性降低 2.系统复杂度提高 3.一致性问题 使用 MQ 需要满足什么条件呢? RabbitMQ 简介 编辑RabbitMQ 中的相关概念 RabbitMQ 提供了 6 种工作模式 JMS java实现Ra…...

ITIL 4—创建、交付和支持—创建、交付和支持服务的价值流
4. 创建、交付和支持服务的价值流 本章节提供了有关如何: 记录一个价值流以理解工作流程如何贯穿该组织了解创建一个新服务的原型价值流了解支持一个现场服务的原型价值流 本章将帮助从业者理解: 价值流在 服务价值系统(SVS) 中的作用价值流的分类如…...

微信怎么给自己发消息
前段时间看到一份数据调查,说是到目前为止,全球使用微信的用户已达到10亿多人次,天啊,多么强大的用户群体! 这么多人喜欢使用微信,相信大家都知道,微信里面有一个特俗功能,可以自己…...

正交试验设计法
正交实验设计 一、什么是正交试验设计法? 是一种成对测试交互的系统的统计方法。它提供了一种能对所有变量对的组合进行典型覆盖(均匀分布)的方法。 可以从大量的试验点中挑出适量的、有代表性的点,利用“正交表”,…...
Scrum工具:助力快速迭代和高效交付
随着软件开发行业的不断发展,敏捷开发方法逐渐成为了主流。Scrum作为敏捷开发中最具代表性的工具之一,其在流程设计、团队协作以及项目管理等方面发挥着重要作用。本文将深入探讨Scrum的优势以及如何运用Scrum提升团队效率与质量。 一、Scrum敏捷开发工…...

通过Python行命令搭建HTTP服务器结合内网穿透实现外网访问
文章目录 1.前言2.本地http服务器搭建2.1.Python的安装和设置2.2.Python服务器设置和测试 3.cpolar的安装和注册3.1 Cpolar云端设置3.2 Cpolar本地设置 4.公网访问测试5.结语 1.前言 Python作为热度比较高的编程语言,其语法简单且语句清晰,而且python有…...

Android T 窗口层级其三 —— 层级结构树添加窗口
文章目录 序节点添加Task以DefaultTaskDisplayArea为父节点以Task为父节点 ActivityRecordWindowTokenWindowState以WindowToken为父节点以ActivityRecord为父节点 小结调用场景添加差异 流程分析添加log堆栈打印流程LauncherStatusBar 序 尚未添加窗口的层级结构树࿰…...

3D虚拟数字人定制,推动传统文化传播新高度
“数字人”成为“汉语盘点2022”年度十大新词语。伴随着科技发展成长的年轻人逐渐成为消费主力军,如何在虚拟世界与年轻一代用户互动以抓住95后年轻人受众,成为不少传统文化品牌发力的重点。 数字人“天妤”,在3D虚拟数字人定制中࿰…...

kubernetes进阶 (三) 基础练习
前两天朋友给了我几道题,看着挺简单的,但实际做的时候发现坑不少,这里做下笔记 一、镜像构建部署lnmp 1、构建镜像 nginx、php、mysql 要求使用centos7作为基础镜像 2、使用deployment部署上面的容器,要求3个服务要放到一个pod中(虽然这样是…...

数据结构 排序
目录 第八章 排序8.1排序的基本概念1. 概念2. 排序算法的分类 8.2 插入排序8.2.1 直接插入排序8.2.2 算法效率分析8.2.2 折半插入排序总结8.2.3 希尔排序 8.3 交换排序8.3.1冒泡排序8.3.2快速排序(了解栈的过程) 8.4 选择排序8.4.1 简单选择排序8.4.2 堆…...

Cpp/Qtday050912cpp基础
目录 实现一个图形类(Shape),包含受保护成员属性:周长、面积, 公共成员函数:特殊成员函数书写 定义一个圆形类(Circle),继承自图形类,包含私有属性&#x…...
Git diff 使用 vimdiff 对比差异
在Ubuntu中使用Git时,可使用命令行的git diff命令来对比两次提交的差异,但是这种对比查看方式无法直观地查看修改的差异,在对比和查看时不太方便。 可以使用vimdiff作为Git diff的对比工具,这样就方便了许多,Git的配置…...
Java 语言特性(面试系列1)
一、面向对象编程 1. 封装(Encapsulation) 定义:将数据(属性)和操作数据的方法绑定在一起,通过访问控制符(private、protected、public)隐藏内部实现细节。示例: public …...
在rocky linux 9.5上在线安装 docker
前面是指南,后面是日志 sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo sudo dnf install docker-ce docker-ce-cli containerd.io -y docker version sudo systemctl start docker sudo systemctl status docker …...

跨链模式:多链互操作架构与性能扩展方案
跨链模式:多链互操作架构与性能扩展方案 ——构建下一代区块链互联网的技术基石 一、跨链架构的核心范式演进 1. 分层协议栈:模块化解耦设计 现代跨链系统采用分层协议栈实现灵活扩展(H2Cross架构): 适配层…...

C++ 求圆面积的程序(Program to find area of a circle)
给定半径r,求圆的面积。圆的面积应精确到小数点后5位。 例子: 输入:r 5 输出:78.53982 解释:由于面积 PI * r * r 3.14159265358979323846 * 5 * 5 78.53982,因为我们只保留小数点后 5 位数字。 输…...

AI,如何重构理解、匹配与决策?
AI 时代,我们如何理解消费? 作者|王彬 封面|Unplash 人们通过信息理解世界。 曾几何时,PC 与移动互联网重塑了人们的购物路径:信息变得唾手可得,商品决策变得高度依赖内容。 但 AI 时代的来…...

【VLNs篇】07:NavRL—在动态环境中学习安全飞行
项目内容论文标题NavRL: 在动态环境中学习安全飞行 (NavRL: Learning Safe Flight in Dynamic Environments)核心问题解决无人机在包含静态和动态障碍物的复杂环境中进行安全、高效自主导航的挑战,克服传统方法和现有强化学习方法的局限性。核心算法基于近端策略优化…...

DingDing机器人群消息推送
文章目录 1 新建机器人2 API文档说明3 代码编写 1 新建机器人 点击群设置 下滑到群管理的机器人,点击进入 添加机器人 选择自定义Webhook服务 点击添加 设置安全设置,详见说明文档 成功后,记录Webhook 2 API文档说明 点击设置说明 查看自…...
MySQL 部分重点知识篇
一、数据库对象 1. 主键 定义 :主键是用于唯一标识表中每一行记录的字段或字段组合。它具有唯一性和非空性特点。 作用 :确保数据的完整性,便于数据的查询和管理。 示例 :在学生信息表中,学号可以作为主键ÿ…...
在 Spring Boot 项目里,MYSQL中json类型字段使用
前言: 因为程序特殊需求导致,需要mysql数据库存储json类型数据,因此记录一下使用流程 1.java实体中新增字段 private List<User> users 2.增加mybatis-plus注解 TableField(typeHandler FastjsonTypeHandler.class) private Lis…...
Docker拉取MySQL后数据库连接失败的解决方案
在使用Docker部署MySQL时,拉取并启动容器后,有时可能会遇到数据库连接失败的问题。这种问题可能由多种原因导致,包括配置错误、网络设置问题、权限问题等。本文将分析可能的原因,并提供解决方案。 一、确认MySQL容器的运行状态 …...