java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java socket编程

Java socket编程实战教程

作者：杨白开909

Socket是网络通信技术,用于实现设备间数据传输,Java中通过创建、绑定、连接、传输、关闭流程操作,结合心跳与重连机制确保连接可靠性和稳定性,适用于即时通讯、文件传输等场景,本文给大家介绍Java socket编程实战教程,感兴趣的朋友跟随小编一起看看吧

一、什么是socket

Socket（套接字）是计算机网络编程中用于实现不同设备之间通信的一种技术或接口。它提供了一套标准的编程接口，让应用程序能够通过网络发送和接收数据。

简单来说，Socket 就像是两个设备（如计算机、服务器）之间通信的 "端口" 或 "接口"：

一个设备上的应用程序通过 Socket 发送数据
另一个设备上的应用程序通过对应的 Socket 接收数据

Socket 通信通常基于 TCP/IP 协议，主要涉及两个核心概念：

IP 地址：标识网络中的设备
端口号：标识设备上的特定应用程序

在编程中，使用 Socket 通常需要以下步骤：

创建 Socket 对象
绑定到特定的 IP 地址和端口（服务器端）
建立连接（客户端）或监听连接（服务器端）
发送 / 接收数据
关闭连接

Socket 编程是网络编程的基础，无论是网页浏览、即时聊天、文件传输等网络应用，底层都依赖 Socket 来实现数据通信。

例如，当你访问一个网站时，你的浏览器会创建一个 Socket 连接到网站服务器的特定端口（通常是 80 或 443 端口），然后通过这个连接发送请求并接收网页数据。

1、如何实现两个设备上的通信

要实现两个设备间通过 Socket 进行数据传输，通常需要创建一个服务器端和一个客户端程序。以下是基于 Java 的实现示例，展示了基本的 Socket 通信流程：
实现原理
1）、服务器端创建 ServerSocket 并监听指定端口
2）、客户端创建 Socket 并连接到服务器的 IP 和端口

创建连接时的方法：

connect()方法
在 Java 的 Socket 编程中，connect() 是 Socket 类的一个方法，用于客户端主动与服务器建立网络连接。它的核心作用是发起 TCP 连接请求，与服务器的 ServerSocket 建立通信链路。
基本用法
connect() 方法有两种常用重载形式：
// 形式1：指定服务器地址和端口，无超时设置
void connect(SocketAddress endpoint) throws IOException

// 形式2：指定服务器地址、端口和超时时间（毫秒）
void connect(SocketAddress endpoint, int timeout) throws IOException使用示例：

import java.net.Socket;
import java.net.InetSocketAddress;
import java.io.IOException;
public class ConnectExample {
    public static void main(String[] args) {
        String serverIP = "127.0.0.1"; // 服务器IP
        int port = 8888; // 服务器端口
        try (Socket socket = new Socket()) {
            // 创建服务器地址对象
            InetSocketAddress serverAddr = new InetSocketAddress(serverIP, port);
            // 发起连接（设置超时时间为3秒）
            socket.connect(serverAddr, 3000);
            if (socket.isConnected()) {
                System.out.println("连接成功！");
                // 连接成功后可进行数据传输...
            }
        } catch (IOException e) {
            System.out.println("连接失败：" + e.getMessage());
        }
    }
}

内部工作原理
connect() 方法的底层遵循 TCP 协议的 "三次握手" 过程：
客户端向服务器发送 SYN 包（连接请求）
服务器收到后返回 SYN+ACK 包（同意连接）
客户端再发送 ACK 包（确认连接）
三次握手完成后，connect() 方法返回，连接建立
关键特点
阻塞特性：connect() 是阻塞方法，会一直等待直到连接建立或失败
超时设置：带超时参数的重载方法可以避免无限期等待（推荐使用）
异常情况：
服务器未启动 → Connection refused
网络不可达 → No route to host
超时未响应 → Connection timed out
地址 / 端口无效 → IllegalArgumentException
与直接构造 Socket 的区别
除了显式调用 connect()，也可以通过 Socket 构造方法直接建立连接：
// 构造方法直接连接（等价于先new Socket()再调用connect()）
Socket socket = new Socket(serverIP, port);
两种方式的区别：
显式 connect() 更灵活，可先创建 Socket 对象，延迟连接或设置超时
构造方法连接无法单独设置超时（默认超时较长）
connect() 是客户端 Socket 建立连接的核心方法，它是 TCP 通信的起点，只有调用成功后，客户端才能与服务器进行数据传输。

3）、连接建立后，通过输入输出流进行数据传输
4）、通信完成后关闭连接

示例代码：

Client.java (客户端)

import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Client {
    public static void main(String[] args) {
        // 服务器IP地址和端口，实际使用时替换为服务器的真实IP
        String serverAddress = "127.0.0.1"; // 本地测试使用localhost
        int port = 8888;
        try (Socket socket = new Socket(serverAddress, port)) {
            System.out.println("已连接到服务器: " + serverAddress + ":" + port);
            // 使用try-with-resources自动关闭资源
            try (
                // 获取输出流，向服务器发送数据
                PrintWriter out = new PrintWriter(
                    socket.getOutputStream(), true);
                // 获取输入流，读取服务器返回的数据
                BufferedReader in = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()));
                // 从控制台读取用户输入
                Scanner scanner = new Scanner(System.in)
            ) {
                String userInput;
                // 循环读取用户输入并发送给服务器
                do {
                    System.out.print("请输入要发送的消息(输入bye退出): ");
                    userInput = scanner.nextLine();
                    // 发送消息到服务器
                    out.println(userInput);
                    // 读取服务器的响应
                    String response = in.readLine();
                    System.out.println("服务器响应: " + response);
                } while (!"bye".equalsIgnoreCase(userInput));
            }
        } catch (UnknownHostException e) {
            System.out.println("无法识别服务器地址: " + serverAddress);
        } catch (IOException e) {
            System.out.println("与服务器连接失败: " + e.getMessage());
        }
    }
}

Server.java (服务端)

import java.io.*;
import java.net.*;
public class Server {
    public static void main(String[] args) {
        // 定义服务器端口
        int port = 8888;
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("服务器启动，监听端口: " + port);
            // 等待客户端连接
            while (true) {
                // 阻塞等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("客户端已连接: " + clientSocket.getInetAddress());
                // 使用try-with-resources自动关闭资源
                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("收到客户端消息: " + inputLine);
                        // 向客户端发送响应
                        out.println("服务器已收到: " + inputLine);
                        // 如果客户端发送"bye"，则关闭连接
                        if ("bye".equalsIgnoreCase(inputLine)) {
                            break;
                        }
                    }
                } catch (IOException e) {
                    System.out.println("与客户端通信时发生错误: " + e.getMessage());
                } finally {
                    try {
                        clientSocket.close();
                        System.out.println("客户端连接已关闭");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            System.out.println("服务器启动失败: " + e.getMessage());
        }
    }
}

运行说明
首先编译并运行 Server 类，服务器将启动并监听 8888 端口
然后编译并运行 Client 类，客户端将连接到服务器
在客户端控制台输入消息，这些消息将发送到服务器
服务器收到消息后会返回响应
输入 "bye" 可以关闭连接
跨设备通信注意事项
确保两个设备在同一网络中，或能通过互联网相互访问
客户端需要使用服务器的实际 IP 地址（不能用 127.0.0.1）
检查防火墙设置，确保通信端口（示例中为 8888）未被阻塞
实际应用中通常需要处理多客户端连接，可使用多线程实现这种基于 TCP 的 Socket 通信是可靠的，适用于需要保证数据完整性的场景，如文件传输、即时通讯等。

2、连接状态管理（心跳 + 重连）的必要性

在网络通信中，心跳（Heartbeat） 是一种用于检测连接是否仍然有效的机制，而心跳包（Heartbeat Packet） 则是实现这种机制所发送的特殊数据包。

核心作用

当两个设备（如客户端和服务器）通过网络建立连接后，可能会出现以下情况：

心跳机制通过定期发送小数据包来解决这些问题，确保双方知道连接的实时状态：

心跳包的特点

  1. 数据量小：通常是固定格式的空包或简单指令（如 "ping"），不占用太多网络资源
  2. 周期性发送：按固定时间间隔发送（如每 30 秒、1 分钟）
  3. 双向或单向：
    • 单向：客户端定期向服务器发送心跳包
    • 双向：双方互相发送，确保双向可达性

实现示例（Java Socket）

以下是一个简单的心跳包实现逻辑：

1. 客户端发送心跳包
// 客户端心跳线程
class HeartbeatSender implements Runnable {
    private Socket socket;
    private boolean running = true;
    public HeartbeatSender(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try (OutputStream out = socket.getOutputStream()) {
            while (running) {
                // 发送心跳包（简单的字符串或空包）
                out.write("HEARTBEAT".getBytes());
                out.flush();
                System.out.println("发送心跳包");
                // 间隔30秒发送一次
                Thread.sleep(30000);
            }
        } catch (Exception e) {
            System.out.println("心跳发送失败，连接可能已断开");
            // 触发重连逻辑
        }
    }
    public void stop() {
        running = false;
    }
}
2. 服务器接收心跳包并检测超时
// 服务器心跳检测线程
class HeartbeatChecker implements Runnable {
    private Socket socket;
    private boolean running = true;
    private long lastHeartbeatTime;
    private static final long TIMEOUT = 60000; // 超时时间60秒
    public HeartbeatChecker(Socket socket) {
        this.socket = socket;
        this.lastHeartbeatTime = System.currentTimeMillis();
    }
    @Override
    public void run() {
        try (InputStream in = socket.getInputStream()) {
            byte[] buffer = new byte[1024];
            while (running) {
                // 检查是否超时
                if (System.currentTimeMillis() - lastHeartbeatTime > TIMEOUT) {
                    System.out.println("心跳超时，关闭连接");
                    socket.close();
                    running = false;
                    break;
                }
                // 读取数据（包括心跳包）
                if (in.available() > 0) {
                    int len = in.read(buffer);
                    String data = new String(buffer, 0, len);
                    if ("HEARTBEAT".equals(data)) {
                        // 收到心跳包，更新时间
                        lastHeartbeatTime = System.currentTimeMillis();
                        System.out.println("收到心跳包");
                    }
                }
                // 短暂休眠，减少CPU占用
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            System.out.println("连接已断开");
        }
    }
}

应用场景

心跳机制广泛用于需要长期保持连接的场景：

简单说，心跳包就像通信双方定期互问 "你还在吗"，是保证网络连接可靠性的重要机制。

在网络通信中，重连（Reconnection） 是指当客户端与服务器的连接意外中断后，自动或手动尝试重新建立连接的机制。它是保证网络通信可靠性的重要手段，尤其适用于需要长期保持连接的场景（如即时通讯、物联网设备、游戏客户端等）。

重连的核心逻辑

重连机制通常包含以下关键步骤：

  1. 检测连接断开：通过心跳超时、IO 异常、连接状态标记等方式发现连接已中断
  2. 尝试重新连接：按照一定策略（如固定间隔、指数退避）重复调用 connect() 方法
  3. 恢复通信状态：连接重建后，恢复之前的会话状态（如重新登录、同步数据）
  4. 限制重连次数：避免无限次重连导致资源浪费或服务器压力

Java Socket 重连实现示例

以下是一个客户端自动重连的实现代码，包含了完整的检测和重连逻辑：

import java.net.Socket;
import java.net.InetSocketAddress;
import java.io.IOException;
public class ReconnectClient {
    private static final String SERVER_IP = "127.0.0.1";
    private static final int SERVER_PORT = 8888;
    private static final int MAX_RECONNECT_ATTEMPTS = 10; // 最大重连次数
    private static final int BASE_DELAY = 1000; // 基础重连延迟（毫秒）
    private Socket socket;
    private boolean isRunning = true;
    public static void main(String[] args) {
        ReconnectClient client = new ReconnectClient();
        client.start();
    }
    public void start() {
        // 初始连接
        if (connect()) {
            // 连接成功后启动通信线程
            startCommunication();
        } else {
            // 初始连接失败，进入重连流程
            startReconnectLoop();
        }
    }
    // 建立连接
    private boolean connect() {
        try {
            socket = new Socket();
            socket.connect(new InetSocketAddress(SERVER_IP, SERVER_PORT), 3000); // 3秒超时
            System.out.println("成功连接到服务器：" + SERVER_IP + ":" + SERVER_PORT);
            return true;
        } catch (IOException e) {
            System.out.println("连接失败：" + e.getMessage());
            closeSocket();
            return false;
        }
    }
    // 启动通信线程（实际业务逻辑）
    private void startCommunication() {
        new Thread(() -> {
            try {
                // 这里是正常通信逻辑（读取/发送数据）
                // ...
                // 模拟通信过程中可能发生的异常断开
                // Thread.sleep(5000);
                // throw new IOException("模拟连接中断");
            } catch (Exception e) {
                System.out.println("通信异常，连接断开：" + e.getMessage());
                closeSocket();
                // 启动重连
                startReconnectLoop();
            }
        }).start();
    }
    // 重连循环
    private void startReconnectLoop() {
        new Thread(() -> {
            int attempt = 0;
            while (isRunning && attempt < MAX_RECONNECT_ATTEMPTS) {
                attempt++;
                // 指数退避策略：重连间隔逐渐增加（1s, 2s, 4s...）
                long delay = (long) (BASE_DELAY * Math.pow(2, Math.min(attempt, 10)));
                System.out.println("第" + attempt + "次重连尝试，延迟" + delay + "ms...");
                try {
                    Thread.sleep(delay);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
                // 尝试重连
                if (connect()) {
                    // 重连成功，恢复通信
                    startCommunication();
                    break;
                }
            }
            if (attempt >= MAX_RECONNECT_ATTEMPTS) {
                System.out.println("达到最大重连次数，停止尝试");
                // 可以通知用户或触发其他处理
            }
        }).start();
    }
    // 关闭Socket
    private void closeSocket() {
        try {
            if (socket != null && !socket.isClosed()) {
                socket.close();
            }
        } catch (IOException e) {
            System.out.println("关闭Socket失败：" + e.getMessage());
        }
        socket = null;
    }
    // 停止客户端
    public void stop() {
        isRunning = false;
        closeSocket();
    }
}

重连策略详解

注意事项

重连机制是构建健壮网络应用的关键组件，合理的重连策略能显著提升用户体验和系统稳定性。

到此这篇关于Java socket编程的文章就介绍到这了,更多相关Java socket编程内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文