java代码利用机器人Robot类实现捕获桌面屏幕图像，服务器端送自己的屏幕图像，接受客户端传来的控制命令，客户端接受被控端计算机（服务器端）传来的屏幕图像，向被控端计算机发送鼠标操作或键盘操作指令

以下是一个简单的Java程序，利用Robot类实现捕获桌面屏幕图像，并将图像发送给服务器端。同时，程序可以接受客户端传来的鼠标或键盘操作指令，并模拟执行这些操作。

服务器端代码：

import java.awt.*;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import javax.imageio.ImageIO;

public class Server {
    private static final int PORT = 8888;

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

            Robot robot = new Robot();
            Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

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

                // Send screen image to client
                BufferedImage image = robot.createScreenCapture(new Rectangle(screenSize));
                ImageIO.write(image, "png", socket.getOutputStream());

                // Receive control command from client
                int cmd = socket.getInputStream().read();
                if (cmd == 1) {
                    // Move mouse
                    int x = socket.getInputStream().read();
                    int y = socket.getInputStream().read();
                    robot.mouseMove(x, y);
                } else if (cmd == 2) {
                    // Click mouse
                    int button = socket.getInputStream().read();
                    if (button == 1) {
                        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
                        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);    
                    } else if (button == 2) {
                        robot.mousePress(InputEvent.BUTTON2_DOWN_MASK);
                        robot.mouseRelease(InputEvent.BUTTON2_DOWN_MASK);    
                    } else if (button == 3) {
                        robot.mousePress(InputEvent.BUTTON3_DOWN_MASK);
                        robot.mouseRelease(InputEvent.BUTTON3_DOWN_MASK);    
                    }
                } else if (cmd == 3) {
                    // Type key
                    int key = socket.getInputStream().read();
                    robot.keyPress(key);
                    robot.keyRelease(key);
                }

                socket.close();
            }
        } catch (AWTException | IOException e) {
            e.printStackTrace();
        }
    }
}

客户端代码：

import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.Socket;
import javax.imageio.ImageIO;
import javax.swing.*;

public class Client extends JFrame {
    private static final int PORT = 8888;
    private static final String SERVER_IP = "127.0.0.1";
    private static final int SCREEN_WIDTH = 800;
    private static final int SCREEN_HEIGHT = 600;

    private JLabel screenLabel;
    private Robot robot;

    public Client() {
        setTitle("Remote Control Client");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        screenLabel = new JLabel();
        add(screenLabel);

        setResizable(false);
        pack();
        setLocationRelativeTo(null);

        try {
            robot = new Robot();
        } catch (AWTException e) {
            e.printStackTrace();
        }
    }

    public void start() {
        while (true) {
            try {
                Socket socket = new Socket(SERVER_IP, PORT);

                // Receive screen image from server
                BufferedImage image = ImageIO.read(socket.getInputStream());
                screenLabel.setIcon(new ImageIcon(image));

                // Read user input
                int cmd = -1;
                int x = -1, y = -1;
                int button = -1;
                int key = -1;

                if (MouseInfo.getPointerInfo().getLocation().x >= 0 &&
                    MouseInfo.getPointerInfo().getLocation().y >= 0 &&
                    MouseInfo.getPointerInfo().getLocation().x < SCREEN_WIDTH &&
                    MouseInfo.getPointerInfo().getLocation().y < SCREEN_HEIGHT) {
                    cmd = 1;
                    x = MouseInfo.getPointerInfo().getLocation().x;
                    y = MouseInfo.getPointerInfo().getLocation().y;

                    if (SwingUtilities.isLeftMouseButtonPressed())
                        button = 1;
                    else if (SwingUtilities.isMiddleMouseButtonPressed())
                        button = 2;
                    else if (SwingUtilities.isRightMouseButtonPressed())
                        button = 3;
                } else {
                    for (int i = KeyEvent.VK_0; i <= KeyEvent.VK_Z; i++) {
                        if (robot.isKeyDown(i)) {
                            cmd = 3;
                            key = i;
                            break;
                        }
                    }
                }

                // Send control command to server
                socket.getOutputStream().write(cmd);
                if (cmd == 1) {
                    socket.getOutputStream().write(x);
                    socket.getOutputStream().write(y);
                } else if (cmd == 2) {
                    socket.getOutputStream().write(button);
                } else if (cmd == 3) {
                    socket.getOutputStream().write(key);
                }

                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.setVisible(true);
        client.start();
    }
}

在启动程序前，需要先确保客户端和服务器端在同一局域网内，并且服务器端先启动。启动程序后，客户端的界面会显示服务器端的屏幕画面，并且可以在客户端进行鼠标或键盘操作。