Java远程操控

Java远程操控

远程操控原理：

    远程操控的实质就是操控方发送鼠标事件，接收被操控方发送来的截图。

    被操控方截图发送，获取鼠标事件然后用一个机器人对象来操控鼠标键盘。

Java实现C/S远程操控：

    单纯的C/S远程操控是很简单的，只要一方接受截图发送事件，另一边做相反操作就可以了。

    但若是两个通过服务器的连接，让两个客户端实现远程操控，难度就大大提高。

    这两天我就是在我的HuaXinIM聊项目中实现了有服务器转发操作的远程操作，我知道服务器只要转发这几个条件，但是死活搞了很久，用了几个线程死循环来做，也获取了几个输入输出流，代码结构相当复杂,混乱，后来我重新编写，只用了原来的输入输出流，线程也删除了，讲读写的代码都封装到方法里面，终于把问题解决了。

    但是其中测试操控鼠标的时候，卡住了，应该是单机测试的局限，服务器即客户端，所以不断的递归返回新的新事件，截图确确实实的可以实现。

有服务器转发的远程控制部分代码:

服务端转发截图：

else if( type.equals("getPicture") ){
int length = ois.readInt();
byte[] bytes = new byte[length];
ois.readFully(bytes);
SocketDistanceControl.getPicture(length, bytes);
}

public static void getPicture(int length,byte[] bytes) {//截图的收发:被控制方发送截图给控制方
try {
String msg = "<choice>getPicture</choice>";
coos.writeUTF(msg);
coos.flush();
coos.writeInt(length);//发送一个int值
coos.flush();
coos.write(bytes);//发送图片数组
coos.flush();
} catch (Exception e) {
e.printStackTrace();
}
}

服务器转发鼠标事件:

else if( type.equals("getObject") ){
Object object = ois.readObject();
// SocketDistanceControl.getEvent(object);
}

public static void getEvent(Object object){
try{
String msg = "<choice>getObject</choice>";
bcoos.writeUTF(msg);
bcoos.flush();
bcoos.writeObject(object);
bcoos.flush();
}catch(Exception e){
e.printStackTrace();
}
}

客户端的接收截图：

else if(getType(Msg,"choice").equals("getPicture")){
int imageLength = ois.readInt();
byte[] data = new byte[imageLength];
ois.readFully(data);
DistanceControl.getPicture(imageLength, data);
}

public static void getPicture(int imageLength,byte[] data) {
try{
ByteArrayInputStream bais = new ByteArrayInputStream(data);
BufferedImage image = ImageIO.read(bais);
ImageIcon icon = new ImageIcon(image);
imageLabel.setIcon(icon);
imageLabel.repaint();
}catch(Exception e){
e.printStackTrace();
}
}

客户端接受鼠标事件：

else if(getType(Msg,"choice").equals("getObject")){
Object ie = ois.readObject();
DistanceControl.getObject(ie);
}

public static void getObject(Object object) {
try {
while (true) {
Object ie = object;
if (ie instanceof MouseEvent) {
MouseEvent me = (MouseEvent) ie;
int id = me.getID();
if (id == MouseEvent.MOUSE_PRESSED) {// 按下
int number = me.getButton();
if (number == MouseEvent.BUTTON1) {
robot.mousePress(InputEvent.BUTTON1_MASK);
} else if (number == MouseEvent.BUTTON2) {
robot.mousePress(InputEvent.BUTTON2_MASK);
} else if (number == MouseEvent.BUTTON3) {
robot.mousePress(InputEvent.BUTTON3_MASK);
}
} else if (id == MouseEvent.MOUSE_CLICKED || id == MouseEvent.MOUSE_RELEASED) {// 移动
int number = me.getButton();
if (number == MouseEvent.BUTTON1) {
robot.mousePress(InputEvent.BUTTON1_MASK);
} else if (number == MouseEvent.BUTTON2) {
robot.mousePress(InputEvent.BUTTON2_MASK);
} else if (number == MouseEvent.BUTTON3) {
robot.mousePress(InputEvent.BUTTON3_MASK);
}
} else if (id == MouseEvent.MOUSE_DRAGGED || id == MouseEvent.MOUSE_MOVED) {// 点击
robot.mouseMove(me.getX(), me.getY());
}
} else if (ie instanceof KeyEvent) {
KeyEvent me = (KeyEvent) ie;
int id = me.getID();
System.out.println(id);
if (id == KeyEvent.KEY_PRESSED) {
robot.keyPress(me.getKeyCode());
} else if (id == KeyEvent.KEY_RELEASED) {
robot.keyRelease(me.getKeyCode());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

客户端发送鼠标事件：

MouseAdapter ma = new MouseAdapter() {
public void mousePressed(MouseEvent e) {
sendEvent(e);
}
public void mouseReleased(MouseEvent e) {
sendEvent(e);
}
public void mouseClicked(MouseEvent e) {
sendEvent(e);
}
public void mouseMoved(MouseEvent e) {
sendEvent(e);
}
public void mouseDragged(MouseEvent e) {
sendEvent(e);
}
};
/**
* 键盘监听
*/
KeyAdapter ka = new KeyAdapter() {
public void keyPressed(KeyEvent e) {
sendEvent(e);
}
public void keyReleased(KeyEvent e) {
sendEvent(e);
}
};
this.addMouseListener(ma);
this.addMouseMotionListener(ma);
this.addMouseWheelListener(ma);
this.addKeyListener(ka);

private void sendEvent(InputEvent e) {
try {
String msg = "<type>getObject</type>";
oos.writeUTF(msg);
oos.flush();
oos.writeObject(e);
oos.flush();
} catch (IOException e1) {
e1.printStackTrace();
}
}

客户端截图并发送截图：

public void byControled() {
new Thread() {
public void run() {
try {
while(true){
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension dm = tk.getScreenSize();
Rectangle rt = new Rectangle(0, 0, dm.width, dm.height);
BufferedImage image = robot.createScreenCapture(rt);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageIO.write(image, "jpeg", baos);
byte[] data = baos.toByteArray();
String msg = "<type>getPicture</type>";
oos.writeUTF(msg);
oos.flush();
oos.writeInt(data.length);
oos.flush();
oos.write(data);
oos.flush();
Thread.sleep(20);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
}

无服务器转发的远程控制代码：

服务器端：

package 远程控制服务器.src.远程控制服务器;

import java.awt.AWTException;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

import javax.imageio.ImageIO;

public class MySever {
private Robot robot;// 定义一个机器人类对象，用于操控
{
try {
robot = new Robot();
} catch (AWTException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
MySever m = new MySever();
m.initServer();
}
private void initServer() {
try {
ServerSocket ss = new ServerSocket(9090);
System.out.println("服务器创建好了");
Socket socket = ss.accept();
System.out.println("已连接");
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
System.out.println("已经创建输入输出流...");
new Thread() {
public void run() {
while (true) {
try {
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension dm = tk.getScreenSize();
Rectangle rt = new Rectangle(0, 0, dm.width, dm.height);
BufferedImage image = robot.createScreenCapture(rt);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageIO.write(image, "jpeg", baos);
byte[] data = baos.toByteArray();
oos.writeInt(data.length);
oos.write(data);
oos.flush();
Thread.sleep(20);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}.start();
new Thread() {
public void run() {
while (true) {
try {
Object ie = ois.readObject();
if (ie instanceof MouseEvent) {
MouseEvent me = (MouseEvent) ie;
int id = me.getID();
if (id == MouseEvent.MOUSE_PRESSED) {// 按下
int number = me.getButton();
if (number == MouseEvent.BUTTON1) {
robot.mousePress(InputEvent.BUTTON1_MASK);
} else if (number == MouseEvent.BUTTON2) {
robot.mousePress(InputEvent.BUTTON2_MASK);
} else if (number == MouseEvent.BUTTON3) {
robot.mousePress(InputEvent.BUTTON3_MASK);
}
} else if (id == MouseEvent.MOUSE_CLICKED || id == MouseEvent.MOUSE_RELEASED) {// 移动
int number = me.getButton();
if (number == MouseEvent.BUTTON1) {
robot.mousePress(InputEvent.BUTTON1_MASK);
} else if (number == MouseEvent.BUTTON2) {
robot.mousePress(InputEvent.BUTTON2_MASK);
} else if (number == MouseEvent.BUTTON3) {
robot.mousePress(InputEvent.BUTTON3_MASK);
}
} else if (id == MouseEvent.MOUSE_DRAGGED || id == MouseEvent.MOUSE_MOVED) {// 点击
robot.mouseMove(me.getX(), me.getY());
}
} else if (ie instanceof KeyEvent) {
KeyEvent me = (KeyEvent) ie;
int id = me.getID();
System.out.println(id);
if (id == KeyEvent.KEY_PRESSED) {
robot.keyPress(me.getKeyCode());
} else if (id == KeyEvent.KEY_RELEASED) {
robot.keyRelease(me.getKeyCode());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}.start();
}catch(Exception e){

}
}
}

客户端：

package 远程控制客户端.src.远程控制客户端;

import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.InputEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

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

public class MyClient extends JFrame{
public ObjectInputStream ois;
public ObjectOutputStream oos;
public JLabel imageLabel;
public static void main(String[] args) {
MyClient mc = new MyClient();
mc.initFrame();
}
public void initFrame(){
try {
Socket socket = new Socket("localhost",9090);
System.out.println("客户端已经连接服务器...");
ois = new ObjectInputStream(socket.getInputStream());
oos = new ObjectOutputStream(socket.getOutputStream());
System.out.println("已经创建输入输出流...");
imageLabel = new JLabel();
this.add(imageLabel);
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
this.setSize(dim);
this.setDefaultCloseOperation(3);
this.setLocationRelativeTo(null);
new Thread() {
public void run() {
while (true) {
// 显示屏幕
try {
// 获取长度
int imageLength = ois.readInt();
// 创建图片字节数组
byte[] data = new byte[imageLength];
// 读取一张图片的字节数组
ois.readFully(data);
// 将读入字节转化为一个BufferedImage对象
ByteArrayInputStream bais = new ByteArrayInputStream(data);
BufferedImage image = ImageIO.read(bais);
ImageIcon icon = new ImageIcon(image);
imageLabel.setIcon(icon);
imageLabel.repaint();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}.start();
this.setVisible(true);
/**
* 鼠标监听
*/
MouseAdapter ma = new MouseAdapter() {
public void mousePressed(MouseEvent e) {
sendEvent(e);
}
public void mouseReleased(MouseEvent e) {
sendEvent(e);
}
public void mouseClicked(MouseEvent e) {
sendEvent(e);
}
public void mouseMoved(MouseEvent e) {
sendEvent(e);
}
public void mouseDragged(MouseEvent e) {
sendEvent(e);
}
};
/**
* 键盘监听
*/
KeyAdapter ka = new KeyAdapter() {
public void keyPressed(KeyEvent e) {
sendEvent(e);
}
public void keyReleased(KeyEvent e) {
sendEvent(e);
}
};
this.addMouseListener(ma);
this.addMouseMotionListener(ma);
this.addMouseWheelListener(ma);
this.addKeyListener(ka);
} catch (Exception e) {
e.printStackTrace();
}
}
private void sendEvent(InputEvent e) {
try {
oos.writeObject(e);
oos.flush();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}

图示：