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

企业开发 2024-11-04 22:07:52 阅读次数: 0

网络编程的概念

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服务器）

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

在服务器程序观察结果：

猜你喜欢

转载自blog.csdn.net/yican2580/article/details/142525286
今日推荐
周排行
服务器配置密钥登录
5.从尾到头打印链表
PAT_Basic Level_Practice_1003 (20)
从Java内存模型讲双重检查锁原理
Gated Self-Matching Networks for Reading Comprehension and Question Answering论文阅读笔记
博客项目注意点
SpringBoot2.x webflux响应式编程实战
二叉树的相关笔记
spring中@RequestBody，bean中属性名和json不一致解决方案
蓝桥杯 传球游戏（dp）
每日归档
更多
2024-12-21(0)
2024-12-20(0)
2024-12-19(0)
2024-12-18(0)
2024-12-17(0)
2024-12-16(0)
2024-12-15(0)
2024-12-14(0)
2024-12-13(0)
2024-12-12(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022