【JavaEE初阶】网络编程TCP协议实现回显服务器以及如何处理多个客户端的响应
前言
🌟🌟本期讲解关于TCP/UDP协议的原理理解~~~
🌈感兴趣的小伙伴看一看小编主页：GGBondlctrl-CSDN博客
🔥 你的点赞就是小编不断更新的最大动力
🎆那么废话不多说直接开整吧~~
目录
📚️1.TCP相关API
📚️2.回显服务器
2.1概念
2.2服务器的实现
1.初始化Socket类对象
2.启动连接服务器
3.读取连接的阻塞
4.数据的响应的返回
5.缓冲区的刷新
2.3客户端的实现
1.初始化Socket类对象
2.启动客户端并阻塞
3.发送请求和接收响应
4.文件流close的操作
📚️3.处理多个客户端同时响应
3.1启动多个服务器
3.2处理多客户端请求
1.问题现象
2.问题分析
3.问题解决
4.方法扩展
📚️4.总结
📚️1.TCP相关API
和前一期的UDP基本是大差不差的，但是这里提供的方法来模拟对于网卡的操作是有一定的区别的，所示API如下：
| ServerSocket | 是Socket类对应到网卡给服务器使用的类 |
| Socket | 对应到网卡，是给服务器或者客户端来进行使用的 |
而我们知道在UDP的使用中有DatagramPacket是用于在传输过程中的数据传送的单位，即“面向数据包”，但是这里是没有具体特有的数据传送的类的
注意：由于TCP是一个面向字节流的协议，所以使用的仍然是文件IO部分的操作字节流；
| inputstream | 读数据（字节为单位） |
| outputstream | 写数据（字节为单位） |
所以有了这些铺垫我们就可以使用TCP来实现一个回显服务器了；
📚️2.回显服务器
2.1概念
回显服务器：所谓的回显服务器就是当客户端发送一个请求之后，服务器就直接返回这个响应，在对于请求的解析和操作中是没有任何的逻辑的；（总之就是用户输入什么就得到什么~~）
2.2服务器的实现
1.初始化Socket类对象
这里和UDP的初始化几乎是一样的，即如下代码所示：
public class TcpEchoServer {
private ServerSocket serverSocket = null;
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port); //操作模拟网卡的端口号
}这里就是通过erverSocket类来实现一个对象，达到模拟控制网卡的操作，用于数据的传输，其中这里的port就是一个服务器的端口号；
2.启动连接服务器
在上述的初始化过后，我们就可直接启动服务器了，代码所示：
public void start() throws IOException {
System.out.println("服务器启动了");
//进入循环
while (true) {
//建立连接
Socket Clientsocket = serverSocket.accept();
processClient(Clientsocket);
}
}解释：当我们启动服务器之后，这里就要进行服务器与客户端的连接，为啥要进行连接呢，主要是因为TCP是一个有连接的协议，这就类似于打电话一样，两边要接听后才能够进行通信，然后将数据传给另一个方法操作；
如下图所示：
此时应用程序中调用对应的API来尝试和服务器建立连接，然后内核态就会尝试发起建立连接的流程，然后服务器这边的内核态就会配合进行连接；
注意：内核发起连接是用户程序来进行操作的，所以这里就要调用accept来进行连接；
3.读取连接的阻塞
当客户端和服务器建立连接，传入数据进行操作时，此时服务器就会进入阻塞状态，那么就有一下代码来进行实现：
private void processClient(Socket Clientsocket) { //处理连接来的数据
System.out.printf("[%s:%d] 客户端上线!
", Clientsocket.getInetAddress(), Clientsocket.getPort());
try (InputStream inputStream = Clientsocket.getInputStream();
OutputStream OutputStream = Clientsocket.getOutputStream()) {
//循环读取客户端的请求并且进行响应
while (true) {
Scanner scanner = new Scanner(inputStream);
if (!scanner.hasNext()) {
System.out.printf("[%s:%d] 客户端下线!
", Clientsocket.getInetAddress(), Clientsocket.getPort());
break;
}解释：
由于TCP的面向字节流，所以我们可以通过inputstream来实现这里的操作，此时将这里的操作写到try里是为了自动执行close的关闭文件流的操作；
通过scanner来读取字节数据，然后通过scanner.hashnext来实现没有输入时就进行跳出循环操作，这里就是客户端下线了；
4.数据的响应的返回
在这里通过字节数据的请求操作实现对于客户端的响应，代码如下：
String request = scanner.next();
//进行响应操作
String response = process(request);
//将响应传给客户端
//给outputstream进行外包装
PrintWriter printWriter = new PrintWriter(OutputStream);
printWriter.println(response);解释：这里的process操作就是直接返回需求作为响应，然后这里小编就通过printwriter来包装了outputstream这个写数据的操作，就是替代了这个代码：
OutputStream.write(response.getBytes(),0,response.getBytes().length)这里两个的区别：
OutputStream ：你需要将字符串手动转换为字节数组发送，例如；
String response = "收到你的消息";
byte[] responseBytes = response.getBytes();
outputStream.write(responseBytes);
PrintWriter ：它提供了更方便的 print 和 println 方法，可以直接发送字符串；
PrintWriter 会自动处理字符编码等细节，并且在构造函数的第二个参数传入 true 时能够自动刷新缓冲区，确保消息及时发送。这使得代码更加简洁易读，减少了因字节处理而可能产生的错误。
5.缓冲区的刷新
这里是printwriter提供的缓冲区在这里面进行了操作，解决代码如下：
printWriter.flush();//刷新缓冲区，让数据发送出去解释：这就是刷新缓冲区的意思，为啥要刷新缓冲区呢？？？
注意：这里的IO操作是一个比较低效的操作，所以就会尽量减少对于文件IO的操作，所以要操作网卡的数据存放到内存缓冲区里，当积攒到一定的量后再发给下一层协议
所以当数据太少的时候，就会存在缓冲区里，并没有发送出去，所以这里要进行刷新的操作；
2.3客户端的实现
1.初始化Socket类对象
和上面的服务器初始化是一致的，只不过使用的类不一样，代码如下：
public class TcpEchoClient {
private Socket socket=null;
public TcpEchoClient(String ServerIP, int ServerPort) throws IOException {
//由于tcp是有连接的，所以会自动保存这里的ip和端口号
socket=new Socket(ServerIP,ServerPort);
}解释：这里通过socket对象，实现对于网卡的模拟操作，在构造函数的时候定义服务器的IP地址以及服务器的端口号；
2.启动客户端并阻塞
这里在启动客户端后直接进入循环，进行不断的从服务器读取响应，代码如下：
public void start(){
System.out.println("客户端启动了");
try (InputStream inputStream=socket.getInputStream();
OutputStream outputStream= socket.getOutputStream()){
Scanner scannerConsole=new Scanner(System.in);
Scanner scannernetwork=new Scanner(inputStream);
PrintWriter writer=new PrintWriter(outputStream);
while (true){
System.out.println("->");
if(!scannerConsole.hasNext()){
break;
}解释:这里还是通过inputstream和outputstream来进行操作，这里的两个scanner分别的用途如下所示;
第一个scanner是用于客户在控制台上进行字符串的输入；
第二个scanner是用于字节数据的读取，就是从服务器响应过后的数据接收；
第三个printwriter用于写数据给服务器，这里就是发送请求的意思
之后进入用户的输入阻塞，当不输入时，就直接跳出循环，客户端下线；
3.发送请求和接收响应
当执行上述步骤之后，我们就要执行对于服务器数据的发送请求和接收响应的操作了，代码如下：
String request=scannerConsole.next();
//发送数据用到写的操作
writer.println(request);
writer.flush();
//接收数据
String response=scannernetwork.next();
System.out.println(response);解释：这里将用户输入的请求通过writer写给服务器，并刷新了缓存，保证字节数组能够发送出去，最后通过scannernetwork来接收数据，并转化为字符串类型数据，最后在打印即可；
4.文件流close的操作
1.serversocket
解释：由于整个程序中只有一个serversocket对象，并且这个对象的生命周期很长，随着服务器的退出自动销毁，所以不需要进行close操作；
2.clientSocket
解释：由于clientsocket是每个客户端都有一个，由于连接的客户端越来越多，不释放socket就会导致将文件描述附表占满，所以这里要进行close的操作；
代码如下：
finally {
try {
clientSocket.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}这里就添加在服务器try-catch的后面即可~~~
📚️3.处理多个客户端同时响应
3.1启动多个服务器
当我们执行代码，启动多个服务器的时候会发现此时idea会终止这个原来的进程，然后执行新的代码，即新的进程，那么解决办法如下所示：
点击后进入如下的画面，然后进入一个新的界面点击如下：
然后这里代表的就是允许多个实例的运行，那么就可以重复执行代码，实现多个服务器同时运行的实现；
3.2处理多客户端请求
1.问题现象
此时当我们对第一个客户端进行输入的时候，发现此时服务器对于客户端是有响应的，如下图所示：
此时是有客户端输入后，会得到响应的，但是此时我们对于第二个客户端进行打印的时候，这里是没有出现响应的：
此时我们可以看见服务器对于两个客户端的上线状态也是不一样的，如下图所示：
很明显这里就是只上线了一个客户端，那么这就是第二个客户端得不到响应的原因；
2.问题分析
流程：首先这里的服务器主循环是通过clientsocket来进行数据连接，然后再进入数据操作的循环，即有以下几个步骤：
1.读取请求并且进行解析；
2.对于解析做出响应；
3.将响应传回给客户端；
注意：这是一个死循环，只要这个循环不结束（即连接这个服务器的第一个客户端不结束）那么就会导致服务器一直在这个循环等待客户端1号的请求，并做出响应；
虽然这里第二个客户端实现了内核上运用accept与服务器建立了连接，但是无法将连接拿到程序里进行处理，这就是整个多客户端 请求不成功的主要原因；
3.问题解决
使用多线程
对这个processClient(Clientsocket)来进行多个线程处理多个客户端的请求与响应，具体代码如下所示：
while (true) {
//建立连接
Socket Clientsocket = serverSocket.accept();
Thread t=new Thread(()->{
processClient(Clientsocket);
});
t.start();
}解释：那么此时当申请一个客户端的时候，那么就会创建一个线程来对这个客户端进行服务，此时就解决了多客户端请求的问题；
使用线程池
由于上述的操作，会导致一个客户端执行，就会创建一个线程，一个客户端执行完了，就会销毁一个线程，那么此时就会造成线程频繁创建销毁的开销增大；
那么这里就引入了线程池，这个概念，具体代码如下：
while (true) {
//建立连接
Socket Clientsocket = serverSocket.accept();
ExecutorService pool= Executors.newCachedThreadPool();
pool.submit(new Runnable() {
@Override
public void run() {
processClient(Clientsocket);
}
});
}解释：那么此时当创建好线程后，客户端执行，那么就会从线程池中拿一个线程进行服务客户端，当客户端执行结束后，将线程入到线程池，就不会销毁，节省了线程创建的开销；
4.方法扩展
引入协程
这里的协程就是轻量级线程，用户态可以手动的调度这个协程，并发的执行多个客户端；那么此时由于协程的创建和销毁是用户态进行手动控制的，所以就省去了系统内核的调度开销；
IO多路复用
IO多路复用：这里就是一个系统内核级别的机制，主要的内容机制就是一个线程同时负责多个socket的处理；
本质：即每个socket需要操作的数据不是同一时间处理的；
举例：假如我去买街上买吃的，我可以点好餐后，等待后，拿到餐了，那么去买另一个东西；那么我也可以等买完餐后直接去买另一个东西，此时在等这两个东西完成后，再去拿；这里的本质就是每个东西的不是同一个时间执行的；
📚️4.总结
💬💬本期小编主要讲解了关于TCP实现回显服务器的操作过程中，服务器的操作，客户端的操作；以及如何处理多个客户端的同时响应，并进行了问题的多方解决~~~
🌅🌅🌅~~~~最后希望与诸君共勉，共同进步！！！
💪💪💪以上就是本期内容了， 感兴趣的话，就关注小编吧。
😊😊 期待你的关注~~~
