tcp 客户端发送数据和服务端接收数据的简单实现

客户端代码

以下是一个传输16进制的示例

public class text {

    public static void main(String[] args) {
        String serverHost = "127.0.0.1"; // 服务器主机地址
        int serverPort = 1111; // 服务器端口号

        try {
            // 创建Socket连接服务器
            Socket socket = new Socket(serverHost, serverPort);
            System.out.println("已连接到服务器");
            // 启动定时任务，每隔一段时间发送数据
            ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
            executorService.scheduleAtFixedRate(() -> {
                try {
                    String hexString = "00010203FFFF";

                    // 将十六进制字符串转换为字节数组
                    byte[] byteArray = DatatypeConverter.parseHexBinary(hexString);


                    // 发送数据给服务端
                    OutputStream outputStream = socket.getOutputStream();
                    outputStream.write(byteArray);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, 0, 5, TimeUnit.SECONDS); // 每隔5秒发送一次数据

            // 关闭连接
            socket.close();
            executorService.shutdown(); // 关闭定时任务
        } catch (IOException e) {
            System.err.println("无法连接到服务器：" + e.getMessage());
            e.printStackTrace();
        }

    }
}

服务器接收数据

服务器定义客户端要传输的端口号，这里是要随代码启动而启动一个服务器来接受客户端发送的数据。
这里buffer字节转为十进制用的方法是先转换为无符号整数（ & 0xFF）再根据位置移位最后拼接

@Component
public class listener implements ApplicationListener<ApplicationStartedEvent> {
    private final int serverPort = 1111; // 服务器端口号
    private DataCollectionServer server;

    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        // 在Spring Boot应用启动时启动服务器
        server = new DataCollectionServer(serverPort);

        // 创建一个新的线程来启动服务器
        Thread serverThread = new Thread(server);
        serverThread.start();
    }

    static class DataCollectionServer implements Runnable {
        private final int serverPort;
        private boolean isRunning;

        public DataCollectionServer(int serverPort) {
            this.serverPort = serverPort;
            this.isRunning = false;
        }

        @Override
        public void run() {
            try {
                ServerSocket serverSocket = new ServerSocket(serverPort);
                isRunning = true;
                System.out.println("服务器已启动，等待客户端连接...");

                while (isRunning) {
                    Socket clientSocket = serverSocket.accept();
                    System.out.println("客户端已连接，地址：" + clientSocket.getInetAddress());

                    // 创建一个新的线程来处理客户端连接
                    Thread clientHandler = new Thread(new ClientHandler(clientSocket));
                    clientHandler.start();
                }

                serverSocket.close();
            } catch (IOException e) {
                System.err.println("服务器启动失败：" + e.getMessage());
                e.printStackTrace();
            }
        }

        public void stop() {
            isRunning = false;
        }

        static class ClientHandler implements Runnable {
            private final Socket clientSocket;

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

            @Override
            public void run() {
                // 处理客户端连接的逻辑
                try {
                    // 从客户端socket获取输入流
                    DataInputStream inputStream = new DataInputStream(clientSocket.getInputStream());

                    // 读取客户端发送的数据并进行实时处理
                    byte[] buffer = new byte[1024]; // 假设数据包大小不超过1024字节
                   

                    while ((inputStream.read(buffer)) != -1) {
                       int a= buffer[0] & 0xFF;
                       int b=((buffer[1] & 0xFF) << 8) | (buffer[2] & 0xFF);
                        // 在这里可以将数据进行实时保存或处理
                    }
                } catch (IOException e) {
                	//客户端断开连接，简单输出一下日志即可
                    System.out.println(e.getMessage());
                } finally {
                    try {
                        // 关闭客户端socket
                    	if(clientSocket!=null)
                        clientSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}