【Java网络编程】使用Tcp和Udp实现一个小型的回声客户端服务器程序

于 2024-09-25 23:17:11 发布
阅读量950 收藏 64
点赞数 82
分类专栏： JavaEE 文章标签： 网络 java tcp/ip 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yican2580/article/details/142525286
版权

网络编程的概念

Java中的网络编程是指使用Java语言及其库创建和管理网络应用程序的过程。这一过程使得不同的计算机可以通过网络进行通信和数据交换。Java提供了一系列强大的API（应用程序编程接口）来支持网络编程，主要涉及以下几个概念：

  1. Socket：Socket是网络通信的基础，代表一个网络连接的端点。在Java中，Socket类用于实现客户端的网络通信，而ServerSocket类用于实现服务器的网络通信。通过Socket，客户端可以连接到服务器，进行数据的发送和接收。

  2. 协议：网络通信通常依赖于特定的通信协议，如TCP（传输控制协议）和UDP（用户数据报协议）。TCP是一种面向连接的协议，提供可靠的数据传输；而UDP则是一种无连接的协议，适用于对速度要求较高但对可靠性要求较低的场景。

  3. IP地址和端口号：IP地址用于唯一标识网络上的设备，而端口号则用于标识特定的应用程序或服务。Java网络编程中，需要通过这些信息来建立连接。

  4. URL（统一资源定位符）：Java中的网络编程还涉及到处理URL，使用URL类可以轻松地访问网络资源，如网页和文件。

  5. 多线程：在网络编程中，尤其是服务器端，使用多线程可以提高并发处理能力，允许多个客户端同时连接和交互。

  6. 数据流：Java网络编程中通常涉及输入流和输出流进行数据的读写，这使得客户端和服务器可以方便地交换信息。

Java的网络编程广泛应用于各种应用场景，如网页服务、网络游戏、即时通讯工具等。通过这些技术，开发者能够构建灵活且高效的网络应用，便捷地实现信息的传递与共享。

使用Udp协议实现简单的客户端服务器程序

服务器代码编写

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

/**
 * 自定义UDP服务器程序
 */
public class UdpEchoServer {

    // 创建DatagramSocket对象，用于接收和发送UDP数据包
    private DatagramSocket socket = null;

    /**
     * 构造函数，初始化DatagramSocket并绑定到指定端口
     * 
     * @param port 服务器监听的端口号
     * @throws SocketException 创建Socket时抛出的异常
     */
    public UdpEchoServer(int port) throws SocketException {
        this.socket = new DatagramSocket(port);
    }

    /**
     * 启动UDP服务器，开始监听和处理客户端请求
     * 
     * @throws IOException 处理数据包时可能抛出的异常
     */
    public void start() throws IOException {
        // 输出服务器启动信息
        System.out.println("服务器启动！！");

        // 持续监听客户端请求
        while (true) {
            // 创建一个空的数据包，用于接收客户端发送的数据
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            // 接收客户端发送的数据包
            socket.receive(requestPacket);

            // 将接收到的数据转换为字符串
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());

            // 处理请求并生成相应的响应数据
            String response = process(request);

            // 创建响应数据包，包含响应内容
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
                    response.getBytes().length, requestPacket.getSocketAddress());

            // 发送响应数据包回客户端
            socket.send(responsePacket);

            // 输出请求的信息和服务器的响应
            System.out.printf("[%s,%d],%s,%s\n", requestPacket.getAddress(), requestPacket.getPort(),
                    request, response);
        }
    }

    /**
     * 处理客户端请求
     * 
     * @param request 客户端发送的请求
     * @return 返回响应内容
     */
    protected String process(String request) {
        // 此处简单返回请求内容，作为回声服务器
        return request;
    }

    /**
     * 主函数，程序入口
     * 
     * @param args 命令行参数
     * @throws IOException 启动服务器时可能抛出的异常
     */
    public static void main(String[] args) throws IOException {
        // 创建UDP服务器，监听9090端口
        UdpEchoServer server = new UdpEchoServer(9090);
        // 启动服务器
        server.start();
    }
}

代码实现和功能解析：

  1. 类定义：UdpEchoServer类定义了一个简单的UDP回声服务器，使用UDP协议与客户端进行通信。

  2. 成员变量：

    • private DatagramSocket socket：用于发送和接收UDP数据包的DatagramSocket。

  3. 构造函数：

    • UdpEchoServer(int port)：创建一个DatagramSocket对象并绑定到指定的端口。端口号作为参数传入。

  4. 启动服务器：

    • public void start()：这个方法负责启动服务器并处理来自客户端的请求。
      • 在方法内，使用一无限循环while (true)来持续监听客户端请求。
      • 创建一个DatagramPacket对象用于接收数据。

  5. 接收数据：

    • 使用socket.receive(requestPacket)接收客户端发送的UDP数据包。

  6. 处理请求：

    • 将接收到的数据转换为字符串，调用process方法来处理请求。此例中，process方法简单地返回请求的内容。

  7. 发送响应：

    • 创建一个响应数据包，并使用socket.send(responsePacket)方法将响应发送回客户端。

  8. 输出请求和响应信息：

    • 使用System.out.printf()打印客户端信息（地址和端口）、请求内容及响应内容。

  9. 主方法：

    • public static void main(String[] args)是程序入口，创建一个UdpEchoServer实例，并在9090端口启动服务器。

功能总结：

这个UDP回声服务器能够接收客户端发送的UDP数据包，并将相同的数据回传给客户端。它可以处理多个客户端请求，实现基本的网络通信功能，适用于需要快速、简单消息传递的应用场景。

客户端代码编写

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

/**
 * 自定义UDP客户端程序
 */
public class UdpEchoClient {
    // 发送和接收UDP数据包的Socket对象
    private DatagramSocket socket = null;
    // 服务器的IP地址
    private String ip;
    // 服务器的端口号
    private int port;

    /**
     * 构造函数，初始化DatagramSocket并设置服务器的IP和端口
     * 
     * @param ip   服务器的IP地址
     * @param port 服务器的端口号
     * @throws SocketException 创建Socket时抛出的异常
     */
    public UdpEchoClient(String ip, int port) throws SocketException {
        this.socket = new DatagramSocket(); // 创建一个无特定端口的DatagramSocket
        this.ip = ip; // 设置服务器的IP
        this.port = port; // 设置服务器的端口
    }

    /**
     * 启动UDP客户端，发送请求并接收响应
     * 
     * @throws IOException 处理数据包时可能抛出的异常
     */
    public void start() throws IOException {
        System.out.println("客户端启动!!"); // 输出客户端启动信息
        while (true) {
            // 创建Scanner对象用于接收用户输入
            Scanner scanner = new Scanner(System.in);
            System.out.println("->"); // 提示用户输入
            String request = scanner.next(); // 读取用户输入的请求内容

            // 创建请求数据包
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(ip), port);
            // 发送请求数据包到服务器
            socket.send(requestPacket);

            // 创建响应数据包，用于接收服务器的响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            // 接收服务器发送的响应
            socket.receive(responsePacket);

            // 将接收到的响应数据转换为字符串
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            // 输出服务器的响应
            System.out.println(response);
        }
    }

    /**
     * 主函数，程序入口
     * 
     * @param args 命令行参数
     * @throws IOException 初始化客户端时可能抛出的异常
     */
    public static void main(String[] args) throws IOException {
        // 创建UDP客户端，连接到本地服务器9090端口
        UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
        // 启动客户端
        client.start();
    }
}

代码实现和功能解析：

  1. 类定义：UdpEchoClient 类定义了一个UDP客户端，该客户端能够向服务器发送请求并接收响应。

  2. 成员变量：

    • private DatagramSocket socket：用于发送和接收UDP数据包的DatagramSocket。
    • private String ip：服务器的IP地址。
    • private int port：服务器的端口号。

  3. 构造函数：

    • UdpEchoClient(String ip, int port)：在构造函数中，创建一个DatagramSocket实例并绑定到一个随机端口。设置服务器的IP和端口，以便后续发送请求。

  4. 启动客户端：

    • public void start()：该方法负责启动客户端并处理用户输入。
      • 输出“客户端启动!!”以确认客户端已启动。
      • 进入一个无限循环，使用Scanner类接收用户输入的信息。

  5. 发送请求：

    • 用户输入请求数据后，生成一个DatagramPacket（请求数据包），包括请求数据、地址（服务器的IP）和端口号（服务器的端口）。
    • 调用socket.send(requestPacket)将请求数据包发送到服务器。

  6. 接收响应：

    • 创建一个大小为4096字节的DatagramPacket（响应数据包）用于接收来自服务器的响应。
    • 使用socket.receive(responsePacket)方法接收服务器返回的响应。

  7. 处理响应：

    • 将接收到的响应数据通过new String()转换为字符串，并输出到控制台。

  8. 主方法：

    • public static void main(String[] args)是程序的入口点，首先创建一个客户端实例，连接到本机的9090端口的服务器，然后调用start()方法启动客户端。

功能总结：

这个UDP客户端能够实时接收用户输入，将输入数据通过UDP协议发送给指定的服务器（在本例中是本地服务器），并输出服务器回传的响应。它可以用于测试UDP服务，验证网络连接和数据传输的有效性。同时，该客户端可以适应多种应用场景，如即时消息传递、简单的命令行交互等。

Udp简单回声客户端服务器程序使用

首先运行 UdpEchoServer 类（Udp服务器），在使用客户端通信之前必须先保证启动了服务器。

其次运行 UdpEchoClient 类（Udp客户端）。

在客户端发送需求：

服务器结果显示： 

使用Tcp协议实现简单的客户端服务器程序

服务器代码编写

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;

/**
 * 自定义TCP回声服务器程序
 */
public class TcpEchoServer {

    // ServerSocket对象，用于监听连接请求
    private ServerSocket socket = null;

    /**
     * 构造函数，初始化ServerSocket并绑定到指定的端口
     * 
     * @param port 服务器监听的端口号
     * @throws IOException 创建ServerSocket时抛出的异常
     */
    public TcpEchoServer(int port) throws IOException {
        this.socket = new ServerSocket(port); // 在指定端口创建一个ServerSocket
    }

    /**
     * 启动TCP服务器，开始接受客户端连接
     * 
     * @throws IOException 处理请求时可能抛出的异常
     */
    public void start() throws IOException {
        System.out.println("服务器启动！"); // 输出服务器启动信息
        // 创建一个线程池，用于处理多个客户端的连接
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        while (true) {
            // 等待并接受来自客户端的连接
            Socket clientSocket = socket.accept();
            // 启动一个新线程来处理该客户端的请求
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket); // 处理与客户端的连接
                    } catch (IOException e) {
                        throw new RuntimeException(e); // 捕获异常并抛出
                    }
                }
            });
        }
    }

    /**
     * 处理与客户端的连接
     * 
     * @param clientSocket 与客户端的Socket连接
     * @throws IOException 处理输入输出流时可能抛出的异常
     */
    private void processConnection(Socket clientSocket) throws IOException {
        // 输出客户端的地址和端口
        System.out.printf("[%s,%d],客户端已连接！\n", clientSocket.getInetAddress(), clientSocket.getPort());

        try (InputStream inputStream = clientSocket.getInputStream(); // 获取输入流
             OutputStream outputStream = clientSocket.getOutputStream()) { // 获取输出流

            while (true) {
                Scanner scanner = new Scanner(inputStream); // 创建Scanner以读取输入流

                if (!scanner.hasNext()) { // 如果没有输入，客户端下线
                    System.out.println("客户端下线！\n");
                    break; // 退出循环
                }

                String request = scanner.next(); // 读取请求
                String response = process(request); // 处理请求并生成响应

                // 创建PrintWriter以发送响应
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response); // 发送响应数据
                printWriter.flush(); // 刷新输出流，强制将数据发送

                // 输出请求和响应的信息
                System.out.printf("[%s,%d],请求：%s，响应：%s\n", clientSocket.getInetAddress(),
                        clientSocket.getPort(), request, response);
            }

        } catch (IOException e) {
            e.printStackTrace(); // 捕获并打印异常
        } finally {
            clientSocket.close(); // 关闭与客户端的连接
        }
    }

    /**
     * 处理客户端请求并生成响应
     * 
     * @param request 客户端发送的请求
     * @return 返回响应内容
     */
    private String process(String request) {
        // 此处简单返回请求内容，作为回声服务器
        return request;
    }

    /**
     * 主函数，程序入口
     * 
     * @param args 命令行参数
     * @throws IOException 启动服务器时可能抛出的异常
     */
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(9090); // 创建TcpEchoServer实例，监听9090端口
        server.start(); // 启动服务器
    }
}

代码实现和功能解析：

  1. 类定义：TcpEchoServer 类实现了一个TCP回声服务器，能够接受客户端的连接并回传客户端发送的信息。

  2. 成员变量：

    • private ServerSocket socket：用于监听连接请求的ServerSocket对象。

  3. 构造函数：

    • TcpEchoServer(int port)：在指定端口创建一个ServerSocket以接受连接。

  4. 启动服务器：

    • public void start()：该方法负责启动服务器并不断监听客户端的连接请求。
      • 输出服务器启动信息。
      • 创建一个线程池，用于并发处理最多10个客户端请求。

  5. 接受连接：

    • 使用socket.accept()方法等待并接受客户端的连接。当有客户端连接时，创建一个Socket对象以与客户端进行通信。

  6. 处理连接：

    • 对于每个连接，使用executorService.submit()方法将连接的处理逻辑提交到线程池中执行，调用processConnection(clientSocket)方法来处理客户端的请求。

  7. 处理客户端请求：

    • processConnection(Socket clientSocket)：
      • 输出客户端的IP地址和端口信息。
      • 利用输入流InputStream和输出流OutputStream进行数据交互。
      • 使用Scanner读取客户端发送的请求，直到客户端关闭连接。
      • 对每个请求调用process(request)处理并生成响应，然后通过PrintWriter发送回客户端。

  8. 生成响应：

    • process(String request)：此示例中，服务器将客户端请求的内容直接返回，作为回声服务器的简单实现。

  9. 主方法：

    • public static void main(String[] args)是程序的入口，创建一个TcpEchoServer实例并启动它，监听9090端口。

功能总结：

这个TCP回声服务器能够接受多个客户端的连接，并实现与每个客户端的通信。客户端发送的消息被原样返回，适合用于测试和验证TCP连接的有效性。由于使用了线程池，可以并发处理多个客户端的请求，大大提高了服务器的性能和响应能力。

客户端代码编写

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

/**
 * 自定义TCP回声客户端程序
 */
public class TcpEchoClient {

    // 与服务器的Socket连接
    private Socket socket = null;

    /**
     * 构造函数，初始化Socket并与服务器建立连接
     * 
     * @param serverIP 服务器的IP地址
     * @param port     服务器的端口号
     * @throws IOException 创建Socket时抛出的异常
     */
    public TcpEchoClient(String serverIP, int port) throws IOException {
        this.socket = new Socket(serverIP, port); // 创建Socket并连接到指定IP和端口
    }

    /**
     * 启动TCP客户端，发送请求并接收响应
     */
    public void start() {
        System.out.println("客户端启动！"); // 输出客户端启动信息
        Scanner scanner = new Scanner(System.in); // 创建Scanner以读取用户输入

        try (InputStream inputStream = socket.getInputStream(); // 获取与服务器的输入流
             OutputStream outputStream = socket.getOutputStream()) { // 获取与服务器的输出流
             
            PrintWriter printWriter = new PrintWriter(outputStream); // 创建PrintWriter以便发送文本数据
            while (true) {
                System.out.println("->"); // 提示用户输入
                String request = scanner.next(); // 读取用户输入的请求
                printWriter.println(request); // 发送请求到服务器
                printWriter.flush(); // 刷新输出流，确保数据被发送

                Scanner scannerNetwork = new Scanner(inputStream); // 从输入流中读取响应
                String response = scannerNetwork.next(); // 获取服务器的响应
                System.out.println(response); // 输出服务器的响应
            }

        } catch (IOException e) {
            throw new RuntimeException(e); // 捕获异常并抛出
        }
    }

    /**
     * 主函数，程序入口
     * 
     * @param args 命令行参数
     * @throws IOException 启动客户端时可能抛出的异常
     */
    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090); // 创建TcpEchoClient实例，连接到本地服务器的9090端口
        client.start(); // 启动客户端
    }
}

代码实现和功能解析：

  1. 类定义：TcpEchoClient 类实现了一个TCP回声客户端，能够向TCP回声服务器发送请求并获得响应。

  2. 成员变量：

    • private Socket socket：存储与服务器的Socket连接对象。

  3. 构造函数：

    • TcpEchoClient(String serverIP, int port)：在构造函数中，创建一个Socket实例并连接到指定的服务器IP和端口。

  4. 启动客户端：

    • public void start() 方法负责启动客户端并处理用户的输入和服务器的响应。
      • 输出“客户端启动！”以确认客户端已启动。
      • 创建一个Scanner对象用于获取用户输入的信息。

  5. 获取输入输出流：

    • 使用socket.getInputStream()和socket.getOutputStream()分别获取与服务器通信的输入流和输出流。

  6. 发送请求：

    • 创建一个PrintWriter对象，以便能够将文本数据写入输出流。
    • 在无限循环中，程序提示用户输入内容，读取用户输入的请求。
    • 将请求通过PrintWriter发送到服务器，并调用flush()方法确保数据被及时发送。

  7. 接收响应：

    • 使用Scanner对象从输入流中读取服务器响应的数据。
    • 获取并打印服务器返回的响应内容。

  8. 主方法：

    • public static void main(String[] args)是程序的入口，创建一个TcpEchoClient实例并与本地的9090端口的服务器连接，然后调用start()方法启动客户端。

功能总结：

这个TCP回声客户端能够实时读取用户输入，并将输入的数据发送给指定的TCP回声服务器（在本例中是本地服务器的9090端口）。它的功能在于能够发送消息并获得服务器的回声响应，适合实现基本的TCP连接测试和了解客户端与服务器之间的数据交互。由于实现了无限循环，客户端可以持续进行多次交互，直至手动停止。

Tcp简单回声客户端服务器程序使用

首先运行 TcpEchoServer 类（Tcp服务器），在使用客户端之前，必须先启动服务器。

其次运行  TcpEchoClient 类（Tcp服务器）

 在客户端输入请求，得到响应：

在服务器程序观察结果：

 

一只淡水鱼66
关注
专栏目录
CCIE重认证350-401
stqer的博客
01-04 2205
traffic policing： causes TCP retransmissions when traffic is dropped导致TCP重传时流量下降 introduces no delay and jitter引入无延迟和抖动 drops excessive traffic减少过多的流量 traffic shaping： buffers excessive traffic缓冲过多的流量 introduces delay and jitter引入延迟和抖动 applied on traffic t
2022年Java 工程师面试题
weixin_42572320的博客
03-03 2530
第 1 页 共 485 页 目录 1、什么是 Mybatis？............................................................................... 33 2、Mybaits 的优点：............................................................................... 33 3、MyBatis 框架的缺点：.............................
Python 网络编程
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
02-05 4325
Python 网络编程
【计算机网络】—— IP协议及动态路由算法
ZShiJ的博客
10-26 2237
IP协议，全称为Internet Protocol，中文名为互联网协议，是用于数据包在互联网上进行传输的规则。它是TCP/IP协议族中的核心协议之一，负责将数据分割成小的数据包，然后在网络中进行传输。 动态路由算法是一种在路由设备之间自动发现和计算最佳路径的方法。它可以根据网络拓扑的变化自动调整路由表，从而保证数据包能够快速、准确地到达目的地。常见的动态路由算法有RIP（Routing Information Protocol）、OSPF（Open Shortest Path First）和BGP等
转载-计算机网络原理
greatliuda的博客
03-05 7816
计算机信息管理专业课程 最新自考笔记 : https://github.com/Eished/self-study-exam_notes 计算机网络 国家精品课 课程地址：https://www.icourse163.org/course/HIT-154005 讲师：李全龙、聂兰顺 课件整合补充：Eished 视频总时长：37:25:46 计算机网络原理 04741 历年真题分析 201910 202008 202104 201904 201810 201804 题型 单项选择题：25小题，每小.
2020-09-15 JAVA面试题整理
weixin_44038860的博客
09-15 2828
2020年字节跳动Java面试题附答案解析 前言 个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、 丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！ 本篇分享的面试题内容包括：Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Redis、MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、Linux 等技术栈。 一、Java基础系列面试题 1、面
计算机网络复习笔记
wukai1211的博客
03-04 856
目录 目录 目录 1 计算机网络概述 1.1 网络概念 1.2 数据交换方式 1.3 网络分类 1.4 网络的性能指标 1.5 网络体系结构 1. 概念 2. OSI参考模型 1 物理层 2 数据链路层 3 网络层 4 传输层 5 会话层 6 表示层 7 应用层 通信过程 数据封装 网络排错 3. TCP/IP参考模型 4. 5层参考模型 5层结构 数据封装.
后端: 互动直播之WebRTC服务开源技术选型
YYniannian的博客
07-11 3146
最原始的直播系统其实并没有想象的那么复杂，无非就是主播端将音视频数据推送到服务器，观众端则从服务器拉取数据播放。
直播软件开发互动直播之WebRTC服务开源技术选型
云豹直播源码
08-21 1450
直播软件开发互动直播之WebRTC服务开源技术选型 1 直播基础知识 最原始的直播系统其实并没有想象的那么复杂，无非就是主播端将音视频数据推送到服务器，观众端则从服务器拉取数据播放。 1.1 基本常识 1.1.1 基础概念 推流 推流，是直播中的一个术语，意思是将流媒体数据推送到服务器。如何推流，关键就在于使用的推流协议。 拉流 拉流，指的是观众端流媒体数据的拉取，同样也需要通过约定的拉流协议来拉取。 视频帧 帧，是视频的一个基本概念，表示一张画面，如上面的翻页动画书中的一
java网络编程使用tcp、udp实现多用户对话
01-10
总之，Java网络编程使用TCP和UDP实现多用户对话，涉及到客户端与服务器的连接建立、数据传输、异常处理、多线程或异步编程、以及安全性等多个方面。通过学习和实践，可以掌握这些关键技术，为开发高效、稳定的网络...
Java网络编程之TCP协议下—上传文件到服务器程序
03-09
本教程将重点讲解如何利用Java实现一个简单的TCP文件上传到服务器的程序。 首先，我们来看`uploadServer.java`。这个文件代表服务器端的程序，主要任务是监听客户端的连接请求，并接收客户端发送过来的文件。在Java...
浅谈java的TCP和UDP编程(附实例讲解)
08-30
在 UDP 客户端编程中，我们可以使用 DatagramSocket 类和 DatagramPacket 类来实现客户端的功能。客户端首先创建了一个 DatagramSocket 对象，并使用 send() 方法来发送数据报文到服务器。然后，它使用 receive() ...
MFC：Socket编程—TCP服务端和多个客户端通信 示例代码
01-12
在本文中，我们将深入探讨MFC（Microsoft Foundation Classes）中的Socket编程，特别是如何实现一个TCP服务端与多个客户端之间的通信。MFC是微软提供的一套C++类库，用于简化Windows应用程序开发，其中包括对网络...
kubernetes网络(一)之calico详解
最新发布
鲜少伟的博客
09-22 1148
本文介绍Kubernetes最流行的网络解决方案calico。
网络高级day03（Http）
dghbs的博客
09-21 1187
HTTP
netty编程之基于websocket发送二进制数据
wang0907的博客
09-20 566
本文看下基于websocket发送二进制数据。
linux网络编程5
qq_65818377的博客
09-21 854
将套接字修改为被动，让操作系统给该套接字设置一个连接队伍，用来记录所有连接到该套接字的连接。关闭使用socket函数创建的套接字，会导致服务器无法接收新的连接，但不会影响已经连接的；其是关闭一个代表已经连接套接字，则会出现向另外一端接收到一个长度为0的数据包；关闭accept返回的套接字，则会导致其连接关闭，但不会影响服务器的；backlog：连接队列的长度，即设置服务器最大的连接客服的数量。其返回的是一个已连接的套接字，这个套接字代表当前这个连接。connect建立连接后不会产生新的套接字；
7、论等保的必要性
weixin_43263566的博客
09-21 1036
目前，金融、电力、广电、医疗、教育等行业已经下发了相关文件。2007年6月发布的《信息安全等级保护管理办法》（公通字[2007]143号）规定了实施该制度的原则、内容、职责分工、基本要求和实施计划，明确了操作办法。梳理不同等级的系统后，应对其进行相应等级的安全防护建设，确保重要信息系统在遭受攻击时能够有效抵御，或在被攻击后快速恢复应用，以避免重大损失或影响。开展等级保护的最重要原因是通过测评工作，发现单位系统内外部的安全风险和脆弱性，整改后提升信息安全防护能力，降低被各种攻击的风险。
评论 57
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值