本文目录导读：
我将为您提供一个完整的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();
}
}
}
运行说明
要运行这些程序：
-
TCP通信：
- 先运行
TCPServer.main() - 再运行
TCPClient.main()（可以运行多个客户端）
- 先运行
-
UDP通信：
- 先运行
UDPServer.main() - 再运行
UDPClient.main()
- 先运行
-
文件传输：
- 先运行
FileServer.main() - 再运行
FileClient，传入文件路径参数
- 先运行
重要特性
- TCP：可靠的面向连接的协议，适合需要可靠性保证的场景
- UDP：无连接协议，适合实时性要求高、允许丢包的场景
- 多线程处理：服务器可以同时处理多个客户端
- 资源管理：使用try-with-resources自动关闭资源
这个案例涵盖了Java网络编程的主要方面,可以作为学习和开发网络应用的参考，您可以根据自己的需求修改和扩展这些代码。
