java实现鼠标和键盘动作后台监听

最新推荐文章于 2024-07-28 04:03:29 发布
最新推荐文章于 2024-07-28 04:03:29 发布
阅读量1.2w 收藏 17
点赞数 2
分类专栏： javaFX

有的时候需要我们对鼠标和键盘的动作（鼠标的移动，键盘的点击）进行监听，比如按键记录，鼠标坐标记录等。

我们使用JNA来实现以上的操作

 tips：JNA类库使用一个很小的本地类库sub 动态的调用本地代码。程序员只需要使用一个特定的java接口描述一下将要调用的本地代码的方法的结构和一些基本属性。这样就省了为了适配多个平台而大量的配置和编译代码。因为调用的都是JNA提供的公用jar 包中的接口。

首先我们实现监听鼠标的代码如下

[java]  view plain  copy
  1. package getInfo;  
  2.   
  3. import java.io.BufferedWriter;  
  4. import java.io.File;  
  5. import java.io.FileWriter;  
  6. import java.io.IOException;  
  7. import java.text.SimpleDateFormat;  
  8. import java.util.Date;  
  9.   
  10. import com.sun.jna.Structure;  
  11. import com.sun.jna.examples.win32.Kernel32;  
  12. import com.sun.jna.examples.win32.User32;  
  13. import com.sun.jna.examples.win32.User32.HHOOK;  
  14. import com.sun.jna.examples.win32.User32.MSG;  
  15. import com.sun.jna.examples.win32.W32API.HMODULE;  
  16. import com.sun.jna.examples.win32.W32API.LRESULT;  
  17. import com.sun.jna.examples.win32.W32API.WPARAM;  
  18. import com.sun.jna.examples.win32.User32.HOOKPROC;  
  19.   
  20. public class MouseHook implements Runnable{  
  21.       
  22.     public static final int WM_MOUSEMOVE = 512;  
  23.     private static HHOOK hhk;  
  24.     private static LowLevelMouseProc mouseHook;  
  25.     final static User32 lib = User32.INSTANCE;  
  26.     private boolean [] on_off=null;  
  27.   
  28.     public MouseHook(boolean [] on_off){  
  29.         this.on_off = on_off;  
  30.     }  
  31.   
  32.     public interface LowLevelMouseProc extends HOOKPROC {  
  33.         LRESULT callback(int nCode, WPARAM wParam, MOUSEHOOKSTRUCT lParam);  
  34.     }  
  35.   
  36.     public static class MOUSEHOOKSTRUCT extends Structure {  
  37.         public static class ByReference extends MOUSEHOOKSTRUCT implements  
  38.         Structure.ByReference {  
  39.         };  
  40.         public User32.POINT pt;  
  41.         public int wHitTestCode;  
  42.         public User32.ULONG_PTR dwExtraInfo;  
  43.     }  
  44.   
  45.     public void run() {  
  46.         HMODULE hMod = Kernel32.INSTANCE.GetModuleHandle(null);  
  47.         mouseHook = new LowLevelMouseProc() {  
  48.             public LRESULT callback(int nCode, WPARAM wParam,  
  49.                     MOUSEHOOKSTRUCT info) {  
  50.                 SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");  
  51.                 SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  52.                 String fileName=df1.format(new Date());  
  53.                 String time=df2.format(new Date());  
  54.                 BufferedWriter bw1=null;  
  55.                 BufferedWriter bw2=null;  
  56.                 try {  
  57.                     bw1=new BufferedWriter(new FileWriter(new File(".//log//"+fileName+"_Mouse.txt"),true));  
  58.                     bw2=new BufferedWriter(new FileWriter(new File(".//log//"+fileName+"_Common.txt"),true));  
  59.                 } catch (IOException e) {  
  60.                     e.printStackTrace();  
  61.                 }  
  62.                 if (on_off[0] == false) {  
  63.                     System.exit(0);  
  64.                 }  
  65.                 if (nCode >= 0) {  
  66.                     switch (wParam.intValue()) {  
  67.                     case MouseHook.WM_MOUSEMOVE:  
  68.                         try {  
  69.                             bw1.write(time+"  ####  "+"x=" + info.pt.x  
  70.                                     + " y=" + info.pt.y+"\r\n");  
  71.                             bw2.write(time+"  ####  "+"x=" + info.pt.x  
  72.                                     + " y=" + info.pt.y+"\r\n");  
  73.                             bw1.flush();  
  74.                             bw2.flush();  
  75.                         } catch (IOException e) {  
  76.                             e.printStackTrace();  
  77.                         }  
  78.                     }  
  79.                 }  
  80.                 return lib  
  81.                 .CallNextHookEx(hhk, nCode, wParam, info.getPointer());  
  82.             }  
  83.         };  
  84.         hhk = lib.SetWindowsHookEx(User32.WH_MOUSE_LL, mouseHook, hMod, 0);  
  85.         int result;  
  86.         MSG msg = new MSG();  
  87.         while ((result = lib.GetMessage(msg, null, 0, 0)) != 0) {  
  88.             if (result == -1) {  
  89.                 System.err.println("error in get message");  
  90.                 break;  
  91.             } else {  
  92.                 System.err.println("got message");  
  93.                 lib.TranslateMessage(msg);  
  94.                 lib.DispatchMessage(msg);  
  95.             }  
  96.         }  
  97.         lib.UnhookWindowsHookEx(hhk);  
  98.     }  
  99. }  
能够在鼠标移动的时候输出鼠标的坐标位置

接下来是监听键盘的代码

[java]  view plain  copy
  1. package getInfo;  
  2.   
  3. import java.io.BufferedWriter;  
  4. import java.io.File;  
  5. import java.io.FileWriter;  
  6. import java.io.IOException;  
  7. import java.text.SimpleDateFormat;  
  8. import java.util.Date;  
  9.   
  10. import com.sun.jna.examples.win32.Kernel32;  
  11. import com.sun.jna.examples.win32.User32;  
  12. import com.sun.jna.examples.win32.User32.HHOOK;  
  13. import com.sun.jna.examples.win32.User32.KBDLLHOOKSTRUCT;  
  14. import com.sun.jna.examples.win32.User32.LowLevelKeyboardProc;  
  15. import com.sun.jna.examples.win32.User32.MSG;  
  16. import com.sun.jna.examples.win32.W32API.HMODULE;  
  17. import com.sun.jna.examples.win32.W32API.LRESULT;  
  18. import com.sun.jna.examples.win32.W32API.WPARAM;  
  19.   
  20.   
  21. public class KeyboardHook implements Runnable{  
  22.   
  23.     private static HHOOK hhk;  
  24.     private static LowLevelKeyboardProc keyboardHook;  
  25.     final static User32 lib = User32.INSTANCE;  
  26.     private boolean [] on_off=null;  
  27.   
  28.     public KeyboardHook(boolean [] on_off){  
  29.         this.on_off = on_off;  
  30.     }  
  31.   
  32.     public void run() {  
  33.   
  34.         HMODULE hMod = Kernel32.INSTANCE.GetModuleHandle(null);  
  35.         keyboardHook = new LowLevelKeyboardProc() {  
  36.             public LRESULT callback(int nCode, WPARAM wParam, KBDLLHOOKSTRUCT info) {  
  37.                 SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");  
  38.                 SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  39.                 String fileName=df1.format(new Date());  
  40.                 String time=df2.format(new Date());  
  41.                 BufferedWriter bw1=null;  
  42.                 BufferedWriter bw2=null;  
  43.                 try {  
  44.                     bw1=new BufferedWriter(new FileWriter(new File(".//log//"+fileName+"_Keyboard.txt"),true));  
  45.                     bw2=new BufferedWriter(new FileWriter(new File(".//log//"+fileName+"_Common.txt"),true));  
  46.                   
  47.                 } catch (IOException e) {  
  48.                     e.printStackTrace();  
  49.                 }  
  50.                 if (on_off[0] == false) {  
  51.                     System.exit(0);  
  52.                 }  
  53.                 try {  
  54.                     bw1.write(time+"  ####  "+info.vkCode+"\r\n");  
  55.                     bw2.write(time+"  ####  "+info.vkCode+"\r\n");  
  56.                     bw1.flush();  
  57.                     bw2.flush();  
  58.                 } catch (IOException e) {  
  59.                     e.printStackTrace();  
  60.                 }  
  61.                 return lib.CallNextHookEx(hhk, nCode, wParam, info.getPointer());  
  62.             }  
  63.         };  
  64.         hhk = lib.SetWindowsHookEx(User32.WH_KEYBOARD_LL, keyboardHook, hMod, 0);  
  65.         int result;  
  66.         MSG msg = new MSG();  
  67.         while ((result = lib.GetMessage(msg, null, 0, 0)) != 0) {  
  68.             if (result == -1) {  
  69.                 System.err.println("error in get message");  
  70.                 break;  
  71.             } else {  
  72.                 System.err.println("got message");  
  73.                 lib.TranslateMessage(msg);  
  74.                 lib.DispatchMessage(msg);  
  75.             }  
  76.         }  
  77.         lib.UnhookWindowsHookEx(hhk);  
  78.     }  
  79.   
  80. }  

最后是获取进程信息的代码

[java]  view plain  copy
  1. package getInfo;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.BufferedWriter;  
  5. import java.io.File;  
  6. import java.io.FileWriter;  
  7. import java.io.IOException;  
  8. import java.io.InputStreamReader;  
  9. import java.text.SimpleDateFormat;  
  10. import java.util.Date;  
  11.   
  12. public class ProcessInfo implements Runnable{  
  13.   
  14.     private boolean [] on_off=null;  
  15.   
  16.     public ProcessInfo(boolean [] on_off){  
  17.         this.on_off = on_off;  
  18.     }  
  19.   
  20.     public void run() {  
  21.         BufferedReader input = null;  
  22.         Process process = null;  
  23.         BufferedWriter bw=null;  
  24.         SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");  
  25.         SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  26.         String fileName=null;  
  27.         String time=null;  
  28.         try {  
  29.             while(on_off[0]){  
  30.                 fileName=df1.format(new Date());  
  31.                 time=df2.format(new Date());  
  32.                 bw=new BufferedWriter(new FileWriter(new File(".//log//"+fileName+"_ProcessInfo.txt"),true));  
  33.                 Thread.sleep(60000);  
  34.                 process = Runtime.getRuntime().exec("cmd.exe   /c   tasklist");  
  35.                 input =new BufferedReader(  
  36.                         new InputStreamReader(process.getInputStream()));  
  37.                 String line = " ";  
  38.                 int i=0;  
  39.                 input.readLine();  
  40.                 input.readLine();  
  41.                 input.readLine();  
  42.                 while ((line = input.readLine()) != null) {  
  43.                     bw.write(time+"  ####  "+line+"\r\n");  
  44.                     bw.flush();  
  45.                     i++;  
  46.                 }  
  47.             }  
  48.         } catch (Exception e) {  
  49.             e.printStackTrace();  
  50.         } finally{  
  51.             try {  
  52.                 bw.close();  
  53.                 input.close();  
  54.             } catch (IOException e) {  
  55.                 e.printStackTrace();  
  56.             }  
  57.         }  
  58.     }  
  59.   
  60. }  

开启上述线程的类

[java]  view plain  copy
  1. package getInfo;  
  2.   
  3. import java.awt.AWTException;    
  4. import java.awt.Image;    
  5. import java.awt.MenuItem;    
  6. import java.awt.PopupMenu;    
  7. import java.awt.SystemTray;    
  8. import java.awt.Toolkit;    
  9. import java.awt.TrayIcon;    
  10. import java.awt.event.ActionEvent;    
  11. import java.awt.event.ActionListener;    
  12.   
  13. public class Monitor  {    
  14.   
  15.     public Monitor()  {    
  16.         boolean [] on_off={true};  
  17.         new Thread(new ProcessInfo(on_off)).start();  
  18.         new Thread(new KeyboardHook(on_off)).start();  
  19.         new Thread(new MouseHook(on_off)).start();  
  20.         final TrayIcon trayIcon;    
  21.   
  22.         if (SystemTray.isSupported()) {    
  23.   
  24.             SystemTray tray = SystemTray.getSystemTray();    
  25.             Image image = Toolkit.getDefaultToolkit().getImage(".//lib//monitor.png");    
  26.   
  27.             ActionListener exitListener = new ActionListener() {    
  28.                 public void actionPerformed(ActionEvent e) {    
  29.                     System.out.println("Exiting...");    
  30.                     System.exit(0);    
  31.                 }  
  32.             };    
  33.   
  34.             PopupMenu popup = new PopupMenu();    
  35.             MenuItem defaultItem = new MenuItem("Exit");    
  36.             defaultItem.addActionListener(exitListener);    
  37.             popup.add(defaultItem);    
  38.   
  39.             trayIcon = new TrayIcon(image, "monitor", popup);    
  40.   
  41.             ActionListener actionListener = new ActionListener() {    
  42.                 public void actionPerformed(ActionEvent e) {    
  43.                     trayIcon.displayMessage("Action Event",     
  44.                             "An Action Event Has Been Peformed!",    
  45.                             TrayIcon.MessageType.INFO);    
  46.                 }    
  47.             };    
  48.   
  49.             trayIcon.setImageAutoSize(true);    
  50.             trayIcon.addActionListener(actionListener);    
  51.   
  52.             try {    
  53.                 tray.add(trayIcon);    
  54.             } catch (AWTException e1) {    
  55.                 e1.printStackTrace();    
  56.             }    
  57.   
  58.         }   
  59.     }  
  60.       
  61.     public static void main(String[] args)  {    
  62.         new Monitor();    
  63.     }    
  64.   
  65. }    


上面是一个鼠标监听的日志文件

程序员会武功
关注
专栏目录
java完成键盘动作_java实现鼠标和键盘动作后台监听
weixin_33692177的博客
02-26 557
有的时候需要我们对鼠标和键盘的动作(鼠标的移动，键盘的点击)进行监听，比如按键记录，鼠标坐标记录等。我们使用JNA来实现以上的操作tips：JNA类库使用一个很小的本地类库sub 动态的调用本地代码。程序员只需要使用一个特定的java接口描述一下将要调用的本地代码的方法的结构和一些基本属性。这样就省了为了适配多个平台而大量的配置和编译代码。因为调用的都是JNA提供的公用jar 包中的接口。首先我们...
java实现鼠标和键盘动作后台监听(未测试)
程序员_007的博客
07-22 4481
有的时候需要我们对鼠标和键盘的动作（鼠标的移动，键盘的点击）进行监听，比如按键记录，鼠标坐标记录等。 我们使用JNA来实现以上的操作  tips：JNA类库使用一个很小的本地类库sub 动态的调用本地代码。程序员只需要使用一个特定的java接口描述一下将要调用的本地代码的方法的结构和一些基本属性。这样就省了为了适配多个平台而大量的配置和编译代码。因为调用的都是JNA提供的公用jar 包中的接口
javabus吧回家路
weixin_40892593的博客
07-28 3044
Javabus吧回家路：新手开发者的入门指南 作为一名刚入行的开发者，你可能对如何实现一个简单的Java应用程序感到困惑。本文将通过一个名为“Javabus吧回家路”的示例，帮助你理解整个开发流程，并提供详细的代码示例和注释。 开发流程概览 首先，让我们通过一个表格来概览整个开发流程： 步骤 描述 1 设计应...
使用Java实现全局键盘和鼠标监听
wr456wr的博客
03-10 5319
普通的Java Swing组件都是必须要在java程序内才能监听到键盘和鼠标事件，全局鼠标键盘监听可以不必在java程序焦点下对键盘和鼠标进行监听
java实现后台键盘监听所需依赖.zip
04-13
1.java用jintellitype实现后台键盘监听时需要的JIntellitype.dll、JIntellitype64.dll、jintellitype-...2.java用jna实现后台键盘和鼠标监听时需要的jna.jar、platform.jar文件(这两个文件网上找了好久了，亲测有用)
Java监听键盘鼠标全局事件[定义].pdf
10-11
Java监听键盘鼠标全局事件是指使用Java语言来监听和处理键盘和鼠标事件的技术。这项技术广泛应用于游戏开发、自动化测试、屏幕阅读器等领域。下面是Java监听键盘鼠标全局事件的详细知识点： 一、Java Native ...
学生选课和成绩管理系统 基于JAVASWing 键盘鼠标事件监听 JDBC 文件IO流
10-01
在本系统中，Swing被用来创建用户友好的交互界面，包括菜单栏、按钮、文本框等元素，通过键盘和鼠标事件监听，实现了用户操作的实时响应，例如点击“选课”按钮后触发选课操作。 其次，数据库管理是系统的核心部分...
java键盘监听所需依赖jintellitype-1.3.9.zip
12-07
1.jintellitype-1.3.9.jar包，用于Java键盘全局监听，内有JIntellitype.dll、JIntellitype64.dll、jintellitype-1.3.9.jar；...2.java用jna实现后台键盘和鼠标监听时需要的jna.jar、platform.jar文件，亲测有用！
鼠标及键盘监听实现
05-09
该项目代码用于实现鼠标动作及键盘事件的监听。可单独监听鼠标事件或键盘事件。
如何使用 Java 实现后台全局监听快捷键
暗诺星刻的博客
07-02 6606
说起使用 Java 实现快捷键，很多人都能想到，借助 Java 领域的 GUI 技术（如 Java Swing、JavaFX 等）就可以实现快捷键的功能。但是，使用这种方法实现的快捷键有一个致命的缺陷，那就是如果光标焦点离开此 UI 界面，则所有的快捷键都将失效。另外，这些快捷键是依附于一种 UI 界面来运行的，因此将占用额外的资源。这些都是一个很大的限制。本文就来探究一下如何设置一个后台运行的全局快捷键。给出的解决方案必须要让别人知道这个解决方案帮助别人解决了什么问题。
java代码 监听鼠标键盘输入生成日志 重复执行日志
qq_43854669的博客
05-31 510
【代码】java代码 监听鼠标键盘输入生成日志 重复执行日志。
Java实现后台按键事件监听(注册系统级热键)
(Never Give Up)--(我的知识点滴)
08-10 2213
所谓系统级热键就是指一组快捷键，不论当前系统焦点在哪个程序中，只要按下该键，程序就能够捕捉该事件并进行相关处理。该功能在应用程序中是非常有用的，比如系统自带的 “win+L”自动锁屏，QQ中默认的“ctrl+alt+Z”自动打开当前的消息窗口等等。 Java中的事件监听机制虽然功能强大，但是当系统焦点脱离该程序时也无能为力。 Java的最底层是jvm，所以单纯的java不能感知jvm再下面的操作...
java用jintellitype和jna两种方式实现鼠标键盘后台监听
qq_38279833的博客
04-13 2676
点我免费下载依赖的jar文件和dll文件 我的目录结构 依赖jintellitype-1.3.9.jar方式实现 需要一个jar文件和两个c编写dll文件，注意:dll的文件必须放在resources下的com.melloware.jintellitype......
Java中三种监听-鼠标监听-键盘监听-窗口监听
qq_45673892的博客
06-13 430
目的：使用鼠标实现画图功能。
我想用java监听全局监听鼠标的点击事件，我不想使用java的AWT或者是java的Swing包完成...
weixin_35749440的博客
02-09 376
你可以使用 Java Native Interface (JNI) 来监听全局鼠标点击事件。 JNI 允许 Java 程序访问本地代码，你可以使用本地代码来监听鼠标点击事件，然后将事件传递给 Java 程序进行处理。 请注意，实现此功能可能会相当复杂，需要一定的编程知识和经验，而且也可能存在一些安全问题。因此，在实现过程中请务必谨慎。 ...
java全局监听键盘
abjtxf的博客
01-02 1166
本文介绍一种java全局监听键盘的方法
基于Java语言的蓝牙遥控器设计源码，支持键盘、鼠标、影音遥控器
最新发布
10-05
该项目为基于Java语言的蓝牙遥控器设计源码，包含539个文件，涵盖307个Java源文件、120个XML配置文件、34个PNG图片文件、16个Gradle构建文件、12个Git忽略文件、9个文本文件、6个JAR包文件、5个JSON配置文件、5个JPG图片文件。该遥控器支持键盘、鼠标和影音控制功能，适用于多种场合。
后台运行java进行鼠标事件监听
05-09
Robot类可以模拟鼠标和键盘的操作，可以用来实现自动化测试和自动化操作等需求。以下是一个监听鼠标点击事件的示例代码： ```java import java.awt.Robot; import java.awt.event.InputEvent; public class ...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值