Java通过 Socket 实现 TCP服务端

下面开始对“Java通过Socket实现TCP服务端”的完整攻略进行详细讲解。

概述

在Java中，可以通过Socket来实现TCP的通信。作为服务端，需要启动一个监听线程来接受客户端的连接请求，并创建一个接受处理线程来处理客户端发送的数据。下面将从以下几个方面来讲解如何通过Socket实现TCP服务端：

1. 启动服务端
2. 监听客户端连接请求
3. 处理客户端发送的数据
4. 关闭服务端

启动服务端

在Java中启动服务端，需要创建一个ServerSocket对象，并设置需要监听的端口号。以下是示例代码：

int port = 8080;
try {
    ServerSocket serverSocket = new ServerSocket(port);
    System.out.println("服务端已启动，监听端口：" + port);
} catch (IOException e) {
    e.printStackTrace();
}

监听客户端连接请求

启动服务端后，需要创建一个线程来监听客户端的连接请求。对于每个连接请求，都需要创建一个新的Socket对象来与客户端进行通信。以下是示例代码：

while (true) {
    try {
        Socket clientSocket = serverSocket.accept();
        System.out.println("客户端连接成功，客户端地址：" + clientSocket.getInetAddress() + "，客户端端口：" + clientSocket.getPort());
        // 处理客户端发送的数据
        // ...
    } catch (IOException e) {
        e.printStackTrace();
    }
}

在循环中调用ServerSocket.accept()方法，等待客户端连接请求。如果客户端发起连接请求，则该方法将返回一个新的Socket对象，程序将创建一个新线程来处理该连接。

处理客户端发送的数据

在接受到客户端连接后，需要通过InputStream读取客户端发送的数据，并通过OutputStream将处理结果返回给客户端。以下是示例代码：

try {
    InputStream inputStream = clientSocket.getInputStream();
    OutputStream outputStream = clientSocket.getOutputStream();
    byte[] buffer = new byte[1024];
    int len;
    while ((len = inputStream.read(buffer)) > 0) {
        String receivedData = new String(buffer, 0, len);
        System.out.println("接收到客户端数据：" + receivedData);
        // 处理客户端发送的数据
        String responseData = "收到您发来的数据：" + receivedData;
        outputStream.write(responseData.getBytes());
        outputStream.flush();
        System.out.println("响应客户端数据：" + responseData);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        clientSocket.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

在处理数据的过程中，需要通过InputStream读取客户端发送的数据。可以先创建一个byte数组作为缓冲区，通过InputStream.read()方法读取客户端发送的数据。读取到数据之后，可以将byte数组转换为字符串，并进行处理。

处理完客户端发送的数据之后，需要通过OutputStream将处理结果返回给客户端。可以通过OutputStream.write()方法将处理结果转换为byte数组，再通过OutputStream.flush()方法将数据发送给客户端。

处理完客户端数据后，需要关闭与客户端的Socket连接。

关闭服务端

在服务端不需要接受客户端连接请求时，需要关闭ServerSocket对象。以下是示例代码：

try {
    serverSocket.close();
    System.out.println("服务端已关闭");
} catch (IOException e) {
    e.printStackTrace();
}

示例

下面给出两个示例：

示例1

该示例实现了一个简单的文件上传服务器，客户端向服务端上传文件，服务端将文件保存到指定目录中。以下是服务端代码：

int port = 8080;
String savePath = "D:/upload/";
int bufferSize = 1024;
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("服务端已启动，监听端口：" + port);
while (true) {
    try {
        Socket clientSocket = serverSocket.accept();
        System.out.println("客户端连接成功，客户端地址：" + clientSocket.getInetAddress() + "，客户端端口：" + clientSocket.getPort());
        // 处理客户端发送的数据
        InputStream inputStream = clientSocket.getInputStream();
        byte[] buffer = new byte[bufferSize];
        int len;
        String fileName = null;
        int fileLength = 0;
        // 读取文件名
        if ((len = inputStream.read(buffer)) > 0) {
            fileName = new String(buffer, 0, len);
        }
        // 读取文件长度
        if ((len = inputStream.read(buffer)) > 0) {
            fileLength = Integer.parseInt(new String(buffer, 0, len));
        }
        FileOutputStream fileOutputStream = new FileOutputStream(new File(savePath + fileName));
        // 读取文件内容
        int count = 0;
        while ((len = inputStream.read(buffer)) > 0) {
            fileOutputStream.write(buffer, 0, len);
            count += len;
            if (count == fileLength) {
                break;
            }
        }
        fileOutputStream.close();
        // 响应客户端
        OutputStream outputStream = clientSocket.getOutputStream();
        String responseData = "文件上传成功";
        outputStream.write(responseData.getBytes());
        outputStream.flush();
        System.out.println("响应客户端数据：" + responseData);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

以下是客户端代码：

String serverIP = "localhost";
int port = 8080;
String filePath = "D:/test.jpg";
int bufferSize = 1024;
Socket clientSocket = new Socket(serverIP, port);
InputStream inputStream = new FileInputStream(new File(filePath));
OutputStream outputStream = clientSocket.getOutputStream();
byte[] buffer = new byte[bufferSize];
int len;
// 发送文件名
String fileName = new File(filePath).getName();
outputStream.write(fileName.getBytes());
outputStream.flush();
// 发送文件长度
int fileLength = inputStream.available();
String fileLengthStr = String.valueOf(fileLength);
outputStream.write(fileLengthStr.getBytes());
outputStream.flush();
// 发送文件内容
while ((len = inputStream.read(buffer)) > 0) {
    outputStream.write(buffer, 0, len);
    outputStream.flush();
}
// 接收响应
buffer = new byte[bufferSize];
if ((len = clientSocket.getInputStream().read(buffer)) > 0) {
    String responseData = new String(buffer, 0, len);
    System.out.println("接收到服务端响应：" + responseData);
}
inputStream.close();
outputStream.close();
clientSocket.close();

示例2

该示例通过Socket实现了多线程的服务端。以下是服务端代码：

int port = 8080;
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("服务端已启动，监听端口：" + port);
while (true) {
    try {
        Socket clientSocket = serverSocket.accept();
        System.out.println("客户端连接成功，客户端地址：" + clientSocket.getInetAddress() + "，客户端端口：" + clientSocket.getPort());
        new SocketThread(clientSocket).start();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

以下是SocketThread类的代码：

public class SocketThread extends Thread {

    private final Socket clientSocket;

    public SocketThread(Socket clientSocket) {
        this.clientSocket = clientSocket;
    }

    @Override
    public void run() {
        try {
            InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = inputStream.read(buffer)) > 0) {
                String receivedData = new String(buffer, 0, len);
                System.out.println("接收到客户端数据：" + receivedData);
                // 处理客户端发送的数据
                String responseData = "收到您发来的数据：" + receivedData;
                outputStream.write(responseData.getBytes());
                outputStream.flush();
                System.out.println("响应客户端数据：" + responseData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

以上就是用Java通过Socket实现TCP服务端的完整攻略，包括启动服务端、监听客户端连接请求、处理客户端发送的数据和关闭服务端四个方面，并提供了两个示例。