【大数据】学习笔记 1 Java SE 第15章网络编程 15.5 TCP网络编程

淩亂°似流年 2024-03-22 14:31 53阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第15章 网络编程
             *   *  15.5 TCP网络编程
                 *   *  15.5.1 通信模型
                     *  15.5.2 开发步骤
                     *  15.5.3 演示单个客户端与服务器单次通信
                     *  15.5.4 演示多个客户端与服务器之间的多次通信

![在这里插入图片描述][2b31cde709e64d36b6e09ac0845f918a.png_pic_center]

#### 1 Java SE ####

##### 第15章 网络编程 #####

###### 15.5 TCP网络编程 ######

###### 15.5.1 通信模型 ######

Java语言的基于套接字TCP编程分为服务端编程和客户端编程，其通信模型如图所示：

![在这里插入图片描述][75b9f07f026843739482674ebda5b639.png_pic_center]

###### 15.5.2 开发步骤 ######

服务器端程序包含以下四个基本的 步骤：

*  调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
 *  调用 accept() ：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
 *  调用 该Socket 类对象的 getOutputStream() 和 getInputStream () ：获取输出流和输入流，开始网络数据的发送和接收。
 *  关闭Socket 对象：客户端访问结束，关闭通信套接字。

客户端程序包含以下四个基本的步骤 ：

*  创建 Socket ：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
 *  打开连接到 Socket 的输入/ 出流： 使用 getInputStream()方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输
 *  按照一定的协议对 Socket 进行读/ 写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线路。
 *  关闭 Socket ：断开客户端到服务器的连接，释放线路

###### 15.5.3 演示单个客户端与服务器单次通信 ######

需求：客户端连接服务器，连接成功后给服务发送“lalala”，服务器收到消息后，给客户端返回“欢迎登录”，客户端接收消息后，断开连接

【1】服务器端示例代码

package com.dingjiaxiong.tcp.one;
    
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Server
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 13:58
     */
    
    public class Server {
        
    
        public static void main(String[] args) throws Exception {
        
            //1、准备一个ServerSocket对象，并绑定8888端口
            ServerSocket server = new ServerSocket(8888);
            System.out.println("等待连接....");
    
            //2、在8888端口监听客户端的连接，该方法是个阻塞的方法，如果没有客户端连接，将一直等待
            Socket socket = server.accept();
            InetAddress inetAddress = socket.getInetAddress();
            System.out.println(inetAddress.getHostAddress() + "客户端连接成功！！");
    
            //3、获取输入流，用来接收该客户端发送给服务器的数据
            InputStream input = socket.getInputStream();
            //接收数据
            byte[] data = new byte[1024];
            StringBuilder s = new StringBuilder();
            int len;
            while ((len = input.read(data)) != -1) {
        
                s.append(new String(data, 0, len));
            }
            System.out.println(inetAddress.getHostAddress() + "客户端发送的消息是：" + s);
    
            //4、获取输出流，用来发送数据给该客户端
            OutputStream out = socket.getOutputStream();
            //发送数据
            out.write("欢迎登录".getBytes());
            out.flush();
    
            //5、关闭socket，不再与该客户端通信
            //socket关闭，意味着InputStream和OutputStream也关闭了
            socket.close();
    
            //6、如果不再接收任何客户端通信，可以关闭ServerSocket
            server.close();
        }
    }

【2】客户端示例代码

package com.dingjiaxiong.tcp.one;
    
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Client
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 13:58
     */
    
    public class Client {
        
    
        public static void main(String[] args) throws Exception {
        
            // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
            Socket socket = new Socket("127.0.0.1", 8888);
    
            // 2、获取输出流，用来发送数据给服务器
            OutputStream out = socket.getOutputStream();
            // 发送数据
            out.write("lalala".getBytes());
            //会在流末尾写入一个“流的末尾”标记，对方才能读到-1，否则对方的读取方法会一致阻塞
            socket.shutdownOutput();
    
            //3、获取输入流，用来接收服务器发送给该客户端的数据
            InputStream input = socket.getInputStream();
            // 接收数据
            byte[] data = new byte[1024];
            StringBuilder s = new StringBuilder();
            int len;
            while ((len = input.read(data)) != -1) {
        
                s.append(new String(data, 0, len));
            }
            System.out.println("服务器返回的消息是：" + s);
    
            //4、关闭socket，不再与服务器通信，即断开与服务器的连接
            //socket关闭，意味着InputStream和OutputStream也关闭了
            socket.close();
        }
    }

运行效果

![在这里插入图片描述][3938c734443e46e99e0a091595f73071.png_pic_center]

![在这里插入图片描述][e0d31e2b0e324b559d9ed69669e78b2c.png_pic_center]

###### 15.5.4 演示多个客户端与服务器之间的多次通信 ######

通常情况下，服务器不应该只接受一个客户端请求，而应该不断地接受来自客户端的所有请求，所以Java程序通常会通过循环，不断地调用ServerSocket的accept()方法。

如果服务器端要“同时”处理多个客户端的请求，因此服务器端需要为**每一个客户端单独分配一个线程**来处理，否则无法实现“同时”。

咱们之前学习IO流的时候，提到过装饰者设计模式，该设计使得不管底层IO流是怎样的节点流：文件流也好，网络Socket产生的流也好，程序都可以将其包装成处理流，甚至可以多层包装，从而提供更多方便的处理。

案例需求：多个客户端连接服务器，并进行多次通信

*  每一个客户端连接成功后，从键盘输入英文单词或中国成语，并发送给服务器
 *  服务器收到客户端的消息后，把词语“反转”后返回给客户端
 *  客户端接收服务器返回的“词语”，打印显示
 *  当客户端输入“stop”时断开与服务器的连接
 *  多个客户端可以同时给服务器发送“词语”，服务器可以“同时”处理多个客户端的请求

![在这里插入图片描述][e72e7a0cfb514e2b8c4b8accb98b58c9.png_pic_center]

【1】服务器端示例代码

package com.dingjiaxiong.tcp.many;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Server
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 14:00
     */
    
    public class Server {
        
        public static void main(String[] args) throws IOException {
        
            // 1、准备一个ServerSocket
            ServerSocket server = new ServerSocket(8888);
            System.out.println("等待连接...");
    
            int count = 0;
            while (true) {
        
                // 2、监听一个客户端的连接
                Socket socket = server.accept();
                System.out.println("第" + ++count + "个客户端" + socket.getInetAddress().getHostAddress() + "连接成功！！");
    
                ClientHandlerThread ct = new ClientHandlerThread(socket);
                ct.start();
            }
    
            //这里没有关闭server，永远监听
        }
    
        static class ClientHandlerThread extends Thread {
        
            private Socket socket;
            private String ip;
    
            public ClientHandlerThread(Socket socket) {
        
                super();
                this.socket = socket;
                ip = socket.getInetAddress().getHostAddress();
            }
    
            public void run() {
        
                try {
        
                    //（1）获取输入流，用来接收该客户端发送给服务器的数据
                    BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    //（2）获取输出流，用来发送数据给该客户端
                    PrintStream ps = new PrintStream(socket.getOutputStream());
                    String str;
                    // （3）接收数据
                    while ((str = br.readLine()) != null) {
        
                        //（4）反转
                        StringBuilder word = new StringBuilder(str);
                        word.reverse();
    
                        //（5）返回给客户端
                        ps.println(word);
                    }
                    System.out.println("客户端" + ip + "正常退出");
                } catch (Exception e) {
        
                    System.out.println("客户端" + ip + "意外退出");
                } finally {
        
                    try {
        
                        //（6）断开连接
                        socket.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

【2】客户端示例代码

package com.dingjiaxiong.tcp.many;
    
    import java.io.BufferedReader;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintStream;
    import java.net.Socket;
    import java.util.Scanner;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Client
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 14:00
     */
    
    public class Client {
        
        public static void main(String[] args) throws Exception {
        
            // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
            Socket socket = new Socket("127.0.0.1", 8888);
    
            // 2、获取输出流，用来发送数据给服务器
            OutputStream out = socket.getOutputStream();
            PrintStream ps = new PrintStream(out);
    
            // 3、获取输入流，用来接收服务器发送给该客户端的数据
            InputStream input = socket.getInputStream();
            BufferedReader br;
            if (args != null && args.length > 0) {
        
                String encoding = args[0];
                br = new BufferedReader(new InputStreamReader(input, encoding));
            } else {
        
                br = new BufferedReader(new InputStreamReader(input));
            }
    
            Scanner scanner = new Scanner(System.in);
            while (true) {
        
                System.out.println("输入发送给服务器的单词或成语：");
                String message = scanner.nextLine();
                if (message.equals("stop")) {
        
                    socket.shutdownOutput();
                    break;
                }
    
                // 4、 发送数据
                ps.println(message);
                // 接收数据
                String feedback = br.readLine();
                System.out.println("从服务器收到的反馈是：" + feedback);
            }
    
            //5、关闭socket，断开与服务器的连接
            scanner.close();
            socket.close();
        }
    }

运行效果

![在这里插入图片描述][563f20fe6cf9427ebaa89201a895f30e.png_pic_center]

![在这里插入图片描述][bb10e004e91b42f1852c80d6e35e23c7.png_pic_center]

![在这里插入图片描述][b8f704efdcbe4174aefef4ead96d3c36.png_pic_center]

[2b31cde709e64d36b6e09ac0845f918a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3087bb8d7ce74c20bbf617aa328a016f.png
[75b9f07f026843739482674ebda5b639.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/fc643922e5f54ad1823abc69cb748e5e.png
[3938c734443e46e99e0a091595f73071.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/1fff60d3a3fb40979d762a46e472e311.png
[e0d31e2b0e324b559d9ed69669e78b2c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/346e2029d6414302ac723c98248898c1.png
[e72e7a0cfb514e2b8c4b8accb98b58c9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/dca0222d931a4c48bd766cb2bc21ce71.png
[563f20fe6cf9427ebaa89201a895f30e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/869582627a9f48b0a026a17192e80662.png
[bb10e004e91b42f1852c80d6e35e23c7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/35c3d139dbf44321aaf503cd23d21e26.png
[b8f704efdcbe4174aefef4ead96d3c36.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c8436a4651bc40ea8fe1cd370bca752f.png