Java网络编程案例

本文目录导读：

1. TCP通信案例（Socket编程）
2. UDP通信案例
3. 文件传输案例
4. 常见使用示例
5. 运行说明
6. 重要特性

我将为您提供一个完整的Java网络编程案例,涵盖TCP和UDP通信。

TCP通信案例（Socket编程）

服务器端代码

import java.io.*;
import java.net.*;
import java.util.concurrent.*;
public class TCPServer {
    private static final int PORT = 8888;
    private static volatile boolean running = true;
    private static final ExecutorService threadPool = Executors.newFixedThreadPool(10);
    public static void main(String[] args) {
        System.out.println("TCP服务器启动，监听端口：" + PORT);
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            while (running) {
                try {
                    Socket clientSocket = serverSocket.accept();
                    System.out.println("客户端连接：" + clientSocket.getInetAddress());
                    // 为每个客户端创建独立线程处理
                    threadPool.submit(() -> handleClient(clientSocket));
                } catch (IOException e) {
                    if (running) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
    private static void handleClient(Socket socket) {
        try (socket;
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
            String message;
            while ((message = in.readLine()) != null) {
                System.out.println("收到客户端消息：" + message);
                // 服务器响应
                String response = "服务器收到消息：" + message;
                out.println(response);
                // 处理退出命令
                if ("quit".equalsIgnoreCase(message)) {
                    break;
                }
            }
            System.out.println("客户端断开连接");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 停止服务器的方法
    public static void stopServer() {
        running = false;
    }
}

客户端代码

import java.io.*;
import java.net.*;
public class TCPClient {
    private static final String SERVER_HOST = "localhost";
    private static final int SERVER_PORT = 8888;
    public static void main(String[] args) {
        try (Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in))) {
            System.out.println("已连接到服务器，输入消息发送（输入quit退出）");
            String userInput;
            while ((userInput = consoleReader.readLine()) != null) {
                // 发送消息到服务器
                out.println(userInput);
                // 接收服务器响应
                String response = in.readLine();
                System.out.println("服务器响应：" + response);
                if ("quit".equalsIgnoreCase(userInput)) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

UDP通信案例

UDP服务器

import java.net.*;
public class UDPServer {
    private static final int PORT = 9999;
    private static final int BUFFER_SIZE = 1024;
    public static void main(String[] args) {
        byte[] buffer = new byte[BUFFER_SIZE];
        try (DatagramSocket socket = new DatagramSocket(PORT)) {
            System.out.println("UDP服务器启动，监听端口：" + PORT);
            while (true) {
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
                socket.receive(packet);
                // 解析收到的数据
                String message = new String(packet.getData(), 0, packet.getLength());
                InetAddress clientAddress = packet.getAddress();
                int clientPort = packet.getPort();
                System.out.println("收到来自 " + clientAddress + ":" + clientPort + " 的消息：" + message);
                // 发送响应
                String response = "UDP服务器已收到消息：" + message;
                byte[] responseData = response.getBytes();
                DatagramPacket responsePacket = new DatagramPacket(
                    responseData, responseData.length, clientAddress, clientPort
                );
                socket.send(responsePacket);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

UDP客户端

import java.net.*;
import java.io.*;
public class UDPClient {
    private static final String SERVER_HOST = "localhost";
    private static final int SERVER_PORT = 9999;
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket();
             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in))) {
            InetAddress serverAddress = InetAddress.getByName(SERVER_HOST);
            System.out.println("UDP客户端启动，输入消息发送（输入quit退出）");
            String input;
            while ((input = consoleReader.readLine()) != null) {
                if ("quit".equalsIgnoreCase(input)) {
                    break;
                }
                // 发送数据
                byte[] sendData = input.getBytes();
                DatagramPacket sendPacket = new DatagramPacket(
                    sendData, sendData.length, serverAddress, SERVER_PORT
                );
                socket.send(sendPacket);
                // 接收响应
                byte[] buffer = new byte[1024];
                DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
                socket.receive(receivePacket);
                String response = new String(receivePacket.getData(), 0, receivePacket.getLength());
                System.out.println("服务器响应：" + response);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

文件传输案例

文件服务器

import java.io.*;
import java.net.*;
public class FileServer {
    private static final int PORT = 7777;
    private static final String FILE_DIRECTORY = "server_files/";
    public static void main(String[] args) {
        // 创建文件存储目录
        new File(FILE_DIRECTORY).mkdirs();
        System.out.println("文件服务器启动，监听端口：" + PORT);
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            while (true) {
                Socket socket = serverSocket.accept();
                System.out.println("客户端连接：" + socket.getInetAddress());
                // 处理文件上传
                handleFileUpload(socket);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static void handleFileUpload(Socket socket) {
        try (socket;
             DataInputStream dis = new DataInputStream(socket.getInputStream());
             DataOutputStream dos = new DataOutputStream(socket.getOutputStream())) {
            // 读取文件名
            String fileName = dis.readUTF();
            // 读取文件大小
            long fileSize = dis.readLong();
            System.out.println("接收文件：" + fileName + "（大小：" + fileSize + "字节）");
            // 保存文件
            String savePath = FILE_DIRECTORY + fileName;
            try (FileOutputStream fos = new FileOutputStream(savePath)) {
                byte[] buffer = new byte[4096];
                int read;
                long remaining = fileSize;
                while (remaining > 0 && (read = dis.read(buffer, 0, (int)Math.min(buffer.length, remaining))) != -1) {
                    fos.write(buffer, 0, read);
                    remaining -= read;
                }
            }
            // 发送成功响应
            dos.writeUTF("文件接收成功：" + fileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件客户端

import java.io.*;
import java.net.*;
public class FileClient {
    private static final String SERVER_HOST = "localhost";
    private static final int SERVER_PORT = 7777;
    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("使用方法：java FileClient <文件路径>");
            return;
        }
        String filePath = args[0];
        File file = new File(filePath);
        if (!file.exists()) {
            System.out.println("文件不存在：" + filePath);
            return;
        }
        try (Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
             DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
             DataInputStream dis = new DataInputStream(socket.getInputStream());
             FileInputStream fis = new FileInputStream(file)) {
            System.out.println("连接服务器成功，开始上传文件...");
            // 发送文件名和大小
            dos.writeUTF(file.getName());
            dos.writeLong(file.length());
            // 发送文件内容
            byte[] buffer = new byte[4096];
            int read;
            while ((read = fis.read(buffer)) != -1) {
                dos.write(buffer, 0, read);
            }
            dos.flush();
            // 接收服务器响应
            String response = dis.readUTF();
            System.out.println(response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

常见使用示例

public class NetworkDemo {
    public static void main(String[] args) {
        // 演示线程化TCP服务器
        System.out.println("=== TCP服务器 ===");
        // 启动TCP服务器在单独线程
        new Thread(() -> TCPServer.main(new String[]{})).start();
        try {
            Thread.sleep(1000); // 等待服务器启动
            // 运行TCP客户端
            System.out.println("\n=== TCP客户端 ===");
            // 这里可以填写自动测试的消息
            testTCPClient();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private static void testTCPClient() {
        try (Socket socket = new Socket("localhost", 8888);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
            String[] messages = {"你好服务器", "测试消息", "quit"};
            for (String msg : messages) {
                out.println(msg);
                String response = in.readLine();
                System.out.println("服务器响应：" + response);
                Thread.sleep(200);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行说明

要运行这些程序：

1. TCP通信：

   • 先运行 TCPServer.main()
   • 再运行 TCPClient.main()（可以运行多个客户端）

2. UDP通信：

   • 先运行 UDPServer.main()
   • 再运行 UDPClient.main()

3. 文件传输：

   • 先运行 FileServer.main()
   • 再运行 FileClient，传入文件路径参数

重要特性

• TCP：可靠的面向连接的协议，适合需要可靠性保证的场景
• UDP：无连接协议，适合实时性要求高、允许丢包的场景
• 多线程处理：服务器可以同时处理多个客户端
• 资源管理：使用try-with-resources自动关闭资源

这个案例涵盖了Java网络编程的主要方面,可以作为学习和开发网络应用的参考，您可以根据自己的需求修改和扩展这些代码。