个人随笔
目录
Java Robot应用示例之机器人功能
2019-09-11 23:31:18

很多时候，我们希望能够实现自动测试，自动演示功能，或者是其它的一些鼠标和键盘控制的应用（比如帮人点击广告赚利润等）。出于这样的目的，自从JDK1.3开始，它就为我们提供了一个用来产生本机输入事件的机器人类 — java.awt.Robot.　

下面我来详细介绍Robot的功能及应用示例：

一、Robot主要的功能

1. BufferedImage createScreenCapture(Rectangle screenRect)

说明：该方法提供类似于键盘上的PrintScreen键的功能，将指定矩形区域内的屏幕像素copy下来产生一个BufferedImage。
应用：我们可以将这个方法用在图形程序中，或是用它来实现远端屏幕传输，可做成远端电脑监控程序等.

2. void delay(int ms)

说明：用来将当前的程序(thread)休眠(sleep)若干毫秒(ms)。
应用：可用来控制程序的延时。这个一般是必须的，因为你在两次间隔操作中肯定有延时。

3. Color getPixelColor(int x, int y)

说明：取得给定屏幕坐标像素位置的颜色值。
应用：就是取颜色RGB值，就不多说了。

4. void keyPress(int keycode)，void keyRelease(int keycode)

说明：这两个方法的作用一看便知，用来产生指定键的按键按下与抬起动作,相当于Win32 API的keyb_event函数，即模拟键盘操作咯，具体keycode值就是KeyEvent.VK_C、KeyEvent.VK_D、KeyEvent.VK_CONTROL什么的，具体应用时直接看Eclipse提示就知道了。
应用：可用于程序的自动演示、测试等，非常有用。

5. void mouseMove(int x, int y)

说明：将鼠标光标移动到指定的屏幕坐标。
应用：可用于程序的自动演示、测试等，配合其他的方法使用，是不可缺少的。

6. void mousePress(int buttons)，void mouseRelease(int buttons)，void mouseWheel(int wheelAmt)

说明：上面的三种方法，产生指定鼠标按钮的按下，抬起，及滚轮动作，就是模拟鼠标操作咯，具体buttons的值有InputEvent.BUTTON1_MASK（鼠标左键）、InputEvent.BUTTON3_MASK（鼠标右键，如果是双键鼠标,请改用InputEvent.BUTTON2_MASK）等。

应用：一样也可用于程序的自动演示、测试等，配合其他方法使用，很重要。

二、应用实例

我写了两个比较小的应用实例，一个是简单的模拟测试，一个是自动点击广告赚利润的，下面分别演示。

首先编写一些公用的方法Common.java

  1. public class Common { 
  3.   /** 
  4.    * 鼠标单击（左击）,要双击就连续调用 
  5.    * 
  6.    * @param r 
  7.    * @param x 
  8.    *      x坐标位置 
  9.    * @param y 
  10.    *      y坐标位置 
  11.    * @param delay 
  12.    *      该操作后的延迟时间 
  13.    */
  14.   public static void clickLMouse(Robot r, int x, int y, int delay) { 
  15.     r.mouseMove(x, y); 
  16.     r.mousePress(InputEvent.BUTTON1_MASK); 
  17.     r.delay(10); 
  18.     r.mouseRelease(InputEvent.BUTTON1_MASK); 
  19.     r.delay(delay); 
  21.   } 
  23.   /** 
  24.    * 鼠标右击,要双击就连续调用 
  25.    * 
  26.    * @param r 
  27.    * @param x 
  28.    *      x坐标位置 
  29.    * @param y 
  30.    *      y坐标位置 
  31.    * @param delay 
  32.    *      该操作后的延迟时间 
  33.    */
  34.   public static void clickRMouse(Robot r, int x, int y, int delay) { 
  35.     r.mouseMove(x, y); 
  36.     r.mousePress(InputEvent.BUTTON3_MASK); 
  37.     r.delay(10); 
  38.     r.mouseRelease(InputEvent.BUTTON3_MASK); 
  39.     r.delay(delay); 
  41.   } 
  43.   /** 
  44.    * 键盘输入（一次只能输入一个字符） 
  45.    * 
  46.    * @param r 
  47.    * @param ks 
  48.    *      键盘输入的字符数组 
  49.    * @param delay 
  50.    *      输入一个键后的延迟时间 
  51.    */
  52.   public static void pressKeys(Robot r, int[] ks, int delay) { 
  53.     for (int i = 0; i < ks.length; i++) { 
  54.       r.keyPress(ks[i]); 
  55.       r.delay(10); 
  56.       r.keyRelease(ks[i]); 
  57.       r.delay(delay); 
  58.     } 
  59.   } 
  61.   /** 
  62.    * 复制 
  63.    * 
  64.    * @param r 
  65.    * @throws InterruptedException 
  66.    */
  67.   void doCopy(Robot r) throws InterruptedException { 
  68.     Thread.sleep(3000); 
  69.     r.setAutoDelay(200); 
  70.     r.keyPress(KeyEvent.VK_CONTROL); 
  71.     r.keyPress(KeyEvent.VK_C); 
  72.     r.keyRelease(KeyEvent.VK_CONTROL); 
  73.     r.keyRelease(KeyEvent.VK_C); 
  74.   } 
  76.   /** 
  77.    * 粘贴 
  78.    * 
  79.    * @param r 
  80.    * @throws InterruptedException 
  81.    */
  82.   void doParse(Robot r) throws InterruptedException { 
  83.     r.setAutoDelay(500); 
  84.     Thread.sleep(2000); 
  85.     r.mouseMove(300, 300); 
  86.     r.mousePress(InputEvent.BUTTON1_MASK); 
  87.     r.mouseRelease(InputEvent.BUTTON1_MASK); 
  88.     r.keyPress(KeyEvent.VK_CONTROL); 
  89.     r.keyPress(KeyEvent.VK_V); 
  90.     r.keyRelease(KeyEvent.VK_CONTROL); 
  91.     r.keyRelease(KeyEvent.VK_V); 
  92.   } 
  94.   /** 
  95.    * 捕捉全屏慕 
  96.    * 
  97.    * @param r 
  98.    * @return 
  99.    */
  100.   public Icon captureFullScreen(Robot r) { 
  101.     BufferedImage fullScreenImage = r.createScreenCapture(new Rectangle( 
  102.         Toolkit.getDefaultToolkit().getScreenSize())); 
  103.     ImageIcon icon = new ImageIcon(fullScreenImage); 
  104.     return icon; 
  105.   } 
  107.   /** 
  108.    * 捕捉屏幕的一个矫形区域 
  109.    * 
  110.    * @param r 
  111.    * @param x 
  112.    *      x坐标位置 
  113.    * @param y 
  114.    *      y坐标位置 
  115.    * @param width 
  116.    *      矩形的宽 
  117.    * @param height 
  118.    *      矩形的高 
  119.    * @return 
  120.    */
  121.   public Icon capturePartScreen(Robot r, int x, int y, int width, int height) { 
  122.     r.mouseMove(x, y); 
  123.     BufferedImage fullScreenImage = r.createScreenCapture(new Rectangle( 
  124.         width, height)); 
  125.     ImageIcon icon = new ImageIcon(fullScreenImage); 
  126.     return icon; 
  127.   } 
  129. }

1、简单的模拟测试

  1. public class SimpleTest { 
  3.   public static void main(String[] args) throws Exception { 
  5.     final Robot rb = new Robot(); 
  7.     new Thread() { 
  8.       public void run() { 
  9.         rb.delay(2000); // 模拟回车 
  10.         rb.keyPress(KeyEvent.VK_ENTER); 
  11.         rb.keyRelease(KeyEvent.VK_ENTER); 
  12.       } 
  13.     }.start(); 
  15.     rb.delay(3000); 
  17.     // 设置开始菜单的大概位置 
  18.     int x = 40; 
  19.     int y = Toolkit.getDefaultToolkit().getScreenSize().height - 10; // 鼠标移动到开始菜单, 
  20.     rb.mouseMove(x, y); 
  21.     rb.delay(500); 
  23.     // 单击开始菜单 
  24.     Common.clickLMouse(rb, x, y, 500); 
  26.     rb.delay(1000); 
  28.     // 运行CMD命令cmd enter 
  29.     int[] ks = { KeyEvent.VK_C, KeyEvent.VK_M, 
  30.         KeyEvent.VK_D, KeyEvent.VK_ENTER, }; 
  31.     Common.pressKeys(rb, ks, 500); 
  32.     rb.mouseMove(400, 400); 
  33.     rb.delay(500); 
  35.     // 运行DIR命令dir enter 
  36.     ks = new int[] { KeyEvent.VK_D, KeyEvent.VK_I, KeyEvent.VK_R, 
  37.         KeyEvent.VK_ENTER }; 
  38.     Common.pressKeys(rb, ks, 500); 
  39.     rb.delay(1000); 
  41.     // 运行CLS命令cls enter 
  42.     ks = new int[] { KeyEvent.VK_C, KeyEvent.VK_L, KeyEvent.VK_S, 
  43.         KeyEvent.VK_ENTER }; 
  44.     Common.pressKeys(rb, ks, 500); 
  45.     rb.delay(1000); 
  47.     // 运行EXIT命令exit enter 
  48.     ks = new int[] { KeyEvent.VK_E, KeyEvent.VK_X, KeyEvent.VK_I, 
  49.         KeyEvent.VK_T, KeyEvent.VK_ENTER }; 
  50.     Common.pressKeys(rb, ks, 500); 
  51.     rb.delay(1000); 
  53.     // 右键测试 
  54.     x = Toolkit.getDefaultToolkit().getScreenSize().width - 50; 
  55.     Common.clickRMouse(rb, x, y, 500); 
  57.     new Thread() { 
  58.       public void run() { 
  59.         rb.delay(1000); // 回车 
  60.         rb.keyPress(KeyEvent.VK_ENTER); 
  61.         rb.keyRelease(KeyEvent.VK_ENTER); 
  62.       } 
  63.     }.start(); 
  65.     JOptionPane.showMessageDialog(null, "演示完毕!"); 
  66.   } 
  67. }

2. 点击网易广告赚取微薄利润

  1. public class AutoClickAds { 
  3.   private Robot robot; 
  5.   private volatile boolean stop = false; 
  7.   /** Creates a new instance of Main */
  9.   public AutoClickAds() { 
  11.     try { 
  13.       robot = new Robot(); 
  15.     } catch (AWTException ex) { 
  17.       ex.printStackTrace(); 
  19.     } 
  20.   } 
  22.   public void init() { 
  24.     robot.delay(3000); 
  26.     System.out.println("Click Ads start"); 
  28.     // 在新的浏览器窗口或在已有的浏览器窗口打开指定的URL(JDK 1.6以上) 
  29.     Desktop desktop = Desktop.getDesktop(); 
  30.     if (Desktop.isDesktopSupported() && desktop.isSupported(Desktop.Action.BROWSE)) { 
  31.       URI uri = URI.create("http://linwenhua.blog.163.com/"); 
  32.       try { 
  33.         desktop.browse(uri); 
  34.       } catch (IOException e) { 
  35.         // TODO Auto-generated catch block 
  36.         e.printStackTrace(); 
  37.       } 
  38.     } 
  40.     try { 
  41.       run(); 
  42.     } catch (InterruptedException e) { 
  43.       // TODO Auto-generated catch block 
  44.       e.printStackTrace(); 
  45.     } 
  47.     stop(); 
  49.     System.out.println("Click Ads stoped"); 
  51.   } 
  53.   public void run() throws InterruptedException { 
  54.     int count = 1; 
  56.     while (!stop) { 
  57.       robot.delay(8000); 
  59.       int x = 576; 
  60.       int y = 567; 
  61.       Random r = new Random(); 
  63.       Common.clickLMouse(robot, x, y, 3000); 
  65.       // 输入向下箭头，实现翻页 
  66.       int[] ks = { KeyEvent.VK_DOWN }; 
  67.       for (int i = 0; i < 10; i++) 
  68.         Common.pressKeys(robot, ks, 0); 
  70.       int[][] a = { { 500, 103 }, { 500, 163 }, { 500, 223 }, 
  71.           { 500, 283 }, { 500, 343 }, { 500, 403 }, { 500, 463 }, 
  72.           { 500, 523 }, { 500, 583 }, { 500, 643 }, }; 
  73.       int b = r.nextInt(5); 
  74.       x = a[b][0]; 
  75.       y = a[b][1]; 
  77.       Common.clickLMouse(robot, x, y, 1000); 
  79.       // 输入向下箭头，实现翻页 
  80.       for (int i = 0; i < 500; i++) 
  81.         Common.pressKeys(robot, ks, 0); 
  83.       // 输入向下箭头，实现翻页 
  84.       int[] kups = { KeyEvent.VK_UP }; 
  85.       for (int i = 0; i < 3; i++) 
  86.         Common.pressKeys(robot, kups, 0); 
  88.       x = 900; 
  89.       y = 210; 
  90.       Common.clickLMouse(robot, x, y, 3000); 
  92.       x =1090; 
  93.       y =15; 
  94.       Common.clickLMouse(robot, x, y, 3000); 
  96.       x = 900; 
  97.       y = 135; 
  98.       Common.clickLMouse(robot, x, y, 3000); 
  100.       System.out.println("成功点击第" + count + "个广告！"); 
  101.     } 
  103.   } 
  105.   public synchronized void stop() { 
  107.     stop = true; 
  109.   } 
  111.   /** 
  112.    * * @param args the command line arguments 
  113.    * 
  114.    * @throws InterruptedException 
  115.    */
  116.   public static void main(String[] args) throws InterruptedException { 
  118.     AutoClickAds mc = new AutoClickAds(); 
  119.     mc.init(); 
  121.   } 
  122. }
 633

啊！这个可能是世界上最丑的留言输入框功能~


当然，也是最丑的留言列表

有疑问发邮件到 : suibibk@qq.com 侵权立删
Copyright : 个人随笔   备案号 : 粤ICP备18099399号-2