java使用教程怎样实现基于TCP的网络通信 java使用教程的TCP编程入门技巧​

java中实现tcp通信需编写服务器端和客户端代码，服务器使用serversocket监听端口并接受连接，客户端通过socket连接服务器，双方通过输入输出流交换数据，tcp确保可靠、有序传输。1. 服务器端创建serversocket绑定端口，调用accept()阻塞等待客户端连接，每接受一个连接便启动新线程处理，避免阻塞主线程；2. 客户端创建socket指定服务器ip和端口发起连接，成功后通过输入输出流与服务器通信；3. 使用try-with-resources语法自动关闭socket和流，防止资源泄露；4. 处理连接断开时需检测read()返回-1或捕获ioexception，及时释放资源；5. 数据传输中若需发送对象，可选择java序列化（仅限java间通信）、json/xml（跨语言、可读性强）或protocol buffers（高性能、小体积、跨语言）。选择tcp而非udp因其提供可靠、有序、连接性的数据传输，适用于文件传输、聊天等对数据完整性要求高的场景，而udp适用于实时性高、可容忍丢包的场景如音视频直播。

Java中实现基于TCP的网络通信，说白了，就是服务器和客户端通过建立连接，然后像打电话一样，你一句我一句地交换数据。核心在于服务器端的

ServerSocket

Socket

Socket

解决方案

要实现TCP通信，我们通常需要编写两部分代码：服务器端和客户端。

服务器端（Server）

立即学习“Java免费学习笔记（深入）”；

服务器的主要任务是监听一个特定的端口，等待客户端的连接请求。一旦有客户端连接上来，它就接受这个连接，然后与客户端进行数据交换。

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

public class SimpleTcpServer {
    public static void main(String[] args) {
        int port = 8080; // 监听的端口
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);
            System.out.println("服务器已启动，正在监听端口 " + port + "...");

            while (true) { // 持续监听新的连接
                Socket clientSocket = serverSocket.accept(); // 阻塞，直到有客户端连接
                System.out.println("客户端 " + clientSocket.getInetAddress().getHostAddress() + " 已连接。");

                // 为每个客户端连接创建一个新的线程来处理，避免阻塞主线程
                new Thread(() -> {
                    try (
                        // 使用try-with-resources确保流自动关闭
                        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true) // true表示自动刷新
                    ) {
                        String clientMessage;
                        while ((clientMessage = in.readLine()) != null) {
                            System.out.println("收到客户端消息: " + clientMessage);
                            out.println("服务器已收到: " + clientMessage); // 回复客户端
                            if ("bye".equalsIgnoreCase(clientMessage.trim())) {
                                break; // 客户端发送"bye"则结束通信
                            }
                        }
                    } catch (IOException e) {
                        System.err.println("处理客户端连接时发生错误: " + e.getMessage());
                    } finally {
                        try {
                            clientSocket.close(); // 关闭客户端socket
                            System.out.println("客户端连接已关闭: " + clientSocket.getInetAddress().getHostAddress());
                        } catch (IOException e) {
                            System.err.println("关闭客户端socket时发生错误: " + e.getMessage());
                        }
                    }
                }).start();
            }

        } catch (IOException e) {
            System.err.println("服务器启动或运行异常: " + e.getMessage());
        } finally {
            if (serverSocket != null && !serverSocket.isClosed()) {
                try {
                    serverSocket.close();
                    System.out.println("服务器已关闭。");
                } catch (IOException e) {
                    System.err.println("关闭服务器socket时发生错误: " + e.getMessage());
                }
            }
        }
    }
}

客户端（Client）

客户端相对简单，它需要知道服务器的IP地址和端口号，然后尝试连接。连接成功后，就可以向服务器发送数据，并接收服务器的回复。

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

public class SimpleTcpClient {
    public static void main(String[] args) {
        String serverIp = "127.0.0.1"; // 服务器IP地址，这里用本机
        int port = 8080; // 服务器端口

        try (
            Socket socket = new Socket(serverIp, port); // 尝试连接服务器
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // true表示自动刷新
            Scanner scanner = new Scanner(System.in) // 用于从控制台读取用户输入
        ) {
            System.out.println("已连接到服务器 " + serverIp + ":" + port);
            String userInput;
            String serverResponse;

            while (true) {
                System.out.print("请输入消息 (输入 'bye' 退出): ");
                userInput = scanner.nextLine();
                out.println(userInput); // 发送消息给服务器

                if ("bye".equalsIgnoreCase(userInput.trim())) {
                    break; // 如果输入"bye"，则退出循环
                }

                // 尝试读取服务器的回复，这里需要注意服务器端是否会立即回复
                // 如果服务器是异步处理，或者回复有延迟，这里可能会阻塞
                // 对于简单的请求-回复模式，readLine通常是可行的
                if ((serverResponse = in.readLine()) != null) {
                    System.out.println("收到服务器回复: " + serverResponse);
                }
            }

        } catch (UnknownHostException e) {
            System.err.println("未知主机: " + serverIp);
        } catch (IOException e) {
            System.err.println("无法连接到服务器或I/O错误: " + e.getMessage());
        } finally {
            System.out.println("客户端已断开连接。");
        }
    }
}

为什么选择TCP而不是UDP进行网络通信？

在我刚接触网络编程的时候，也曾纠结过TCP和UDP这两种协议的选择。简单来说，TCP（传输控制协议）就像你寄送一份非常重要的快递，需要签名、需要确认收货，确保货物完整无损、顺序不乱地送到。它提供的是可靠的、面向连接的、基于字节流的服务。这意味着：

• 可靠性： TCP会确保数据到达目的地，如果数据丢失，它会自动重传。你不需要操心数据包是不是丢了，是不是乱序了。
• 有序性： 数据包会按照发送的顺序到达接收方，即使在网络中它们走的路线不同。
• 连接性： 在数据传输之前，客户端和服务器之间会先建立一个“握手”过程，形成一个逻辑连接。数据传输完毕后，也会有一个“挥手”过程来断开连接。
• 流量控制和拥塞控制： TCP会根据网络状况调整发送速率，避免发送方把接收方或网络淹没。

而UDP（用户数据报协议）则更像你往一个方向扔纸飞机，你只管扔出去，至于它能不能飞到、飞到谁那里、什么时候飞到，你一概不管。它是不可靠的、无连接的、基于数据报的服务。UDP的优点在于它的速度快、开销小，因为它省去了建立连接、重传、排序等复杂机制。

所以，选择哪一个，完全取决于你的应用场景。如果你的应用对数据完整性和顺序有严格要求，比如文件传输、网页浏览（HTTP底层就是TCP）、邮件发送、在线聊天等，那么TCP是你的不二之选。如果你的应用对实时性要求极高，可以容忍少量数据丢失，比如在线音视频直播、网络游戏（部分数据）、DNS查询等，那么UDP可能会是更好的选择，因为它能提供更低的延迟。在我看来，对于大多数需要确保数据正确送达的应用，TCP无疑是更稳妥、更省心的方案。

Java TCP编程中常见的陷阱与应对策略

说实话，刚开始写Java TCP代码，特别是涉及到多线程和资源管理时，确实踩过不少坑。这里总结几个常见的“陷阱”以及我的应对方法：

1. 阻塞I/O的“死锁”与性能问题：

   • 陷阱： 默认情况下，

     socket.getInputStream().read()

     登录后复制
     和

     socket.getOutputStream().write()

     登录后复制
     都是阻塞的。这意味着如果一方没有数据可读或可写，对应的线程就会一直等待。在服务器端，如果不对每个客户端连接使用单独的线程处理，一个客户端的阻塞操作就会导致整个服务器无法响应其他客户端。
   • 应对策略：
     • 多线程处理客户端： 最常见的做法是，每当

       ServerSocket.accept()

       登录后复制
       接受到一个新的客户端连接时，就为这个

       Socket

       登录后复制
       创建一个新的线程来处理其输入输出。这样，一个客户端的阻塞不会影响其他客户端。我在上面的服务器代码中就是这么做的。
     • 非阻塞I/O（NIO）： 对于需要处理大量并发连接，且每个连接数据量不大但交互频繁的场景，传统的多线程模型可能会因为线程上下文切换开销过大而性能下降。这时，Java NIO（New I/O）就是更好的选择。NIO引入了

       Selector

       登录后复制
       （选择器），一个线程可以同时监听多个

       Channel

       登录后复制
       （通道）上的事件（如连接就绪、读就绪、写就绪），从而实现高并发。不过，NIO的学习曲线相对陡峭，对于入门来说，多线程模型已经足够了。

2. 资源未正确关闭导致的泄露：

   • 陷阱：

     Socket

     登录后复制
     、

     ServerSocket

     登录后复制
     、

     InputStream

     登录后复制
     、

     OutputStream

     登录后复制
     等都是系统资源，如果不及时关闭，可能会导致文件句柄泄露、端口占用等问题，最终影响系统稳定性和性能。特别是在发生异常时，资源很容易被遗忘。
   • 应对策略：

     • try-with-resources

       登录后复制
       ： 这是Java 7及更高版本提供的语法糖，对于实现了

       AutoCloseable

       登录后复制
       接口的资源（大部分I/O流和Socket都实现了），可以在

       try

       登录后复制
       语句中声明并初始化它们，JVM会在

       try

       登录后复制
       块结束时（无论正常结束还是异常结束）自动调用它们的

       close()

       登录后复制
       方法。这是我强烈推荐的写法，它让代码更简洁，也更健壮。

     • finally

       登录后复制
       块： 如果你使用的是旧版Java或者资源没有实现

       AutoCloseable

       登录后复制
       ，那么在

       finally

       登录后复制
       块中显式关闭资源是必须的。但要注意，在

       finally

       登录后复制
       块中关闭资源时，也要捕获可能发生的

       IOException

       登录后复制
       。

3. 连接断开的判断与处理：

   

   豆包AI编程

   豆包推出的AI编程助手

   483

   查看详情
   • 陷阱： 客户端或服务器可能会突然断开连接（例如，程序崩溃、网络中断）。如果代码没有正确处理这种情况，可能会导致

     read()

     登录后复制
     方法一直返回-1（表示流结束），或者抛出

     SocketException

     登录后复制
     。
   • 应对策略：

     • read()

       登录后复制
       返回-1： 当

       InputStream.read()

       登录后复制
       方法返回-1时，表示流已经到达末尾，对方已经关闭了连接。这是正常断开的一种信号，你应该相应地关闭自己的

       Socket

       登录后复制
       和流。
     • 捕获

       IOException

       登录后复制
       ： 网络传输过程中，各种I/O异常（如

       SocketException

       登录后复制
       、

       Connection Reset by Peer

       登录后复制
       ）是常态。你的代码应该有健壮的异常处理机制，捕获这些异常，并进行相应的清理和日志记录。例如，在服务器端，当处理某个客户端时捕获到异常，通常意味着这个客户端的连接出了问题，应该关闭这个连接。
     • 心跳机制： 对于长时间保持的连接，如果双方长时间没有数据交换，有时很难判断连接是否仍然存活。可以实现一个简单的“心跳”机制，定期发送小数据包来探测对方是否在线。

如何处理TCP通信中的数据序列化与反序列化？

在TCP通信中，数据总是以字节流的形式传输的。这意味着如果你想发送一个Java对象，或者更复杂的数据结构，你需要把它们转换成字节序列，然后在接收端再把字节序列还原成原来的数据。这个过程就是序列化（Serialization）和反序列化（Deserialization）。

1. Java内置的对象序列化（

   ObjectOutputStream

   登录后复制
   /

   ObjectInputStream

   登录后复制
   ）：

   • 原理： Java提供了一套非常方便的机制来序列化Java对象。只要你的类实现了

     java.io.Serializable

     登录后复制
     接口，你就可以使用

     ObjectOutputStream

     登录后复制
     将对象写入到输出流，使用

     ObjectInputStream

     登录后复制
     从输入流中读取对象。

   • 示例（片段）：

     // 发送端
     // out是Socket的OutputStream
     ObjectOutputStream oos = new ObjectOutputStream(out);
     MyCustomObject objToSend = new MyCustomObject("Hello", 123);
     oos.writeObject(objToSend);
     oos.flush();
     
     // 接收端
     // in是Socket的InputStream
     ObjectInputStream ois = new ObjectInputStream(in);
     MyCustomObject receivedObj = (MyCustomObject) ois.readObject();
     System.out.println("收到对象: " + receivedObj.getName() + ", " + receivedObj.getValue());
     
     // MyCustomObject类需要实现Serializable接口
     class MyCustomObject implements Serializable {
         private static final long serialVersionUID = 1L; // 推荐定义
         private String name;
         private int value;
         // 构造函数，getter/setter等
         public MyCustomObject(String name, int value) {
             this.name = name;
             this.value = value;
         }
         public String getName() { return name; }
         public int getValue() { return value; }
     }

     登录后复制

   • 优点： 使用简单，对Java对象原生支持。

   • 缺点： 它是Java特有的，如果你需要与其他语言编写的客户端或服务器进行通信，这种方式就行不通了。此外，它对对象结构的修改比较敏感，序列化后的数据通常比较大，且存在一定的安全风险（反序列化攻击）。所以，对于跨平台或对性能、安全性要求高的场景，我通常不会首选它。

2. 基于文本的序列化（JSON / XML）：

   • 原理： 将对象转换成JSON字符串或XML字符串进行传输。这些格式都是人类可读的，并且有大量的库支持，方便跨语言使用。

   • 常用库：

     • JSON： Jackson、Gson（Google）、Fastjson（阿里巴巴）等。
     • XML： JAXB、Dom4j、SAX等。

   • 示例（JSON with Gson）：

     import com.google.gson.Gson; // 假设你已经引入了Gson库
     
     // 发送端
     // out是Socket的OutputStream
     PrintWriter outText = new PrintWriter(out, true);
     MyCustomObject objToSend = new MyCustomObject("Hello", 123);
     String jsonString = new Gson().toJson(objToSend);
     outText.println(jsonString); // 发送JSON字符串
     
     // 接收端
     // in是Socket的InputStream
     BufferedReader inText = new BufferedReader(new InputStreamReader(in));
     String receivedJson = inText.readLine(); // 读取JSON字符串
     MyCustomObject receivedObj = new Gson().fromJson(receivedJson, MyCustomObject.class);
     System.out.println("收到对象: " + receivedObj.getName() + ", " + receivedObj.getValue());

     登录后复制

   • 优点： 跨语言兼容性好，数据可读性强，生态系统成熟。

   • 缺点： 相比二进制协议，通常数据量会稍大，解析也需要额外开销。

3. 基于二进制的序列化（Protocol Buffers / Apache Avro / Thrift）：

   • 原理： 这些是更高级的序列化框架，它们通常需要你定义一个Schema（数据结构），然后根据Schema生成对应语言的代码，进行高效的二进制序列化和反序列化。
   • 优点： 性能极高，序列化后的数据量小，跨语言支持良好，并且有严格的版本控制和向后兼容性。
   • 缺点： 学习成本和使用复杂性相对较高，需要额外定义Schema文件。

在我自己的项目里，如果只是简单的Java应用内部通信，或者原型阶段，Java自带的序列化有时也用。但如果涉及到服务间通信、微服务架构，或者需要与非Java客户端交互，我几乎总是倾向于使用JSON或Protocol Buffers。JSON简单直观，适合快速开发；Protocol Buffers则在性能和数据大小上有显著优势，适合对这些方面有更高要求的场景。选择哪种方式，最终还是看项目的具体需求和团队的偏好。

以上就是java使用教程怎样实现基于TCP的网络通信 java使用教程的TCP编程入门技巧​的详细内容，更多请关注php中文网其它相关文章！