Java鼠标在屏幕上的任意位置移动

我相信这是可能的，但我所有的搜索都是空白的

在Java中，是否可以在Java应用程序之外注册鼠标运动事件？因此，如果鼠标指针在屏幕上的任何位置移动，我会收到一个回电。轮询

MouseInfo.getPointerInfo

可以实现近似，但必须有更好的方法

谢谢

要解释用例，请执行以下操作：

---

这只是一个宠物项目，但基本上是在鼠标点击屏幕边缘时触发事件。我还认为，如果你试图突破屏幕边缘，可能会引发不同的事件。为此，我认为鼠标运动监听器可能更合适。

java.awt.event.MouseMotionListener

只会提供有关应用程序窗口中鼠标运动的信息。对于在该窗口之外发生的事件，无法绕过

MouseInfo.getPointerInfo

。但是，您可以编写一个（可能是单例）类，定期轮询指针信息，并允许添加

MouseMotionListeners

：

import java.awt.Component;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.util.HashSet;
import java.util.Set;

import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

/**
 * This class checks the position every #DELAY milliseconds and 
 * informs all registered MouseMotionListeners about position updates.
 */
public class MouseObserver {
    /* the resolution of the mouse motion */
    private static final int DELAY = 10;

    private Component component;
    private Timer timer;
    private Set<MouseMotionListener> mouseMotionListeners;

    protected MouseObserver(Component component) {
        if (component == null) {
            throw new IllegalArgumentException("Null component not allowed.");
        }

        this.component = component;

        /* poll mouse coordinates at the given rate */
        timer = new Timer(DELAY, new ActionListener() {
                private Point lastPoint = MouseInfo.getPointerInfo().getLocation();

                /* called every DELAY milliseconds to fetch the
                 * current mouse coordinates */
                public synchronized void actionPerformed(ActionEvent e) {
                    Point point = MouseInfo.getPointerInfo().getLocation();

                    if (!point.equals(lastPoint)) {
                        fireMouseMotionEvent(point);
                    }

                    lastPoint = point;
                }
            });
        mouseMotionListeners = new HashSet<MouseMotionListener>();
    }

    public Component getComponent() {
        return component;
    }

    public void start() {
        timer.start();
    }

    public void stop() {
        timer.stop();
    }

    public void addMouseMotionListener(MouseMotionListener listener) {
        synchronized (mouseMotionListeners) {
            mouseMotionListeners.add(listener);
        }
    }

    public void removeMouseMotionListener(MouseMotionListener listener) {
        synchronized (mouseMotionListeners) {
            mouseMotionListeners.remove(listener);
        }
    }

    protected void fireMouseMotionEvent(Point point) {
        synchronized (mouseMotionListeners) {
            for (final MouseMotionListener listener : mouseMotionListeners) {
                final MouseEvent event =
                    new MouseEvent(component, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(),
                                   0, point.x, point.y, 0, false);

                SwingUtilities.invokeLater(new Runnable() {
                        public void run() {
                            listener.mouseMoved(event);
                        }
                    });
            }
        }
    }

    /* Testing the ovserver */
    public static void main(String[] args) {
        JFrame main = new JFrame("dummy...");
        main.setSize(100,100);
        main.setVisible(true);

        MouseObserver mo = new MouseObserver(main);
        mo.addMouseMotionListener(new MouseMotionListener() {
                public void mouseMoved(MouseEvent e) {
                    System.out.println("mouse moved: " + e.getPoint());
                }

                public void mouseDragged(MouseEvent e) {
                    System.out.println("mouse dragged: " + e.getPoint());
                }
            });

        mo.start();
    }
}

导入java.awt.Component；
导入java.awt.MouseInfo；
导入java.awt.Point；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.event.MouseEvent；
导入java.awt.event.MouseMotionListener；
导入java.util.HashSet；
导入java.util.Set；
导入javax.swing.JFrame；
导入javax.swing.SwingUtilities；
导入javax.swing.Timer；
/**
*此类每隔#延迟毫秒和秒检查一次位置
*通知所有已注册的MouseMotionListeners位置更新。
*/
公共类鼠标观察服务器{
/*鼠标运动的分辨率*/
专用静态最终整数延迟=10；
私有组件；
私人定时器；
私有设置mouseMotionListeners；
受保护的MouseObserver（组件）{
如果（组件==null）{
抛出新的IllegalArgumentException（“不允许使用Null组件”）；
}
这个组件=组件；
/*以给定速率轮询鼠标坐标*/
计时器=新计时器（延迟，新ActionListener（）{
私有点lastPoint=MouseInfo.getPointerInfo（）.getLocation（）；
/*每延迟毫秒调用一次以获取
*当前鼠标坐标*/
已执行的公共同步作废操作（ActionEvent e）{
Point Point=MouseInfo.getPointerInfo（）.getLocation（）；
如果（！point.equals（lastPoint））{
fireMouseMotionEvent（点）；
}
最后一点=点；
}
});
mouseMotionListeners=newhashset（）；
}
公共组件getComponent（）{
返回组件；
}
公开作废开始（）{
timer.start（）；
}
公共停车场（）{
timer.stop（）；
}
public void addMouseMotionListener（MouseMotionListener侦听器）{
已同步（mouseMotionListeners）{
添加（监听器）；
}
}
public void removeMouseMotionListener（MouseMotionListener listener）{
已同步（mouseMotionListeners）{
mouseMotionListeners.remove（监听器）；
}
}
受保护的void fireMouseMotionEvent（点）{
已同步（mouseMotionListeners）{
for（最终的MouseMotionListener侦听器：mouseMotionListeners）{
最后的MouseeEvent事件=
新的MouseEvent（组件，MouseEvent.MOUSE_，System.currentTimeMillis（），
0，点x，点y，0，假）；
SwingUtilities.invokeLater（新的Runnable（）{
公开募捐{
mouseMoved（事件）；
}
});
}
}
}
/*测试ovserver*/
公共静态void main（字符串[]args）{
JFrame main=新JFrame（“虚拟…”）；
主设置尺寸（100100）；
main.setVisible（true）；
MouseObserver mo=新的MouseObserver（主）；
mo.addMouseMotionListener（新的MouseMotionListener（）{
public void mouseMoved（MouseEvent e）{
System.out.println（“鼠标移动：+e.getPoint（））；
}
公共无效鼠标标记（鼠标事件e）{
println（“鼠标拖动：+e.getPoint（））；
}
});
mo.start（）；
}
}

不过，请注意，与标准的MouseMotionListener有一些显著的区别：

• 您将只接收

  mousemoded

  事件，而不会接收

  mouseDragged

  事件。这是因为无法在主窗口外接收有关单击的信息
• 出于类似原因，每个

  MouseEvent

  的

  修饰符将始终为0

• 值

  点击计数

  ，

  弹出触发器

  ，

  按钮

• 您需要提供一个虚拟

  java.awt.Component

  ，该组件将用作

  MouseEvent

  s的（假）源，此处不允许使用

  null

  值

---

我认为没有更好的办法。这必须是独立于操作系统的，我怀疑这是很容易做到的。但是，如果定期轮询MouseInfo.getPointerInfo方法，会有什么问题？你的用例是什么？