当前位置：首页 > 文章列表 > 文章 > java教程 > JavaSocket通信教程及代码示例

JavaSocket通信教程及代码示例

2025-07-19 13:45:18 0浏览收藏

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《Java Socket通信实现教程及示例代码》，聊聊，我们一起来看看吧！

如何在Java中实现Socket通信？1. 服务器端使用ServerSocket监听端口并等待客户端连接；2. 客户端使用Socket连接服务器的IP和端口；3. 连接建立后，通过Socket的输入/输出流进行数据交换。如何处理多个客户端连接？1. 使用多线程，在accept()获取新连接后，为每个客户端创建独立线程处理通信；2. 可进一步使用线程池（ExecutorService）提升资源利用率。常用数据传输方式有哪些？1. 文本流：使用InputStreamReader/OutputStreamWriter结合BufferedReader/PrintWriter，适合传输文本数据；2. 字节流：直接操作InputStream和OutputStream，适合传输任意二进制数据；3. 对象流：使用ObjectInputStream/ObjectOutputStream传输Java对象，要求类实现Serializable接口。Socket通信与HTTP、RMI有何不同？1. Socket是最底层的TCP/IP通信，需自定义协议，灵活性高但复杂；2. HTTP是基于请求-响应的高层协议，广泛用于Web服务，底层仍使用Socket；3. RMI是Java特有的远程方法调用机制，封装了Socket通信，适合纯Java环境的分布式系统。

如何在Java中实现Socket通信 Java网络编程基础示例

在Java中实现Socket通信，核心在于使用java.net.Socket和java.net.ServerSocket这两个类。简单来说，服务器端会创建一个ServerSocket来监听特定端口，等待客户端连接；客户端则通过Socket连接到服务器的IP地址和端口。一旦连接建立，双方就可以通过各自Socket对象提供的输入/输出流进行数据交换了。这就像是两部电话，服务器是总机，客户端是分机，一旦接通，就能开始对话。

解决方案

要在Java中实现基本的Socket通信，通常涉及一个服务器程序和一个客户端程序。我们以一个简单的“回声”服务为例，客户端发送一条消息，服务器接收后原样返回。

服务器端代码示例：

import java.io.*;
import java.net.*;

public class EchoServer {
    public static void main(String[] args) {
        int port = 12345; // 选择一个未被占用的端口
        System.out.println("Echo服务器正在启动，监听端口: " + port + "...");

        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("服务器已启动，等待客户端连接...");
            // serverSocket.accept()会阻塞，直到有客户端连接
            Socket clientSocket = serverSocket.accept();
            System.out.println("客户端已连接: " + clientSocket.getInetAddress().getHostAddress());

            // 获取客户端的输入流和输出流
            try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                 PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) { // true表示自动刷新

                String clientMessage;
                // 从客户端读取一行，如果读取到null，表示客户端已关闭连接
                while ((clientMessage = in.readLine()) != null) {
                    System.out.println("收到客户端消息: " + clientMessage);
                    out.println("服务器回声: " + clientMessage); // 将消息回传给客户端
                    if ("bye".equalsIgnoreCase(clientMessage.trim())) {
                        System.out.println("客户端发送'bye'，关闭连接。");
                        break;
                    }
                }
            }
            clientSocket.close(); // 关闭客户端Socket
            System.out.println("客户端连接已关闭。");

        } catch (IOException e) {
            System.err.println("服务器异常: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

客户端代码示例：

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class EchoClient {
    public static void main(String[] args) {
        String serverAddress = "127.0.0.1"; // 服务器IP地址，这里是本机
        int port = 12345; // 服务器监听的端口

        System.out.println("Echo客户端尝试连接服务器: " + serverAddress + ":" + port);

        try (Socket socket = new Socket(serverAddress, port); // 尝试连接服务器
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // 自动刷新
             Scanner scanner = new Scanner(System.in)) {

            System.out.println("成功连接到服务器。输入消息，输入'bye'退出。");

            String userInput;
            while (true) {
                System.out.print("你: ");
                userInput = scanner.nextLine();
                out.println(userInput); // 发送消息给服务器

                if ("bye".equalsIgnoreCase(userInput.trim())) {
                    System.out.println("发送'bye'，准备退出。");
                    break;
                }

                String serverResponse = in.readLine(); // 读取服务器响应
                if (serverResponse == null) {
                    System.out.println("服务器已关闭连接。");
                    break;
                }
                System.out.println("服务器: " + serverResponse);
            }

        } catch (UnknownHostException e) {
            System.err.println("无法找到服务器: " + serverAddress);
        } catch (IOException e) {
            System.err.println("客户端连接或通信异常: " + e.getMessage());
            e.printStackTrace();
        } finally {
            System.out.println("客户端已退出。");
        }
    }
}

运行步骤：

先运行EchoServer的main方法。
再运行EchoClient的main方法。你会在客户端控制台输入消息，服务器控制台显示收到消息并回传，客户端再显示服务器的回声。

如何在Java Socket通信中处理多个客户端连接？

刚才的示例服务器只能处理一个客户端连接，因为serverSocket.accept()返回一个Socket后，服务器就直接开始和这个客户端通信了，并不会再去监听新的连接。一旦这个客户端断开，服务器就退出了。在实际应用中，服务器往往需要同时服务多个客户端。这自然而然地引出了多线程的概念。

当ServerSocket接受到一个新的客户端连接（即accept()方法返回一个新的Socket对象）时，我们不应该让主线程直接处理这个连接的输入输出，而是应该把这个新建立的Socket对象“扔给”一个新的线程去处理。这样，主线程就可以立即回到accept()方法那里，继续等待下一个客户端的连接了。

一个简单的多线程服务器结构可能是这样的：

// EchoServer的main方法修改版，支持多客户端
public class MultiThreadedEchoServer {
    public static void main(String[] args) {
        int port = 12345;
        System.out.println("多线程Echo服务器正在启动，监听端口: " + port + "...");

        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("服务器已启动，等待客户端连接...");
            while (true) { // 服务器会一直运行，等待并处理新连接
                Socket clientSocket = serverSocket.accept(); // 阻塞，直到有新客户端连接
                System.out.println("新客户端已连接: " + clientSocket.getInetAddress().getHostAddress());
                // 为每个新连接创建一个新的线程来处理
                new Thread(new ClientHandler(clientSocket)).start();
            }
        } catch (IOException e) {
            System.err.println("服务器异常: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

// 独立的客户端处理类
class ClientHandler implements Runnable {
    private 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 clientMessage;
            while ((clientMessage = in.readLine()) != null) {
                System.out.println("从 " + clientSocket.getInetAddress().getHostAddress() + " 收到: " + clientMessage);
                out.println("服务器回声: " + clientMessage);
                if ("bye".equalsIgnoreCase(clientMessage.trim())) {
                    System.out.println(clientSocket.getInetAddress().getHostAddress() + " 发送'bye'，关闭连接。");
                    break;
                }
            }
        } catch (IOException e) {
            System.err.println("客户端 " + clientSocket.getInetAddress().getHostAddress() + " 异常: " + e.getMessage());
        } finally {
            try {
                clientSocket.close();
                System.out.println("客户端 " + clientSocket.getInetAddress().getHostAddress() + " 连接已关闭。");
            } catch (IOException e) {
                System.err.println("关闭Socket时发生错误: " + e.getMessage());
            }
        }
    }
}

这种模式下，每个客户端连接都有自己独立的线程来处理输入输出，彼此之间互不影响。当然，如果客户端数量非常庞大，为每个连接都创建一个新线程可能会消耗大量系统资源。这时候，可以考虑使用线程池（ExecutorService）来管理和复用线程，而不是每次都new Thread()。这能更有效地利用资源，避免频繁创建和销毁线程的开销。

Java Socket通信中常用的数据传输方式和格式

Socket通信本质上是在两个端点之间传输字节流。但是，直接操作字节流通常不够方便，我们需要一些更高层次的抽象来处理不同类型的数据。

文本流 (Text Streams):
- 方式: 使用InputStreamReader/OutputStreamWriter来桥接字节流和字符流，再结合BufferedReader/PrintWriter进行行读取和行写入。
- 示例: 上面回声服务器的例子就是典型的文本流通信。in.readLine()读取一行文本，out.println()写入一行文本。
- 优点: 简单易用，人类可读，适合传输结构化或非结构化的文本数据。
- 缺点: 只能传输文本，对于二进制数据（如图片、文件）不适用。编码问题（UTF-8, GBK等）需要注意。
字节流 (Byte Streams):
- 方式: 直接使用InputStream和OutputStream的read()和write()方法。
- 示例:
```
// 读取一个字节
int byteData = in.read();
// 写入一个字节
out.write(byteData);
// 读取到字节数组
byte[] buffer = new byte[1024];
int bytesRead = in.read(buffer);
// 写入字节数组
out.write(buffer, 0, bytesRead);
```
- 优点: 最底层，可以传输任何类型的二进制数据，效率高。
- 缺点: 需要手动处理数据的边界和长度，实现自定义协议来解析数据。比如，发送一个文件，你需要先发送文件大小，然后才是文件内容。
对象流 (Object Streams):
- 方式: 使用ObjectInputStream和ObjectOutputStream。它们允许你直接在网络上传输Java对象。
- 示例:
```
// 服务器端发送一个对象
// out = new ObjectOutputStream(clientSocket.getOutputStream());
// out.writeObject(new MyCustomObject("Hello", 123));

// 客户端接收一个对象
// in = new ObjectInputStream(socket.getInputStream());
// MyCustomObject receivedObject = (MyCustomObject) in.readObject();
```
- 要求: 传输的对象必须实现java.io.Serializable接口。
- 优点: 极其方便，可以直接发送和接收复杂的Java对象图，省去了序列化/反序列化的繁琐工作。
- 缺点: 只能在Java应用程序之间使用（因为它是Java特有的序列化机制）。对象的版本兼容性可能成为问题，如果发送方和接收方的类定义不完全一致，可能会出现InvalidClassException。

除了这些Java内置的流，实际项目中还经常会看到基于文本的JSON或XML格式，或者更紧凑的Protocol Buffers、Thrift等二进制序列化协议。这些通常需要引入第三方库，但它们提供了跨语言的兼容性，让不同编程语言写的客户端和服务器也能互相通信。选择哪种方式，很大程度上取决于你的应用场景：是Java-to-Java通信，还是需要跨语言互操作；是传输简单文本，还是复杂数据结构；对性能和可读性有什么要求。

Java Socket通信与HTTP、RMI等高级网络通信方式有何不同？

理解Socket通信，就像理解了汽车的发动机和变速箱，而HTTP、RMI这些，更像是不同品牌的汽车。它们都是基于Socket构建的，但提供了不同层次的抽象和功能。

原始Socket通信 (TCP/IP Sockets):
- 本质: 它是最底层的应用层协议，直接在TCP/IP协议之上进行字节流传输。你几乎拥有对网络连接的完全控制权。
- 特点:
  - 低层次: 你需要自己定义应用层协议，比如消息的格式、长度、如何解析等。
  - 灵活性高: 可以实现任何你想要的通信模式，无论是长连接、短连接、双向通信等。
  - 性能潜力大: 因为没有额外的协议开销，理论上可以达到最高性能，但需要你手动处理所有细节。
  - 复杂性高: 错误处理、数据包完整性、连接管理、多客户端并发等都需要自己编写代码。
- 适用场景: 对性能要求极高、需要自定义协议（如游戏服务器、实时数据推送）、嵌入式系统通信等。
HTTP (Hypertext Transfer Protocol):
- 本质: 这是一个基于请求-响应模式的应用层协议，通常运行在TCP/IP之上（默认端口80/443）。它最初是为了传输超文本而设计，现在广泛用于Web服务和RESTful API。
- 特点:
  - 高层次: HTTP协议定义了请求方法（GET, POST等）、状态码（200 OK, 404 Not Found等）、头部信息等，大大简化了Web通信。
  - 无状态: 每个请求都是独立的，服务器不会保留客户端的上下文信息（除非通过Cookie、Session等机制模拟）。
  - 短连接为主: 传统HTTP每次请求后连接就会关闭，但HTTP/1.1引入了Keep-Alive，HTTP/2和HTTP/3则支持多路复用，提升了效率。
  - 广泛性: 几乎所有编程语言和平台都支持HTTP客户端和服务器。
- 与Socket关系: HTTP客户端和服务器在底层依然使用Socket建立连接并传输数据，但HTTP协议规范了这些数据的格式和交互流程。你不需要关心如何将请求头和请求体打包成字节流，HTTP库会帮你完成。
- 适用场景: 网页浏览、RESTful API、微服务间通信、文件下载等。
RMI (Remote Method Invocation):
- 本质: RMI是Java特有的远程方法调用机制，它允许一个Java虚拟机（JVM）中的对象调用另一个JVM中对象的方法。它也是基于Socket通信的。
- 特点:
  - 面向对象: 你可以直接像调用本地方法一样调用远程对象的方法，网络通信细节被完全封装。
  - Java特定: 只能在Java应用程序之间使用。
  - 代理模式: RMI使用代理（Stub和Skeleton）来处理远程方法调用、参数序列化和结果反序列化。
  - 透明性高: 开发者不需要关心底层Socket连接和数据传输。
- 与Socket关系: RMI在底层使用Socket进行通信，但它在Socket之上构建了一个完整的远程对象调用框架，包括参数和返回值的序列化、远程对象查找等。
- 适用场景: 纯Java分布式系统，需要进行对象级交互的场景。

总结来说：

Socket通信是基石，给你最大的控制权，但需要你处理所有底层细节。
HTTP是基于Socket构建的，提供了一种标准化的请求-响应通信模式，简化了Web应用开发，是无状态的。
RMI也是基于Socket构建的，提供了一种Java特有的、面向对象的远程方法调用机制，极大地简化了Java分布式应用的开发，但仅限于Java环境。

选择哪种方式，取决于你的具体需求：是需要底层控制和极致性能，还是需要标准化的Web服务，抑或是纯Java环境下的远程对象调用。大多数时候，我们更倾向于使用HTTP或RMI这类高级协议，因为它们大大降低了开发复杂性。只有在特定场景下，比如需要实现自定义协议或者对性能有极致要求时，才会直接使用原始Socket。

以上就是《JavaSocket通信教程及代码示例》的详细内容，更多关于的资料请关注golang学习网公众号！