JAVA实现远程控制（JAVA in RemoteControl）

远程控制（RemoteControl）

远程控制的基本原理... 2

远程控制（RemoteControl）拥有控制端和被控端双方... 2

事件回放原理... 2

捕获桌面原理：... 3

远程控制（RemoteControl）的核心技术5

1 、Socket编程... 5

2、控制端事件的封装... 5

3、画面的传输... 6

远程控制（RemoteControl）的控制端... 7

远程控制（RemoteControl）的被控制端15

远程控制（RemoteControl）的界面截图25

控制端（客户端）... 25

被控制端（远端或服务端）... 25

远程控制的基本原理

远程控制（ RemoteControl）拥有控制端和被控端双方。

控制方通过请求，取得对远端的操作，实现远端的事件回放功能，同时，应该看得到远端桌面的画面。

而被控方必须在建立ServerSocket之后进行对外来请求的鉴听。如下图，

 

事件回放原理

利用JAVA.AWT.ROBOT类，实现在远端的回放功能

例子：// Robot 使用示例

import java.awt.Toolkit;

import java.awt.event.InputEvent;

import java.awt.event.KeyEvent;

public class RobotTest {

public static void main(String[]args) throws Exception {

// 创建一个机器人对象

java.awt.Robot robot = new java.awt.Robot ();

// 当前屏幕大小

Toolkit tk = java.awt.Toolkit.getDefaultToolkit ();

java.awt.Dimension dm = tk.getScreenSize ();

// 计算屏幕中心点

int x = ( int ) dm.getWidth() / 2;

int y = ( int ) dm.getHeight() / 2;

// 将鼠标移动到屏幕中心

robot.mouseMove(x, y);

// 按下鼠标左键

robot.mousePress(InputEvent.BUTTON1_MASK );

// 松开鼠标左键

robot.mouseRelease(InputEvent.BUTTON1_MASK );

// 模拟按下回车键

robot.keyPress(KeyEvent.VK_ENTER );

/ / 模拟放松回车键

robot.keyRelease(KeyEvent.VK_ENTER );

// 按下 SHIFT 键

robot.keyPress(KeyEvent.VK_SHIFT );

for ( int i = 0; i < 10; i++) {

// 在屏幕上打字

robot.keyPress('A' + i);

robot.keyRelease('A' + i);

Thread.sleep (500);

}

// 松开 SHIFT 键

robot.keyRelease(KeyEvent.VK_SHIFT );

for ( int i = 0; i < 11; i++) {

// 删除操作

robot.keyPress(KeyEvent.VK_BACK_SPACE );

robot.keyRelease(KeyEvent.VK_BACK_SPACE );

Thread.sleep (500);

}

}

}

捕获桌面原理：

同样利用ROBOT里的createScreenCapture() 方法进行画面的捕获。

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.RenderingHints;

import java.awt.Toolkit;

import java.awt.image.BufferedImage;

import java.io.FileOutputStream;

 

import javax.swing.*;

 

public class ScreenTest {

// 截屏测试

public static void main(String[] args) throws Exception {

//控制台标题

JFrame jf = new JFrame( " 控制台 " );

// 控制台大小

jf.setSize(500, 400);

//imag_lab 用于存放画面

JLabel imag_lab = new JLabel();

jf.add(imag_lab);

// 设置控制台可见

jf.setVisible(true );

// 控制台置顶

jf.setAlwaysOnTop(true );

// 控制台退出模式

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE );

java.awt.Dimension d =jf.size ();

java.awt.Graphics g = jf.getGraphics();

// 当前屏幕大小

Toolkit tk = java.awt.Toolkit.getDefaultToolkit ();

java.awt.Dimension dm =tk.getScreenSize();

// 创建 Robot 对象

java.awt.Robot robot = new java.awt.Robot();

for ( int i = 0; i < 1000; i++) {

// 截取指定大小的屏幕区域

Rectangle rec = new Rectangle(0, 0, ( int ) dm.getWidth(), ( int ) dm

.getHeight());

BufferedImage bimage = robot.createScreenCapture(rec);

// 将图片转为小图片

BufferedImage littleImage =resize (bimage,jf.getWidth(),jf

.getHeight());

// 将图片保存到文件中

FileOutputStream fous =new FileOutputStream( "screenImg” + i+ ”.jpeg" );

// javax.imageio.ImageIO.write(littleImage, "jpeg", fous);

fous.flush();

fous.close();

// 将小图片显示到界面上

imag_lab.setIcon(new javax.swing.ImageIcon(littleImage));

Thread.sleep (50);

}

}

 

private static BufferedImage resize(BufferedImage img, int newW, int newH) {

int w = img.getWidth();

int h = img.getHeight();

BufferedImage dimg = new BufferedImage(newW, newH, img.getType());

Graphics2D g = dimg.createGraphics();

g.setRenderingHint(RenderingHints.KEY_INTERPOLATION ,

RenderingHints.VALUE_INTERPOLATION_BILINEAR );

g.drawImage(img, 0, 0, newW, newH, 0, 0, w, h,null );

g.dispose();

return dimg;

}

}

 

远程控制（RemoteControl ）的核心技术

1 、Socket编程

利用JAVA Socket编程，使控制端与被控端之间建立数据传输的数据流通道。

例子：

（远端）ServerSocketss =new ServerSocket(PORT);

Socket client = ss.accept();

（近端）Socket s=new Socket(IP,PORT);

注：Socket有对应的输入输出（InputStream、 OutputStream）流对象。

2 、控制端事件的封装

将控制端所侦听到的事件封装成InputEvent类，用对像输入出流，往远端写出去。

private void sendEventObject (java.awt.event.InputEventevent){

try {

// 将事件对象发送到被控制端

ous .writeObject(event);

}catch (Exception ef){

ef.printStackTrace();

}

}

3 、画面的传输

在远端，每隔一段一定的时间，将从桌面捕获的画面图片，用javax.io.ImagIO转成一个字节数组，从而将每一个画面的数据量大小，以及数据用数据输出流往控制端发送。

相关代码：

public void run(){

// 截图，发送

try {

while ( true ){

byte [] data=createImage();

// 发送 :

//1. 先写一个 int , 代表图片数据长度

dous .writeInt(data. length );

//2. 写入图片字节数据

dous .write(data);

dous .flush();

Thread.sleep (1000/20);

}

}catch (SocketExceptionef){

// ef.printStackTrace();

rs .destroy();

throw new MyException( " 客户端 SOCKET 已断开连接，无法发送图片信息。。 " );

} catch (InterruptedException e) {

// TODO Auto-generatedcatch block

rs .destroy();

throw new MyException( " 客户端已中断连接，无法发送图片信息。。 " );

} catch (IOException e) {

// TODO Auto-generatedcatch block

rs .destroy();

throw new MyException( " 客户端输入输出流中断，无法发送图片信息。。 " );

} catch (Exception e) {

// TODO Auto-generatedcatch block

rs .destroy();

throw new MyException( " 客户端已断开连接，无法发送图片信息。。 " );

}

}

// 取得一张屏幕图片 , 转成字节数组返回

private byte [] createImage() throws Exception{

java.awt.Robot robot=new java.awt.Robot();

java.awt.Toolkit tk=java.awt.Toolkit.getDefaultToolkit ();

java.awt.Dimensiondm=tk.getScreenSize();

// 设定区域的大小

Rectangle rt=new Rectangle(0,0,dm. width ,dm. height );

// 取得指定大小的一张图片

BufferedImage image=robot.createScreenCapture(rt);

// 创建一段内存流

java.io.ByteArrayOutputStream temB=new ByteArrayOutputStream ();

// 将图片数据写入内存流中

javax.imageio.ImageIO.write (image,"jpeg" , temB);

// 做为字节数组返回

byte [] data=temB.toByteArray();

return data;

}

 

远程控制（RemoteControl ）的控制端

在控制端，实现对所有事件（Mouse、Key）的侦听，将所有事件封装在InputEvent类，并用对像输出流ObjectOutputStream发送到远端。同时，控制端为一个线程，不断地执行run()方法，将接收到的画面数据（按远端转成字节数据的逆过程）转成图片，并在控制端显示。

控制端代码（在包com.zzw.client里有三个类，代码分别如下）

package com.zzw.client;

importjava.awt.FlowLayout;

import java.awt.event.*;

import javax.swing.*;

importjava.net.InetAddress;

importjava.net.UnknownHostException;

public class Client extends JFrame {

/**

* @param args

*/

public JTextField iptf =new JTextField(10);

public JTextField porttf =new JTextField(3);

public JButton jb1 = new JButton("连接");

public JButton jb2 = new JButton("断开");

public void launch(){

this.setTitle("远程控制客户端---连接窗口");

this.setLocation(300, 200);

this.setSize(300, 100);

this.setAlwaysOnTop(true);

JLayeredPane jlp =new JLayeredPane();

jlp.setLayout(new FlowLayout());

jlp.add(new JLabel("远程IP地址："));

iptf.setText("127.0.0.1");

porttf.setText("8888");

jlp.add(iptf);

jlp.add(new JLabel("端口："));

jlp.add(porttf);

jb1.addMouseListener(new MouseAdapter(){

public void mouseClicked(MouseEvent e) {

try {

ClientDealObject.connect(iptf.getText(),Integer.parseInt(porttf.getText().trim()));

} catch (NumberFormatException e1) {

//端口号格式输入出错

JOptionPane.showMessageDialog(null,"IP地址或端口号输入出错，无法取得连接。。","提示",JOptionPane.ERROR_MESSAGE);

System.exit(0);

destroy();

//

} catch (MyException e1) {

// JOptionPane.showMessageDialog(null,e1.info,"提示",JOptionPane.ERROR_MESSAGE);

//

}catch(Exception ed){

// "远程不允许被控，无法取得连接。。

JOptionPane.showMessageDialog(null,"远程不允许被控，无法取得连接。。","提示",JOptionPane.ERROR_MESSAGE);

System.exit(0);

destroy();

}

//连接成功

}

});

jb2.addMouseListener(new MouseAdapter(){

public void mouseClicked(MouseEvent e) {

JOptionPane.showMessageDialog(null, "断开控制端窗口","提示",JOptionPane.INFORMATION_MESSAGE);

System.exit(0);

destroy();

}

});

jlp.add(jb1);

jlp.add(jb2);

this.setLayeredPane(jlp);

this.addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent e) {

// 关闭窗口

JOptionPane.showMessageDialog(null, "关闭连接窗口","提示",JOptionPane.INFORMATION_MESSAGE);

System.exit(0);

}

});

this.setVisible(true);

}

public static void main(String[] args) {

// TODO Auto-generated method stub

// new RemoteControlLoginFrame().getLocalIP();

new Client().launch();

}

public String getLocalIP(){

String ipstr = "";

InetAddress ip = null;

try {

ip = InetAddress.getLocalHost();

} catch (UnknownHostException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

ipstr = ip.toString();

ipstr = ipstr.substring(ipstr.indexOf("/")+1);

System.out.println(ipstr);

return ipstr;

}

public void destroy(){

this.destroy();

}

}

 

 

 

梦之幻时尚睡衣纺 http://shop.paipai.com/442560143

///////

package com.zzw.client;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

importjava.awt.RenderingHints;

import java.awt.Toolkit;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.awt.event.MouseWheelEvent;

import java.awt.event.MouseWheelListener;

import java.awt.image.BufferedImage;

importjava.io.ByteArrayInputStream;

importjava.io.DataInputStream;

importjava.io.ObjectOutputStream;

importjavax.imageio.ImageIO;

importjavax.swing.ImageIcon;

importjavax.swing.JLayeredPane;

public class ClientDealObject extends Thread{

public int x,y;

private java.io.DataInputStream dins;

private java.io.ObjectOutputStream ous;

private javax.swing.JLabel la_image=new javax.swing.JLabel();

public void showUI(){

javax.swing.JFrame frame=new javax.swing.JFrame("远程控制");

frame.setSize(800,600);

frame.setResizable(false);

la_image.setSize(800, 600);

JLayeredPane jlp = new JLayeredPane();

jlp.add(la_image);

frame.setLayeredPane(jlp);

frame.setVisible(true);

frame.setDefaultCloseOperation(3);

frame.setAlwaysOnTop(true);

frame.addKeyListener(new KeyAdapter(){

public void keyPressed(KeyEvent e) {

sendEventObject(e);

}

@Override

public void keyReleased(KeyEvent e) {

sendEventObject(e);

}

@Override

public void keyTyped(KeyEvent e) {

}

});

frame.addMouseWheelListener(new MouseWheelListener(){

public void mouseWheelMoved(MouseWheelEvent e) {

sendEventObject(e);

}

});

frame.addMouseMotionListener(new MouseMotionListener(){

public void mouseDragged(MouseEvent e) {

sendEventObject(e);

}

public void mouseMoved(MouseEvent e) {

sendEventObject(e);

}

});

frame.addMouseListener(new MouseListener(){

public void mouseClicked(MouseEvent e) {

sendEventObject(e);

}

public void mouseEntered(MouseEvent e) {

sendEventObject(e);

}

public void mouseExited(MouseEvent e) {

sendEventObject(e);

}

public void mousePressed(MouseEvent e) {

sendEventObject(e);

}

public void mouseReleased(MouseEvent e) {

sendEventObject(e);

}

});

}

private void conn2Server(String ip,int port)

throws MyException,Exception{

java.net.Socket sc=new java.net.Socket(ip,port);

dins=newDataInputStream(sc.getInputStream());

ous=newObjectOutputStream(sc.getOutputStream());

if(dins==null||ous==null)throw newMyException("远程控制不接受或未接受被控制。。。");

}

//发送事件对象到被控制端

private void sendEventObject(java.awt.event.InputEvent event){

try{

ous.writeObject(event);

}catch(Exception ef){

ef.printStackTrace();

}

}

public void run(){

try{

while(true){

int len=dins.readInt();

byte[] data=new byte[len];

dins.readFully(data);

ByteArrayInputStream bins=newByteArrayInputStream(data);

BufferedImage image= ImageIO.read(bins);

javax.swing.ImageIcon ic=new ImageIcon(image);

Image img = ic.getImage();

Toolkit tk = Toolkit.getDefaultToolkit() ;

Dimension d =tk.getScreenSize();

int w = d.width;

int h =d.height;

BufferedImage bi = resize(img,800,600);

la_image.setIcon(new ImageIcon(bi));

la_image.repaint();//销掉以前画的背景

}

}catch(Exception ef){

System.out.println("网络故障：无法读出远程图片数据。。。");

ef.printStackTrace();

}

}

private static BufferedImage resize(Image img, int newW, intnewH) {

int w = img.getWidth(null);

int h = img.getHeight(null);

BufferedImage dimg = new BufferedImage(newW, newH,BufferedImage.TYPE_INT_BGR);

Graphics2D g = dimg.createGraphics();

g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

RenderingHints.VALUE_INTERPOLATION_BILINEAR);

g.drawImage(img, 0, 0, newW, newH, 0, 0, w, h, null);

g.dispose();

return dimg;

}

public static void main(String[] args)

throws Exception{

}

public static void connect(String ip,intport) throws Exception{

ClientDealObject ct=newClientDealObject();

ct.showUI();

ct.conn2Server(ip,port);

ct.start();

}

}

package com.zzw.client;

import javax.swing.JOptionPane;

public class MyException extends RuntimeException {

public String info= "";

public MyException(String info){

this.info = info;

System.out .println(info);

JOptionPane.showMessageDialog (null, this.info,"提示 ",JOptionPane.ERROR_MESSAGE );

}

}

 

 

梦之幻时尚睡衣纺 http://shop.paipai.com/442560143

远程控制（RemoteControl ）的被控制端

在被控制端用两个线程分别处理事件的回放与画面数据的发送功能。每隔1000/20 秒，远端向控制端发送一个画面。同时不断用事件处理线程对控制端事件的回放处理。

被控制端代码（在包com.zzw.server里有四个类，代码分别如下）

 

package com.zzw.server;

importjava.awt.FlowLayout;

import java.awt.event.KeyAdapter;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

importjava.io.DataOutputStream;

importjava.io.IOException;

importjava.io.ObjectInputStream;

importjava.net.InetAddress;

importjava.net.UnknownHostException;

importjavax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

importjavax.swing.JLayeredPane;

importjavax.swing.JOptionPane;

importjavax.swing.JTextField;

import com.zzw.client.MyException;

/**

* @author Administrator

*/

public class RemoteServer extends JFrame{

//启动服务器

static ScreenThread ct=null;

static RobotThread rt= null;

static RemoteServer rs= null;

static java.net.Socket client= null;

static java.net.ServerSocket sc= null;

static java.io.InputStream ins = null;

static java.io.ObjectInputStream oins = null;

static java.io.OutputStream ous = null;

static java.io.DataOutputStream dous= null;

public void setupServer(int port)

throws MyException,Exception{

sc = new java.net.ServerSocket(port);

JOptionPane.showMessageDialog(null, "允许被控！！","提示",JOptionPane.INFORMATION_MESSAGE);

// while(true){

client = sc.accept();

ins =client.getInputStream();

// 对象输入流，读取事件对象

oins=newObjectInputStream(ins);

ous =client.getOutputStream();

//数据输出流，用以发送图片数据 1个int图片数据长度 图片的字节

dous = new DataOutputStream(ous);

//启动二个处理线程

if(ins==null||oins==null||ous==null||dous==null)thrownew MyException("控制客户端已关闭连接");

try{

ct = new ScreenThread(dous,this);

ct.start();

rt = newRobotThread(oins,this);

rt.start();

}catch(Exception e){

destroy();

}

// }

}

/**

* @param args

*/

public static void main(String[] args)

throws Exception{

}

public static void accept(int port)throws Exception{

rs = new RemoteServer();

rs.setupServer(port);

}

public void destroy(){

RemoteServer.deconnect();

}

public static void deconnect(){

if(ins!=null){

try {

ins.close();

} catch (IOException e) {

e.printStackTrace();

}

}

if(oins!=null){

try {

oins.close();

} catch (IOException e) {

e.printStackTrace();

}

}

if(sc!=null){

try {

sc.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

/////

package com.zzw.server;

import java.awt.Dimension;

import java.awt.Image;

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.event.MouseWheelEvent;

import java.io.ObjectInputStream;

//读取控制端发来的事件对象，并进行回放线程

public class RobotThread extends Thread{

publicRemoteServer rs = null;

private java.io.ObjectInputStream oins;

public RobotThread(ObjectInputStream oins,RemoteServer rs){

this.oins=oins;

this.rs = rs;

}

// public void destroy(){

// if(rs!=null)rs = null;

// if(oins!=null)oins= null;

// }

public void run(){

try{

while(true){

//读取一个事件对象

Object event=oins.readObject();

java.awt.event.InputEvent e=(InputEvent)event;

//处理这个事件

actionEvent(e);

}

}catch(Exception ef){

rs.destroy();

// ef.printStackTrace();

}

}

//回放事件的方法

public voidactionEvent(InputEvent event)throws Exception{

Robot robot =new Robot();

Toolkit tk = Toolkit.getDefaultToolkit();

Dimension d = tk.getScreenSize();

int sw = 800;

int sh = 600;

int w =(int)d.getWidth();

int h =(int) d.getHeight();

int x,y;

MouseEvent mevent=null;//Mouse事件

MouseWheelEventmwevent=null;//Mouse滚轮事件

KeyEventkevent=null; //按键事件

intmousebuttonmask=-100;

//根据事件ＩＤ判断为何种事件

switch(event.getID()){

case MouseEvent.MOUSE_MOVED://Mouse移动事件

mevent=(MouseEvent)event;

x =w*mevent.getX()/800;

y =h*(mevent.getY()-30)/(600-30);

robot.mouseMove(x,y);

break;

caseMouseEvent.MOUSE_PRESSED : //Mouse按键按下事件

mevent = ( MouseEvent ) event;

mousebuttonmask = getMouseClick( mevent.getButton() );

robot.mousePress(mousebuttonmask);

break;

caseMouseEvent.MOUSE_RELEASED://Mouse按键放开事件

mevent=(MouseEvent)event;

mousebuttonmask =getMouseClick( mevent.getButton() );

robot.mouseRelease(mousebuttonmask);

break;

caseMouseEvent.MOUSE_WHEEL: //Mouse滚动事件

mwevent=(MouseWheelEvent)event;

robot.mouseWheel(mwevent.getWheelRotation());

break;

caseMouseEvent.MOUSE_DRAGGED: //Mouse拖动事件

mevent=(MouseEvent)event;

x =w*mevent.getX()/800;

y =h*(mevent.getY()-30)/(600-30);

robot.mouseMove(x,y);

break;

case KeyEvent.KEY_PRESSED://按键按下事件

kevent=(KeyEvent)event;

robot.keyPress(kevent.getKeyCode());

break;

caseKeyEvent.KEY_RELEASED://按键放开事件

kevent=(KeyEvent)event;

robot.keyRelease(kevent.getKeyCode());

break;

default:

System.out.println("unknowevent:"+event.getID());

break;

}

}

//根据发送事的Mouse事件对象，转变为通用的Mouse按键代码

private int getMouseClick(int button){

if(button==MouseEvent.BUTTON1){

returnInputEvent.BUTTON1_MASK;

}if(button==MouseEvent.BUTTON2){

return InputEvent.BUTTON2_MASK;

} if(button==MouseEvent.BUTTON3){

return InputEvent.BUTTON3_MASK;

}

return -1;

}

}

//////

package com.zzw.server;

import java.awt.Color;

import java.awt.Desktop;

import java.awt.Graphics;

import java.awt.Rectangle;

import java.awt.SplashScreen;

import java.awt.Toolkit;

import java.awt.image.BufferedImage;

import java.io.ByteArrayOutputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.net.SocketException;

import com.zzw.client.MyException;

// 发送屏幕图的线程

public class ScreenThread extends Thread {

public RemoteServer rs = null;

private java.io.DataOutputStream dous;

public ScreenThread(DataOutputStreamdous,RemoteServer rs){

this.dous=dous;

this.rs = rs;

}

public void run(){

//截图，发送

try{

while(true){

byte[] data=createImage();

//发送 :

//1.先写一个 int , 代表图片数据长度

dous.writeInt(data.length);

//2.写入图片字节数据

dous.write(data);

dous.flush();

Thread.sleep (1000/20);

}

}catch(SocketExceptionef){

// ef.printStackTrace();

rs.destroy();

throw new MyException("客户端 SOCKET 已断开连接，无法发送图片信息。。 ");

} catch(InterruptedException e) {

// TODO Auto-generated catch block

rs.destroy();

thrownew MyException("客户端已中断连接，无法发送图片信息。。 ");

} catch (IOException e) {

// TODO Auto-generated catch block

rs.destroy();

throw new MyException("客户端输入输出流中断，无法发送图片信息。。 ");

} catch (Exception e) {

// TODO Auto-generated catch block

rs.destroy();

throw new MyException("客户端已断开连接，无法发送图片信息。。 ");

}

}

//取得一张屏幕图片 , 转成字节数组返回

private byte[] createImage()throwsException{

java.awt.Robot robot=newjava.awt.Robot();

java.awt.Toolkittk=java.awt.Toolkit.getDefaultToolkit ();

java.awt.Dimension dm=tk.getScreenSize();

//设定区域的大小

Rectangle rt=new Rectangle(0,0,dm.width,dm.height);

//取得指定大小的一张图片

BufferedImageimage=robot.createScreenCapture(rt);

//创建一段内存流

java.io.ByteArrayOutputStreamtemB=newByteArrayOutputStream();

//将图片数据写入内存流中

javax.imageio.ImageIO.write (image,"jpeg", temB);

//做为字节数组返回

byte[] data=temB.toByteArray();

return data;

}

}

package com.zzw.server;

importjava.awt.FlowLayout;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.net.InetAddress;

import java.net.UnknownHostException;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JLayeredPane;

importjavax.swing.JOptionPane;

importjavax.swing.JTextField;

import com.zzw.client.MyException;

public class Server extends JFrame {

JButton jb1 = newJButton("接受被控");

JButton jb2 = newJButton("断开被控");

JTextField jtf = newJTextField("8888");

public void launch(){

this.setTitle("远程端-IP："+getLocalIP());

this.setLocation(300, 200);

this.setSize(300, 80);

this.setAlwaysOnTop(true);

this.setResizable(false);

JLayeredPane jlp= new JLayeredPane();

jlp.setLayout(new FlowLayout());

jlp.add(new JLabel("端口："));

jlp.add(jtf);

jlp.add(jb1);

jb1.addMouseListener(new MouseAdapter(){

@Override

public void mouseClicked(MouseEvent e) {

try {

RemoteServer.accept(Integer.parseInt(jtf.getText().trim()));

} catch (NumberFormatException e1){

//

// e1.printStackTrace();

} catch (MyException e1) {

//

JOptionPane.showMessageDialog(null,e1.info,"提示",JOptionPane.ERROR_MESSAGE);

}catch (Exception ed) {

//

// ed.printStackTrace();

}

}

});

jlp.add(jb2);

jb2.addMouseListener(new MouseAdapter(){

@Override

public void mouseClicked(MouseEvent e) {

JOptionPane.showMessageDialog(null,"断开被控服务端窗口","提示",JOptionPane.INFORMATION_MESSAGE);

ScreenThread st =RemoteServer.rs.ct;

RobotThread rt =RemoteServer.rs.rt;

if(st!=null)st.destroy();

if(rt!=null)rt.destroy();

RemoteServer.deconnect();

System.exit(0);

}

});

this.setLayeredPane(jlp);

this.setDefaultCloseOperation(3);

this.setVisible(true);

}

public static void main(String arg[]){

new Server().launch();

}

public String getLocalIP(){

String ipstr = "";

InetAddress ip = null;

try {

ip = InetAddress.getLocalHost();

} catch (UnknownHostException e) {

//

throw new MyException("主机号没找到。。");

}

ipstr = ip.toString();

ipstr =ipstr.substring(ipstr.indexOf("/")+1);

System.out.println(ipstr);

return ipstr;

}

}

---------------developed it in the year of 2010 by zzw--仅供学习使用--------------------------------------------------

 

时尚睡衣纺欢迎你http://shop.paipai.com/442560143