如何在Java实现TCP方式发送和接收Socket消息（多线程模式）_java socket请求并接收响应

导言：

在Java编程中，使用TCP协议进行Socket通信是非常常见的场景。本文将详细介绍如何在Java中实现TCP方式发送和接收Socket消息，并且利用多线程模式来提高通信效率。

正文：

1. 创建Server端：

首先，我们需要创建一个Server端来处理接收到的Socket连接请求。以下是实现的步骤：

• 创建一个ServerSocket对象，并指定监听的端口号。
• 使用accept()方法监听客户端的连接请求，并为每个连接创建一个新的线程进行处理。
• 在线程中，使用Socket对象的getInputStream()方法获取输入流，可以读取客户端发送的消息。
• 实现业务逻辑，处理收到的消息。
• 使用Socket对象的getOutputStream()方法获取输出流，可以向客户端发送响应消息。
• 关闭Socket连接和相关资源。

2. 创建Client端：

接下来，我们需要创建一个Client端来发送Socket消息到Server端。以下是实现的步骤：

• 创建一个Socket对象，并指定Server端的IP地址和端口号。
• 使用Socket对象的getOutputStream()方法获取输出流，可以向Server端发送消息。
• 实现业务逻辑，发送需要传输的消息。
• 使用Socket对象的getInputStream()方法获取输入流，可以读取Server端的响应消息。
• 关闭Socket连接和相关资源。

3. 多线程模式：

在上述的Server端实现中，我们为每个连接创建了一个新的线程来处理消息。这样可以并发地处理多个客户端的请求，提高通信效率。以下是实现的步骤：

• 创建一个Runnable接口的实现类，实现run()方法。
• 在run()方法中实现Server端的逻辑：监听客户端连接、接收消息、处理消息、发送响应。
• 在Server端的主线程中，创建一个线程池（ThreadPoolExecutor）来管理线程的执行。
• 使用线程池的execute()方法提交任务，每次有新的连接请求时，创建一个新的任务并执行。
• 关闭线程池和相关资源。

代码示例

当然，以下是一个简单的示例代码，展示了如何在Java中实现TCP方式发送和接收Socket消息（多线程模式）：

Server端代码示例：

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

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(12345);
            System.out.println("Server started, waiting for client...");

            while (true) {
                Socket socket = serverSocket.accept();
                System.out.println("Client connected: " + socket.getInetAddress().getHostAddress());

                Thread thread = new Thread(new ClientHandler(socket));
                thread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class ClientHandler implements Runnable {
        private Socket socket;

        public ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

                String message = reader.readLine();
                System.out.println("Received message from client: " + message);

                // 处理消息（这里仅做回显）
                String response = "Server: " + message.toUpperCase();

                writer.write(response);
                writer.newLine();
                writer.flush();
                System.out.println("Sent response to client: " + response);

                // 关闭连接
                socket.close();
                System.out.println("Connection closed");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

Client端代码示例：

同步模式发送TCP消息

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

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 12345);
            System.out.println("Connected to server");

            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

            String message = "Hello from client";
            writer.write(message);
            writer.newLine();
            writer.flush();
            System.out.println("Sent message to server: " + message);

            String response = reader.readLine();
            System.out.println("Received response from server: " + response);

            // 关闭连接
            socket.close();
            System.out.println("Connection closed");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

异步模式

以下是客户端添加异步方式发送Socket消息并接收服务端响应消息的代码示例：

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

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 12345);
            System.out.println("Connected to server");

            // 异步发送消息
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            Future<Void> sendFuture = executorService.submit(() -> {
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                String message = "Hello from client";
                writer.write(message);
                writer.newLine();
                writer.flush();
                System.out.println("Sent message to server: " + message);
                return null;
            });

            // 异步接收响应
            Future<String> receiveFuture = executorService.submit(() -> {
                BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String response = reader.readLine();
                System.out.println("Received response from server: " + response);
                return response;
            });

            // 等待发送和接收完成
            sendFuture.get();
            String response = receiveFuture.get();

            // 关闭连接
            socket.close();
            executorService.shutdown();
            System.out.println("Connection closed");
        } catch (IOException | InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

在这个异步模式的示例中，我们使用了ExecutorService来创建一个线程池，并利用submit()方法异步地执行发送和接收任务。Future对象用于获取异步任务的结果。

通过这种方式，客户端可以并行地发送消息和接收响应，提高通信效率。请注意，在实际应用中，您可能需要根据具体需求对代码进行修改和调整以满足项目的要求。

在上述示例中，Server端监听12345端口，接受客户端的连接请求，并为每个连接创建一个新的线程进行处理。Client端连接到Server端，发送消息，并接收Server端的响应。Server端仅将客户端发来的消息转换为大写并回显。

请注意，在实际应用中，您可能需要根据具体需求对代码进行修改和扩展，以满足更复杂的场景和功能要求。

结论：

通过以上步骤，我们可以在Java中实现TCP方式发送和接收Socket消息，并且利用多线程模式提高通信效率。这样可以满足大规模并发的需求，使得服务器能够同时处理多个客户端的请求。

需要注意的是，在实际应用中，我们还需要考虑网络异常、数据传输的安全性等问题，并进行相应的处理和优化。

希望本文对您理解如何在Java中实现TCP方式发送和接收Socket消息以及多线程模式有所帮助。如有任何疑问，请随时向我提问。如果您喜欢本文，欢迎点赞、收藏。