0
0

网络编程【TCP流套接字编程】

目录

TCP流套接字编程

❗❗两个核心：ServerSocket Socket

1.ServerSocket API

✨**ServerSocket **是创建 TCP服务端Socket的API

ServerSocket 构造方法：

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

**ServerSocket **方法：

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

2.Socket API

✨Socket 是 客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端 Socket。

Socket 构造方法：

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

Socket 方法：

InetAddress getInetAddress() 返回套接字所连接的地址
InputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流

3.TCP中的长短连接

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

短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。

长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

4.回显程序(短连接)

1️⃣TCP 客户端

package io;

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 port) throws IOException {
        // 这个操作相当于让客户端和服务器建立 tcp 连接.
        // 这里的连接连上了, 服务器的 accept 就会返回.
        socket = new Socket(serverIp, port);
    }

    //启动客户端程序
    public void start() {
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            PrintWriter printWriter = new PrintWriter(outputStream);
            Scanner scannerFromSocket = new Scanner(inputStream);
            while (true) {
                // 1. 从键盘上读取用户输入的内容.
                System.out.print("-> ");
                String request = scanner.next();
                // 2. 把读取的内容构造成请求, 发送给服务器.
                //    注意, 这里的发送, 是带有换行的!!
                printWriter.println(request);//这里只是把数据写入内存的缓冲区中，等待缓冲区满了，才会真正写网卡
                // 3. 从服务器读取响应内容
                String response = scannerFromSocket.next();
                // 4. 把响应结果显示到控制台上.
                System.out.printf("req: %s; resp: %s\n", request, 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();
    }
}

2️⃣TCP 服务端

package io;

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;

public class TcpEchoServer {
    // serverSocket 就是外场拉客的小哥
    // clientSocket 就是内场服务的小姐姐.
    // serverSocket 只有一个. clientSocket 会给每个客户端都分配一个~
    private ServerSocket serverSocket = null;

    //端口号绑定
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true) {
            Socket clientSocket = serverSocket.accept();
            processConnection(clientSocket);
        }
    }

    // 通过这个方法来处理一个连接.
    // 读取请求
    // 根据请求计算响应
    // 把响应返回给客户端
    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress().toString(),
                clientSocket.getPort());
        // try () 这种写法, ( ) 中允许写多个流对象. 使用 ; 来分割
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 没有这个 scanner 和 printWriter, 完全可以!! 但是代价就是得一个字节一个字节扣, 找到哪个是请求的结束标记 \n
            // 不是不能做, 而是代码比较麻烦.为了简单, 把字节流包装秤了更方便的字符流~~
            Scanner scanner = new Scanner(inputStream);
            //Scanner 相当于 字符流，上述约定了请求是字符串，所以就可以使用字符流来处理

            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 1. 读取请求：
                //hasNext 判定接下来还有没有数据了，如果对端关闭连接(客户端关闭连接)，此时 hasNext 就会返回 false，循环就让它结束
                //如果对端有数据，hasNxet 返回 true，进一步就可以使用 next 方法来读出这一段字符串的内容了

                if (!scanner.hasNext()) {
                    // 读取的流到了结尾了 (对端关闭了)
                    System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                // 直接使用 scanner 读取一段字符串.
                String request = scanner.next();
                //next：一直往后读，读到空白符结束——空格，换行，制表符，翻页符..都算空白符
                //nextLine 只是读到换行符结束
                //这里不要用nextLine

                // 2. 根据请求计算响应
                String response = process(request);
                // 3. 把响应写回给客户端. 不要忘了, 响应里也是要带上换行的.
                printWriter.println(response);
                System.out.printf("[%s:%d] req: %s; resp: %s\n", clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(), request, response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();//clientSocket 只是给一个连接提供服务的，还是要能够进行关闭
        }
    }

    private String process(String request) {
        return request;
    }

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

5.服务器和客户端它们的交互过程

1️⃣启动服务器

c9d7c3798dd44a02800cc19538ffb39e.png

2️⃣客户端启动

e49e6cae999f4c88ab1d26e3c026d8ab.png

当客户端和服务器连接建立好之后，服务器这边的 accept 就返回了

3️⃣服务器就进入 processConnection 了，尝试从客户端读取请(由于此时客户端还没有发送请求，此时读取操作也会阻塞)

81c1428f1db44e25be96484fb7d6bda2.png

与此同时：

用户端往下执行到，从控制台读取用户输入——也会阻塞

6c1b997fe55d47c5918e0e276193ffc2.png

4️⃣当用户真的输入内容，客户端真正发送了请求出去；同时往下执行到，读取服务器响应，再次阻塞

342798f3a56840a5a0616869d225052e.png

5️⃣服务器收到客户端的请求之后，从 next 这里返回，执行 process 执行 println ，把响应写回到客户端

18f3a30a1b6244d3af99b35a6c199ea7.png

** 6️⃣服务器重新回到上述开头位置，继续尝试读取请求，并阻塞**

** 客户端收到服务器的响应就可以把结果显示出来了；同时进入下次循环，再次等待用户的输入了**

6.运行结果及修改代码

539d13a9b99f46438f7573e61bc5907e.png

0b26723b732a402abe31e23b42475fde.png

❗❗❗当我们输入 hello 之后，发现客户端没有任何响应——因为数据还在缓冲区内

// 2. 把读取的内容构造成请求, 发送给服务器.
//    注意, 这里的发送, 是带有换行的!!
printWriter.println(request);

这里只是把数据写入内存的缓冲区中，等待缓冲区满了，才会真正写网卡

1️⃣此时我们需要****冲刷

2ef3b156950246d6b3897e8dc8ebdf0d.png

dd01eff856124384ad156e55079e6e46.png

此时就可以响应了；当前程序已经跑起来了，已经可以正常通信了

❗❗但是还存在一个严重的 bug！！服务器需要同时能够给多个客户端提供服务的

2️⃣在 idea 中启动多个客户端，需要配置，默认一个程序只能启动一个

2df1f424ab95401486ef1a243e0be8ac.png

74b64692b2ae4fb58ee3ccee72f99b2d.png

🔎此时就可以启动多个程序

3️⃣但是我们看到的是在第一个客户端输入 hello，运行是正常的；但是我们在第二个客户端输入 hello2的时候没有任何反应

aef3b65779e84ac980c939138fa6ba8a.png

这就是当前服务器无法同时服务多个客户端；为什么会造成这种原因呢？

bccfeaa0ac814f85bb3dbbb3b0a0811f.png

6️⃣解决方法：希望同时能够给客户端1提供服务，又能够循环的调用 accept——多线程

** 如果直接调用，该方法回影响这个循环的二次执行，导致 accept 不及时了 ；这个时候就需要 创建新的线程，用新线程来调用 processConnection；每次来一个新的客户端都搞一个新的线程即可！！!**

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true) {
            Socket clientSocket = serverSocket.accept();
            //如果直接调用，该方法回影响这个循环的二次执行，导致 accept 不及时了
            //这个时候就需要 创建新的线程，用新线程来调用 processConnection；每次来一个新的客户端都搞一个新的线程即可！！!
            Thread t = new Thread(() -> {
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }
    }

ec194c39efd841e69cbb3162832f43eb.png

此时运行结果：

b3f182f69a9f4748aa2fb1e570bacd87.png

7️⃣解决方案2：使用 线程池 修改上述代码

bcb7155deee242b0809a6baeb4062f57.png

✨一个连接的所有请求处理完，这个程序不会销毁，而且还到池子里，下次直接使用

标签： 网络 服务器 java-ee
本文转载自: https://blog.csdn.net/m0_72161237/article/details/130068496
版权归原作者 奋斗小温 所有， 如有侵权，请联系我们删除。
登录后发布评论

“网络编程【TCP流套接字编程】”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航