在Swing GUI中高效刷新动态图像：利用SwingWorker实现实时更新

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.net.Socket;
import java.util.List;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.SwingWorker;

public class ClientImageUpdater {

    public static void main(String[] args) {
        // 在EDT上创建并显示GUI
        javax.swing.SwingUtilities.invokeLater(() -> {
            JFrame frame = new JFrame("远程图像客户端");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

            JLabel imageLabel = new JLabel("等待图像...", SwingConstants.CENTER);
            frame.getContentPane().add(imageLabel, BorderLayout.CENTER);

            // 设置初始窗口大小，可以根据实际接收的图像尺寸调整
            frame.setPreferredSize(new Dimension(800, 600));
            frame.pack();
            frame.setLocationRelativeTo(null); // 窗口居中
            frame.setVisible(true);

            // 启动SwingWorker来处理图像接收和更新
            ImageReceiveWorker worker = new ImageReceiveWorker(imageLabel, "localhost", 5900);
            worker.execute();
        });
    }

    /**
     * SwingWorker 子类，负责在后台线程接收图像数据并更新UI。
     * <Void, ImageIcon> 中的第一个参数是 doInBackground 的返回值类型（这里不需要特定返回值），
     * 第二个参数是 publish 方法发送的中间结果类型（这里是 ImageIcon）。
     */
    static class ImageReceiveWorker extends SwingWorker<Void, ImageIcon> {

        private final JLabel label;
        private final String serverAddress;
        private final int serverPort;
        private Socket socket;
        private DataInputStream din;

        public ImageReceiveWorker(JLabel label, String serverAddress, int serverPort) {
            this.label = label;
            this.serverAddress = serverAddress;
            this.serverPort = serverPort;
        }

        @Override
        protected Void doInBackground() throws Exception {
            try {
                // 尝试连接服务器
                socket = new Socket(serverAddress, serverPort);
                din = new DataInputStream(socket.getInputStream());
                System.out.println("成功连接到服务器: " + serverAddress + ":" + serverPort);

                // 首次接收图像尺寸（如果服务器发送）
                // int width = din.readInt();
                // int height = din.readInt();
                // label.setPreferredSize(new Dimension(width, height)); // 可以根据实际尺寸调整JLabel大小

                while (!isCancelled()) { // 持续循环接收图像，直到任务被取消
                    try {
                        // 读取图像数据的长度
                        int len = din.readInt();
                        if (len <= 0) { // 如果长度为0或负数，可能是连接中断或数据异常
                            System.err.println("接收到无效的图像数据长度: " + len + "，尝试重新连接或等待...");
                            Thread.sleep(100); // 短暂等待，避免CPU空转
                            continue;
                        }

                        byte[] imageInByte = new byte[len];
                        din.readFully(imageInByte); // 读取完整的图像字节数据

                        // 将字节数据转换为 BufferedImage
                        ByteArrayInputStream bis = new ByteArrayInputStream(imageInByte);
                        BufferedImage bImage = ImageIO.read(bis);

                        if (bImage != null) {
                            // 创建 ImageIcon 并发布到EDT
                            ImageIcon icon = new ImageIcon(bImage);
                            publish(icon);
                        } else {
                            System.err.println("无法解码接收到的图像数据。");
                        }

                    } catch (java.io.EOFException e) {
                        System.out.println("服务器关闭连接或数据流结束。");
                        break; // 退出循环
                    } catch (Exception e) {
                        System.err.println("接收图像数据时发生错误: " + e.getMessage());
                        e.printStackTrace();
                        // 考虑在此处添加重连逻辑或等待一段时间
                        Thread.sleep(500); // 错误后稍作等待
                    }
                }
            } catch (Exception e) {
                System.err.println("连接服务器失败或初始化错误: " + e.getMessage());
                e.printStackTrace();
            } finally {
                // 确保关闭资源
                if (din != null) {
                    try { din.close(); } catch (Exception e) { e.printStackTrace(); }
                }
                if (socket != null) {
                    try { socket.close(); } catch (Exception e) { e.printStackTrace(); }
                }
                System.out.println("图像接收工作器已停止。");
            }
            return null;
        }

        @Override
        protected void process(List<ImageIcon> icons) {
            // 此方法在EDT上执行，接收所有发布的 ImageIcon
            if (!icons.isEmpty()) {
                // 通常只取最新的一个图标进行更新，以确保UI显示的是最新状态
                ImageIcon latestIcon = icons.get(icons.size() - 1);
                label.setIcon(latestIcon);
                // 如果图像尺寸变化，可能需要重新布局和重绘
                // label.revalidate();
                // label.repaint();
                // 如果JFrame的尺寸需要跟随图像变化，可以考虑 frame.pack(); 但在循环中调用 pack() 可能效率不高
            }
        }

        @Override
        protected void done() {
            // 此方法在EDT上执行，当 doInBackground 完成时调用
            try {
                get(); // 检查 doInBackground 是否抛出异常
                label.setText("图像接收已停止。");
            } catch (Exception e) {
                label.setText("图像接收出现错误: " + e.getMessage());
                e.printStackTrace();
            }
        }
    }
}