胖厨胡学斌1. Java网络编程基础概念
计算机网络是现代软件开发中不可或缺的基础设施，而Java作为一门成熟的编程语言，提供了完善的网络编程支持。要理解Java网络编程，首先需要掌握几个核心概念。
IP地址是网络通信的基础，它就像是计算机在网络中的"门牌号"。在Java中，我们可以使用InetAddress类来获取和操作IP地址：
java复制// 获取本机IP地址
InetAddress localHost = InetAddress.getLocalHost();
System.out.println("本地主机地址: " + localHost);
// 根据域名获取IP地址
InetAddress googleAddress = InetAddress.getByName("www.google.com");
System.out.println("Google服务器地址: " + googleAddress);
端口号则是应用程序在计算机上的"房间号"，它是一个16位的整数（0-65535）。其中0-1023是系统保留端口，我们在开发时通常使用1024以上的端口。Java中创建服务器端程序时，需要指定监听的端口号。
协议是通信双方约定的规则，TCP/IP协议族中最常用的两个传输层协议是：
- TCP协议：面向连接、可靠传输，像打电话一样需要建立连接
- UDP协议：无连接、不可靠但高效，像发短信一样简单快速
在Java中，TCP编程主要通过Socket和ServerSocket类实现，而UDP编程则使用DatagramSocket和DatagramPacket类。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. TCP编程实战
2.1 基础TCP服务器实现
让我们从最简单的TCP服务器开始，这是一个可以接收客户端连接并回显消息的服务器：
java复制public class SimpleEchoServer {
public static void main(String[] args) throws IOException {
// 在端口8080上创建服务器套接字
try (ServerSocket serverSocket = new ServerSocket(8080)) {
System.out.println("服务器启动，等待连接...");
// 接受客户端连接
Socket clientSocket = serverSocket.accept();
System.out.println("客户端已连接: " + clientSocket.getInetAddress());
// 获取输入输出流
BufferedReader in = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("收到消息: " + inputLine);
out.println("服务器回应: " + inputLine); // 回显消息
}
}
}
}
对应的TCP客户端实现：
java复制public class SimpleEchoClient {
public static void main(String[] args) throws IOException {
// 连接到服务器
try (Socket socket = new Socket("localhost", 8080);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
BufferedReader stdIn = new BufferedReader(
new InputStreamReader(System.in))) {
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput); // 发送消息到服务器
System.out.println("服务器回应: " + in.readLine()); // 打印服务器响应
}
}
}
}
2.2 多线程TCP服务器
上面的简单服务器只能处理一个客户端连接，实际应用中我们需要支持多客户端并发连接。下面是改进后的多线程版本：
java复制public class MultiThreadedEchoServer {
public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(8080)) {
System.out.println("多线程服务器启动，等待连接...");
while (true) {
Socket clientSocket = serverSocket.accept();
// 为每个客户端创建新线程
new Thread(new ClientHandler(clientSocket)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static class ClientHandler implements Runnable {
private final Socket clientSocket;
public ClientHandler(Socket socket) {
this.clientSocket = socket;
}
@Override
public void run() {
try (BufferedReader in = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("来自" + clientSocket.getInetAddress() +
"的消息: " + inputLine);
out.println("服务器回应: " + inputLine);
}
} catch (IOException e) {
System.out.println("客户端连接异常: " + e.getMessage());
} finally {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
提示：在实际生产环境中，直接为每个连接创建线程并不是最佳实践，更好的做法是使用线程池或NIO。这里为了演示基本原理使用了简单实现。
3. UDP编程实战
3.1 基础UDP通信
UDP编程相比TCP更简单，因为它不需要建立连接。下面是一个UDP服务器和客户端的实现：
UDP服务器：
java复制public class UdpEchoServer {
public static void main(String[] args) throws IOException {
// 创建UDP套接字，绑定到端口8081
try (DatagramSocket socket = new DatagramSocket(8081)) {
System.out.println("UDP服务器启动，等待数据...");
byte[] buffer = new byte[1024];
while (true) {
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
socket.receive(packet); // 接收数据包
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("收到来自" + packet.getAddress() +
":" + packet.getPort() + "的消息: " + received);
// 准备回发数据
byte[] response = ("UDP服务器回应: " + received).getBytes();
DatagramPacket responsePacket = new DatagramPacket(
response, response.length, packet.getAddress(), packet.getPort());
socket.send(responsePacket); // 发送回应
}
}
}
}
UDP客户端：
java复制public class UdpEchoClient {
public static void main(String[] args) throws IOException {
try (DatagramSocket socket = new DatagramSocket();
BufferedReader stdIn = new BufferedReader(
new InputStreamReader(System.in))) {
InetAddress serverAddress = InetAddress.getByName("localhost");
String userInput;
while ((userInput = stdIn.readLine()) != null) {
byte[] sendData = userInput.getBytes();
// 创建发送数据包
DatagramPacket sendPacket = new DatagramPacket(
sendData, sendData.length, serverAddress, 8081);
socket.send(sendPacket); // 发送数据
byte[] receiveData = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
socket.receive(receivePacket); // 接收回应
String response = new String(receivePacket.getData(), 0, receivePacket.getLength());
System.out.println("服务器回应: " + response);
}
}
}
}
3.2 UDP广播示例
UDP支持广播功能，可以向同一网络内的所有主机发送消息：
java复制public class UdpBroadcaster {
public static void main(String[] args) throws IOException {
try (DatagramSocket socket = new DatagramSocket()) {
socket.setBroadcast(true); // 启用广播
String message = "这是一条广播消息";
byte[] buffer = message.getBytes();
// 广播地址
InetAddress broadcastAddress = InetAddress.getByName("255.255.255.255");
DatagramPacket packet = new DatagramPacket(
buffer, buffer.length, broadcastAddress, 8082);
socket.send(packet);
System.out.println("广播消息已发送");
}
}
}
public class UdpBroadcastReceiver {
public static void main(String[] args) throws IOException {
try (DatagramSocket socket = new DatagramSocket(8082)) {
System.out.println("广播接收器启动...");
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
while (true) {
socket.receive(packet);
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("收到广播消息来自" + packet.getAddress() + ": " + received);
}
}
}
}
4. 高级网络编程技术
4.1 非阻塞I/O (NIO)
Java NIO提供了非阻塞的网络编程能力，适合高并发场景。下面是NIO实现的简单服务器：
java复制public class NioEchoServer {
public static void main(String[] args) throws IOException {
// 创建Selector和ServerSocketChannel
Selector selector = Selector.open();
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.bind(new InetSocketAddress("localhost", 8083));
serverSocket.configureBlocking(false);
serverSocket.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("NIO服务器启动，等待连接...");
while (true) {
selector.select(); // 阻塞直到有事件发生
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iter = selectedKeys.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
if (key.isAcceptable()) {
// 接受新连接
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel client = server.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
System.out.println("客户端连接: " + client.getRemoteAddress());
}
if (key.isReadable()) {
// 读取数据
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = client.read(buffer);
if (bytesRead == -1) {
// 连接关闭
client.close();
System.out.println("客户端断开连接");
} else if (bytesRead > 0) {
buffer.flip();
byte[] bytes = new byte[buffer.remaining()];
buffer.get(bytes);
String received = new String(bytes);
System.out.println("收到消息: " + received);
// 回显消息
ByteBuffer response = ByteBuffer.wrap(("NIO服务器回应: " + received).getBytes());
client.write(response);
}
}
iter.remove();
}
}
}
}
4.2 心跳检测机制
在网络编程中，心跳检测是保持长连接健康的重要手段。下面是一个简单的心跳检测实现：
java复制public class HeartbeatServer {
private static final int HEARTBEAT_INTERVAL = 5000; // 5秒
private static final int TIMEOUT = 10000; // 10秒超时
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8084);
System.out.println("心跳服务器启动，等待连接...");
Socket clientSocket = serverSocket.accept();
clientSocket.setSoTimeout(TIMEOUT);
System.out.println("客户端已连接: " + clientSocket.getInetAddress());
try (BufferedReader in = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
long lastHeartbeatTime = System.currentTimeMillis();
while (true) {
try {
String message = in.readLine();
if (message == null) {
break; // 连接关闭
}
if ("HEARTBEAT".equals(message)) {
lastHeartbeatTime = System.currentTimeMillis();
out.println("HEARTBEAT_ACK");
System.out.println("收到心跳，发送确认");
} else {
System.out.println("收到普通消息: " + message);
out.println("服务器回应: " + message);
}
} catch (SocketTimeoutException e) {
long currentTime = System.currentTimeMillis();
if (currentTime - lastHeartbeatTime > TIMEOUT) {
System.out.println("心跳超时，关闭连接");
break;
}
}
}
} finally {
clientSocket.close();
serverSocket.close();
}
}
}
对应的客户端实现：
java复制public class HeartbeatClient {
private static final int HEARTBEAT_INTERVAL = 5000; // 5秒
public static void main(String[] args) throws IOException {
Socket socket = new Socket("localhost", 8084);
socket.setSoTimeout(10000);
try (BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader stdIn = new BufferedReader(
new InputStreamReader(System.in))) {
// 启动心跳线程
Thread heartbeatThread = new Thread(() -> {
while (!socket.isClosed()) {
try {
Thread.sleep(HEARTBEAT_INTERVAL);
out.println("HEARTBEAT");
System.out.println("发送心跳");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
} catch (IOException e) {
System.out.println("心跳发送失败: " + e.getMessage());
break;
}
}
});
heartbeatThread.setDaemon(true);
heartbeatThread.start();
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("服务器回应: " + in.readLine());
}
} finally {
socket.close();
}
}
}
5. 网络编程中的常见问题与解决方案
5.1 连接超时处理
在网络编程中，连接超时是常见问题。Java提供了设置连接超时的方法：
java复制Socket socket = new Socket();
// 设置连接超时为3秒
socket.connect(new InetSocketAddress("example.com", 80), 3000);
5.2 粘包和拆包问题
TCP是流式协议，没有消息边界，可能会发生粘包（多个消息粘在一起）和拆包（一个消息被拆分成多个包）问题。解决方案包括：
- 固定长度消息：每条消息长度固定，不足补空格
- 分隔符：使用特殊字符作为消息结束标志
- 长度前缀：在消息前添加长度字段
下面是使用长度前缀的示例：
java复制// 发送端
String message = "Hello World";
byte[] messageBytes = message.getBytes();
byte[] lengthBytes = ByteBuffer.allocate(4).putInt(messageBytes.length).array();
// 先发送长度，再发送消息
outputStream.write(lengthBytes);
outputStream.write(messageBytes);
// 接收端
byte[] lengthBytes = new byte[4];
inputStream.read(lengthBytes);
int length = ByteBuffer.wrap(lengthBytes).getInt();
byte[] messageBytes = new byte[length];
inputStream.read(messageBytes);
String message = new String(messageBytes);
5.3 资源泄漏问题
网络编程中常见的资源泄漏包括Socket未关闭、流未关闭等。推荐使用try-with-resources语法自动关闭资源：
java复制try (Socket socket = new Socket("localhost", 8080);
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream()) {
// 使用socket进行通信
} // 自动关闭所有资源
5.4 性能优化建议
- 使用连接池：对于频繁创建关闭连接的应用，使用连接池可以显著提高性能
- 合理设置缓冲区大小：根据应用场景调整Socket缓冲区大小
- 使用NIO或Netty：对于高并发场景，考虑使用NIO或Netty框架
- 启用TCP_NODELAY：禁用Nagle算法，减少小数据包的延迟
java复制// 禁用Nagle算法
socket.setTcpNoDelay(true);
6. 实际应用案例
6.1 简单HTTP服务器实现
下面是一个简单的HTTP服务器实现，可以处理GET请求并返回响应：
java复制public class SimpleHttpServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8085);
System.out.println("HTTP服务器启动，监听端口8085...");
while (true) {
try (Socket clientSocket = serverSocket.accept();
BufferedReader in = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream())) {
// 读取请求头
String requestLine = in.readLine();
System.out.println("收到请求: " + requestLine);
// 简单解析请求
String[] requestParts = requestLine.split(" ");
String method = requestParts[0];
String path = requestParts[1];
// 构建响应
out.println("HTTP/1.1 200 OK");
out.println("Content-Type: text/html; charset=utf-8");
out.println();
out.println("<html><body>");
out.println("<h1>简单HTTP服务器</h1>");
out.println("<p>请求方法: " + method + "</p>");
out.println("<p>请求路径: " + path + "</p>");
out.println("</body></html>");
out.flush();
}
}
}
}
6.2 文件传输实现
下面是使用TCP实现文件传输的示例：
服务器端：
java复制public class FileTransferServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8086);
System.out.println("文件传输服务器启动，等待连接...");
Socket clientSocket = serverSocket.accept();
System.out.println("客户端已连接: " + clientSocket.getInetAddress());
try (InputStream in = clientSocket.getInputStream();
FileOutputStream fileOut = new FileOutputStream("received_file.txt")) {
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
fileOut.write(buffer, 0, bytesRead);
}
System.out.println("文件接收完成");
} finally {
clientSocket.close();
serverSocket.close();
}
}
}
客户端：
java复制public class FileTransferClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("localhost", 8086);
try (OutputStream out = socket.getOutputStream();
FileInputStream fileIn = new FileInputStream("file_to_send.txt")) {
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = fileIn.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
}
System.out.println("文件发送完成");
} finally {
socket.close();
}
}
}
6.3 使用Java实现简单的聊天室
下面是一个简单的多用户聊天室实现：
服务器端：
java复制public class ChatServer {
private static final List<PrintWriter> clients = new ArrayList<>();
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8087);
System.out.println("聊天室服务器启动，等待连接...");
while (true) {
Socket clientSocket = serverSocket.accept();
System.out.println("新用户加入: " + clientSocket.getInetAddress());
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
clients.add(out);
new Thread(new ClientHandler(clientSocket)).start();
}
}
private static class ClientHandler implements Runnable {
private final Socket clientSocket;
private String clientName;
public ClientHandler(Socket socket) {
this.clientSocket = socket;
}
@Override
public void run() {
try (BufferedReader in = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream()))) {
// 获取客户端名称
clientName = in.readLine();
broadcast(clientName + " 加入了聊天室");
String inputLine;
while ((inputLine = in.readLine()) != null) {
broadcast(clientName + ": " + inputLine);
}
} catch (IOException e) {
System.out.println("客户端异常: " + e.getMessage());
} finally {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
clients.removeIf(writer -> {
try {
if (writer.checkError()) {
return true;
}
return false;
} catch (Exception e) {
return true;
}
});
if (clientName != null) {
broadcast(clientName + " 离开了聊天室");
}
}
}
private void broadcast(String message) {
System.out.println(message);
for (PrintWriter client : clients) {
try {
client.println(message);
} catch (Exception e) {
// 忽略发送失败的客户端
}
}
}
}
}
客户端：
java复制public class ChatClient {
public static void main(String[] args) throws IOException {
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入你的昵称: ");
String name = stdIn.readLine();
Socket socket = new Socket("localhost", 8087);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 发送昵称
out.println(name);
// 启动消息接收线程
new Thread(() -> {
try {
String serverResponse;
while ((serverResponse = in.readLine()) != null) {
System.out.println(serverResponse);
}
} catch (IOException e) {
System.out.println("与服务器的连接已断开");
}
}).start();
// 发送消息
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
}
socket.close();
}
}
7. Java网络编程最佳实践
7.1 安全性考虑
-
使用SSL/TLS加密通信：
java复制// 创建SSL服务器套接字 SSLServerSocketFactory sslServerSocketFactory = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault(); SSLServerSocket sslServerSocket = (SSLServerSocket) sslServerSocketFactory.createServerSocket(8443); // 创建SSL客户端套接字 SSLSocketFactory sslSocketFactory = (SSLSocketFactory) SSLSocketFactory.getDefault(); SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket("localhost", 8443); -
验证主机名：
java复制HttpsURLConnection.setDefaultHostnameVerifier((hostname, session) -> { return hostname.equals("trusted.example.com"); }); -
使用安全的协议版本：
java复制SSLContext sslContext = SSLContext.getInstance("TLSv1.2"); sslContext.init(null, null, null); SSLSocketFactory factory = sslContext.getSocketFactory();
7.2 性能调优
-
调整Socket缓冲区大小：
java复制// 设置发送缓冲区大小为64KB socket.setSendBufferSize(64 * 1024); // 设置接收缓冲区大小为64KB socket.setReceiveBufferSize(64 * 1024); -
重用地址：
java复制serverSocket.setReuseAddress(true); -
设置连接超时和读取超时：
java复制// 连接超时3秒 socket.connect(new InetSocketAddress("example.com", 80), 3000); // 读取超时5秒 socket.setSoTimeout(5000);
7.3 异常处理
网络编程中常见的异常包括：
- IOException：基础IO异常
- SocketTimeoutException：操作超时
- ConnectException：连接被拒绝
- UnknownHostException：主机名无法解析
良好的异常处理实践：
java复制try {
// 网络操作代码
} catch (UnknownHostException e) {
System.err.println("无法解析主机名: " + e.getMessage());
} catch (ConnectException e) {
System.err.println("连接被拒绝，请检查服务器是否运行");
} catch (SocketTimeoutException e) {
System.err.println("操作超时，请检查网络连接");
} catch (IOException e) {
System.err.println("IO异常: " + e.getMessage());
} finally {
// 确保资源被释放
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
// 忽略关闭异常
}
}
}
7.4 使用第三方网络库
对于复杂的网络应用，可以考虑使用成熟的网络库：
- Netty：高性能异步事件驱动网络框架
- OkHttp：HTTP客户端库
- Apache HttpClient：功能丰富的HTTP客户端
- gRPC：基于HTTP/2的RPC框架
例如使用Netty创建简单的HTTP服务器：
java复制public class NettyHttpServer {
public static void main(String[] args) throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) {
ch.pipeline()
.addLast(new HttpServerCodec())
.addLast(new SimpleChannelInboundHandler<HttpObject>() {
@Override
protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) {
if (msg instanceof HttpRequest) {
HttpRequest req = (HttpRequest) msg;
ByteBuf content = Unpooled.copiedBuffer(
"Hello from Netty", CharsetUtil.UTF_8);
FullHttpResponse response = new DefaultFullHttpResponse(
HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);
response.headers().set(HttpHeaderNames.CONTENT_TYPE,
"text/plain");
response.headers().set(HttpHeaderNames.CONTENT_LENGTH,
content.readableBytes());
ctx.writeAndFlush(response);
}
}
});
}
});
ChannelFuture f = b.bind(8088).sync();
System.out.println("Netty HTTP服务器启动，监听端口8088...");
f.channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
}