• 【JavaEE】网络编程

    网络编程中的基本概念

    发送端和接收端
    在一次网络数据传输时：
    发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
    接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
    收发端：发送端和接收端两端，也简称为收发端。
    注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。
    请求和响应
    一般来说，获取一个网络资源，涉及到两次网络数据传输：
    第一次：请求数据的发送
    第二次：响应数据的发送。
    客户端和服务端
    服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
    客户端：获取服务的一方进程，称为客户端。
    对于服务来说，一般是提供：

    • 客户端获取服务资源

    在这里插入图片描述

    • 客户端保存资源在服务端

    image.png
    常见的客户端服务端模型
    最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序

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

    image.png

    Socket套接字

    概念
    Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。
    分类
    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数据报的流程如下：
    image.png
    以上只是一次发送端的UDP数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请求，没有响应。对于一个服务端来说，重要的是提供多个客户端的请求处理及响应，流程如下：
    image.png

    UDP数据报套接字编程

    DatagramSocket API
    DatagramSocket 是UDP Socket，用于发送和接收UDP数据报。
    DatagramSocket 构造方法：
    image.png
    DatagramSocket 方法：
    image.png
    DatagramPacket API
    DatagramPacket是UDP Socket发送和接收的数据报。
    DatagramPacket 构造方法：
    image.png
    DatagramPacket 方法：
    image.png
    构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建。
    InetSocketAddress API
    InetSocketAddress （ SocketAddress 的子类 ）构造方法：
    image.png

    1. 建立一个服务器端
    import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;

public class UDPEchoServer {
    // 定义一个用于服务器端的DatagramSocket
    private DatagramSocket server;

    /**
     * 构造方法，完成服务器的初始化
     * @param port 端口号
     */
    public UDPEchoServer (int port) throws Exception {
        if (port > 65535 || port < 1024) {
            throw new Exception("端口号必须在1024 ~ 65535之间");
        }
        // 初始化服务器端的UDP服务
        this.server = new DatagramSocket(port);
    }

    /**
     * 对外提供服务
     */
    public void start () throws IOException {
        System.out.println("服务器已启动！");
        // 循环接收用户的请求
        while (true) {
            // 1. 创建一个用于接收请求数据的DatagramPacket
            DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
            // 2. 接收请求, 把真实的内容填充到requestPacket
            server.receive(requestPacket);
            // 3. 从requestPacket获取数据
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "UTF-8");
            // 4. 根据请求获取响应
            String response = processor (request);
            // 5. 把响应封装到DatagramPacket
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(StandardCharsets.UTF_8),
                    response.getBytes().length, requestPacket.getSocketAddress());
            // 6. 发送数据
            server.send(responsePacket);
            // 7. 打印日志
            System.out.printf("[%s:%d] request: %s, response: %s.\n", requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }

    }

    public String processor(String request) {
        return request;
    }

    public static void main(String[] args) throws Exception {
        // 初始化服务器
        UDPEchoServer server = new UDPEchoServer(9999);
        // 启动服务
        server.start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    1. 建立一个客户器端
    import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class UDPEchoClient {
    // 定义一个用于客户端的DatagramSocket
    private DatagramSocket client;
    // 定义服务器的IP地址
    private String serverIp;
    // 定义服务器的端口号
    private int port;
    private SocketAddress address;

    /**
     * 构造方法,指定服务器的Ip地址和端口号
     *
     * @param serverIp 服务器IP
     * @param port 端口号
     */
    public UDPEchoClient (String serverIp, int port) throws SocketException {
        this.client = new DatagramSocket();
        this.serverIp = serverIp;
        this.port = port;
        this.address = new InetSocketAddress(serverIp, port);
    }

    public void start () throws IOException {
        System.out.println("客户端已启动.");
        // 循环接收用户的输入
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("->");
            // 接收用户输入
            String request = scanner.next();
         
           // 1. 把请求内容包装成DatagramPacket
           DatagramPacket requestPacket = new DatagramPacket(request.getBytes(StandardCharsets.UTF_8),
                   request.getBytes().length, address);
           // 2. 发送数据
           client.send(requestPacket);
           // 3. 接收响应
           DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
           // 4. 在receive方法中填充响应数据
           client.receive(responsePacket);
           // 5. 解析响应数据
           String response = new String(responsePacket.getData(), 0, responsePacket.getLength(), "UTF-8");
           // 6. 打印日志
           System.out.printf("request: %s, response: %s.\n", request, response);
        }
    }

    public static void main(String[] args) throws IOException {
        UDPEchoClient client = new UDPEchoClient("127.0.0.1", 9998);
        // 启动服务
        client.start();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    Java流套接字通信

    image.png

    TCP流套接字编程

    和刚才UDP类似. 实现一个简单的英译汉的功能
    ServerSocket API
    ServerSocket 是创建TCP服务端Socket的API。
    ServerSocket 构造方法：
    image.png
    ServerSocket 方法：
    image.png
    Socket API
    Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
    不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
    Socket 构造方法：
    image.png
    Socket 方法：
    image.png
    TCP中的长短连接
    TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
    短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
    长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
    对比以上长短连接，两者区别如下：

    • 建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
    • 主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
    • 两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。
    1. 建立一个服务端
    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.net.SocketException;
import java.text.MessageFormat;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class TCPEchoServer {
//    声明一个用于服务器的对象
    private ServerSocket server;

    public TCPEchoServer(int port) throws IOException {
        if(port < 1024 || port > 65535){
            throw new SocketException("端口号不正确！");
        }
        this.server = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务端启动成功！");
        //接收连接
        while (true){
            //没有连接会阻塞，
            Socket clientSocket = server.accept();
            processConnetion(clientSocket);
        }
    }

    //处理数据
    private void processConnetion(Socket clientSocket) throws IOException {
//        System.out.printf("[%s:%d客户端已经上线\n");
        String clientInfo = MessageFormat.format("[{0},{1}]客户端已经上线\n",clientSocket.getInetAddress(),clientSocket.getPort());
        System.out.println(clientInfo);
        //获取输入输出流
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            //处理用户请求
            while (true){
                //读取用户数据
                Scanner requestScanner = new Scanner(inputStream);
                if(!requestScanner.hasNextLine()){
                    clientInfo = MessageFormat.format("[{0},{1}]客户端已经下线\n",clientSocket.getInetAddress(),clientSocket.getPort());
                    System.out.println(clientInfo);
                    break;
                }
                // 有数据，获取用户真实请求
                String request = requestScanner.nextLine();
//                响应
                String response = process(request);
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                printWriter.flush();

                clientInfo = MessageFormat.format("[{0},{1}]request:{2},response:{3}\n",
                        clientSocket.getInetAddress(),clientSocket.getPort(),request,response);
                System.out.println(clientInfo);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            clientSocket.close();
        }
    }

    private String process(String request) {
        System.out.println("收到新消息：" + request);
        System.out.print("->");
        Scanner scanner = new Scanner(System.in);
        String re = scanner.nextLine();
        return re;
    }

    public static void main(String[] args) throws IOException {
        TCPEchoServer server = new TCPEchoServer(9999);
//        Scanner scanner = new Scanner(System.in);
//        String s = scanner.nextLine();
        server.start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    1. 建立一个客户端
    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 client;
    public TCPEchoClient(String serverIp,int port) throws IOException {
        if(port < 1024 || port > 65535){
            throw new SocketException("端口号不正确！");
        }
        this.client = new Socket(serverIp,port);
    }
    public void start() throws IOException {
        System.out.println("客户端已启动！");
        try(InputStream inputStream = client.getInputStream();
            OutputStream outputStream = client.getOutputStream()) {
            while (true){
                System.out.print("->");
                Scanner scanner = new Scanner(System.in);
                String request = scanner.nextLine();
//                发送请求
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();
                //接收服务器的响应
                Scanner responseScaner = new Scanner(inputStream);
                String response = responseScaner.nextLine();

                System.out.println("接收到服务器的响应" + response);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            client.close();
        }
    }

    public static void main(String[] args) throws IOException {
        //本机，连接服务端端口
        TCPEchoClient client = new TCPEchoClient("127.0.0.1",9999);
        client.start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    上面的的服务端只能服务于一个客户端，为了实现服务器可以处理多个客户端连接
    那么就可以为每一个客户端创建一个新的线程， 那请求的处理在单独子线程中去执行
    但是如果有1万个连接那么就要创建1万个线程，如果有1万个连接那么就要创建1万个线程，1万个线程会消耗掉非常大的系统资源，C10K现象；为了解决线程大量创建，那么可以使用线程池的方式进一步做优化。

    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.text.MessageFormat;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TCPEchoServerThreadPool {
    // 声明一个用于服务端的Socket对象
    private ServerSocket server;

    /**
     * 通过指定端口号实例化服务
     *
     * @param port 端口号
     * @throws IOException
     */
    public TCPEchoServerThreadPool(int port) throws IOException {
        if (port < 1025 || port > 65535) {
            throw new RuntimeException("端口号要在 1025 ~ 65535之间.");
        }
        // 实例化ServerSocket并指定端口号
        this.server = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动成功...");
        // 创建一个线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10));
        // 循环接收客户端的连接
        while (true) {
            Socket clientSocket = server.accept();
            // 每接收到一个新连接请求，就创建一个新的子线程
//            Thread thread = new Thread(() -> {
//                // 处理Socket中的数据
//                try {
//                    processConnections(clientSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            // 启动线程
//            thread.start();

            // 提交任务到线程池中
            poolExecutor.submit(() -> {
                try {
                    processConnections(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

        }
    }

    // 处理数据
    private void processConnections(Socket clientSocket) throws IOException {
        // 打印日志
        String clientInfo = MessageFormat.format("[{0}:{1}] 客户端已上线", clientSocket.getInetAddress(),
                clientSocket.getPort());
        System.out.println(clientInfo);
        // 处理数据之前要获取一下输入输出流
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 循环处理用户的请求
            while (true) {
                // 通过Scanner读取用户请求中的数据
                Scanner requestScanner = new Scanner(inputStream);
                if (!requestScanner.hasNextLine()) {
                    // 日志
                    clientInfo = MessageFormat.format("[{0}:{1}] 客户端已下线.", clientSocket.getInetAddress(),
                            clientSocket.getPort());
                    System.out.println(clientInfo);
                    break;
                }
                // 获取真实的用户请求数据
                String request = requestScanner.nextLine();
                // 根据请求计算响应
                String response = process(request);
                // 把响应写回客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 写入输出流
                printWriter.println(response);
                // 强制刷新缓冲区
                printWriter.flush();
                // 打印日志
                clientInfo = MessageFormat.format("[{0}:{1}], request: {2}, response: {3}",
                        clientSocket.getInetAddress(), clientSocket.getPort(), request, response);
                System.out.println(clientInfo);

            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }

    }

    private String process(String request) {
        System.out.println("收到新消息："  + request);
        Scanner scanner = new Scanner(System.in);
        String response = scanner.nextLine();
        return response;
    }

    public static void main(String[] args) throws IOException {
        TCPEchoServerThreadPool server = new TCPEchoServerThreadPool(9999);
        server.start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
  • 相关阅读:
    【图像分割】Unet-ConvLstm利用时序信息进行视频分割
    初始 Docker【介绍以及安装】
    每天五分钟计算机视觉：如何在现有经典的卷积神经网络上进行微调
    LeetCode 图解 | 206.反转链表（附有知识点回顾）
    CSDN编程竞赛第八期 | 参赛经历分享
    算法通关村17关 | 透析跳跃游戏
    酒类商城小程序怎么做
    力扣打卡之两数之和【有序数组和无序数组】
    依赖注入(DI)，自动配置，集合注入
    Mac 制作可引导安装器
  • 原文地址：https://blog.csdn.net/qq_53869058/article/details/130893699