Java中Socket通信问题分析：五种不同情况的示例

原创刺骨的言语ヽ痛彻心扉 2024-09-25 17:51 18阅读 0赞

在Java中，Socket是一种网络编程接口，用于客户端和服务器端之间的双向通信。下面我将分析并提供五种不同情况下使用Socket进行通信的示例。

1. **客户端向服务器发起连接**：
```java
import java.net.*;

public class Client {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 8080)) {
            System.out.println("Connected to Server!");
            // Now you can send/receive data through the socket.
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }
    }
}
```

2. **服务器端监听客户端连接**：
```java
import java.net.*;
import java.io.*;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8080);
        System.out.println("Server is listening for connections...");

Socket client = server.accept();
        System.out.println("Client connected: " + client.getRemoteSocketAddress()));

DataOutputStream out = new DataOutputStream(client.getOutputStream()));
        // Send/receive data here.

out.close();
        client.close();
        server.close();
    }
}
```

3. **客户端主动关闭连接**：
```java
import java.net.*;
import java.io.*;

public class ClientClosing {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 8080));
        System.out.println("Connected to Server!");

DataOutputStream out = new DataOutputStream(socket.getOutputStream()));
        // Send data here.

// Simulate client closing the connection.
        socket.closeOutput();
        System.out.println("Client closed the connection.");

// Now you can't send/receive any data through the socket.
    }
}
```

4. **服务器端主动关闭连接**：
```java
import java.net.*;
import java.io.*;

public class ServerClosing {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8080));
        System.out.println("Server is listening for connections...");

Socket client = server.accept();
        System.out.println("Client connected: " + client.getRemoteSocketAddress()));

DataOutputStream out = new DataOutputStream(client.getOutputStream()));
        // Send/receive data here.

// Simulate the server closing the connection.
        server.close();
        System.out.println("Server closed the connection.");

// Now you can't send/receive any data through the socket anymore.
    }
}
```

5. **多客户端连接**：
在实际应用中，可能会有多个客户端同时连接到服务器。这需要在服务器端对每个连接进行单独处理。

例如，一个简单的多客户端聊天服务，可以使用线程池来并发处理客户端请求：

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

public class MultiClientChatServer {
    private static final int PORT = 8080;
    private static final int THREAD_POOL_SIZE = 10;

public static void main(String[] args) throws IOException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE));

ServerSocket server = new ServerSocket(PORT);
        System.out.println("Server started listening on port " + PORT);

while (true) {
            Socket client = server.accept();
            System.out.println("Client connected: " + client.getRemoteSocketAddress()));

executor.submit(new ClientHandler(client)));
        }

executor.shutdown();
        while (!executor.isTerminated())) {
            Thread.sleep(100);
        }
        server.close();
    }

private static class ClientHandler implements Runnable {
        private final Socket socket;
        private DataOutputStream out;

public ClientHandler(Socket socket) {
            this.socket = socket;
            try {
                out = new DataOutputStream(socket.getOutputStream()));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

@Override
        public void run() {
            // Send/receive data from client.
            String message = "Hello, client! Message received: " + System.currentTimeMillis();
            out.writeUTF(message);

try {
                socket.shutdownOutput();
                System.out.println("Client closed the connection.");
            } catch (IOException e) {
                System.err.println(e.getMessage());
            }

// Close resources when done.
            try {
                out.close();
                socket.close();
            } catch (IOException e) {
                System.err.println(e.getMessage());
            }
        }
    }
}
```
以上示例涵盖了Java中Socket通信的五种常见情况。