我正在使用一个名为Processing的框架，它基本上是一个Java小程序。它能够执行按键事件，因为它是一个小程序。你也可以将自己的回调函数整合到父类中。我现在没有这样做，也许那就是解决方案。目前，我正在寻找更加普遍的POJO解决方案。因此，我编写了一些示例来说明我的问题。
请忽略在命令行（控制台）上使用按键事件。当然，这将是一个非常干净的解决方案，但在命令行上不可能实现，而且我的实际应用程序也不是命令行应用程序。事实上，按键事件对我来说是一个很好的解决方案，但我想了解除了与键盘有关的问题之外的事件和轮询。
这两个示例都会翻转一个布尔值。当布尔值翻转时，我想要触发某些内容。我可以在一个对象中包装这个布尔值，这样如果对象发生改变，我也可以触发事件。我只是不想通过if()语句进行无谓的轮询。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* Example of checking a variable for changes.
* Uses dumb if() and polls continuously.
*/
public class NotAvoidingPolling {
public static void main(String[] args) {
boolean typedA = false;
String input = "";
System.out.println("Type 'a' please.");
while (true) {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
try {
input = br.readLine();
} catch (IOException ioException) {
System.out.println("IO Error.");
System.exit(1);
}
// contrived state change logic
if (input.equals("a")) {
typedA = true;
} else {
typedA = false;
}
// problem: this is polling.
if (typedA) System.out.println("Typed 'a'.");
}
}
}
运行此代码将输出：
Type 'a' please.
a
Typed 'a'.
在一些论坛上，人们建议使用观察者模式。虽然这样可以将事件处理程序与被观察的类解耦，但我仍然需要在一个无限循环中使用if()语句。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Observable;
import java.util.Observer;
/*
* Example of checking a variable for changes.
* This uses an observer to decouple the handler feedback
* out of the main() but still is polling.
*/
public class ObserverStillPolling {
boolean typedA = false;
public static void main(String[] args) {
// this
ObserverStillPolling o = new ObserverStillPolling();
final MyEvent myEvent = new MyEvent(o);
final MyHandler myHandler = new MyHandler();
myEvent.addObserver(myHandler); // subscribe
// watch for event forever
Thread thread = new Thread(myEvent);
thread.start();
System.out.println("Type 'a' please.");
String input = "";
while (true) {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
try {
input = br.readLine();
} catch (IOException ioException) {
System.out.println("IO Error.");
System.exit(1);
}
// contrived state change logic
// but it's decoupled now because there's no handler here.
if (input.equals("a")) {
o.typedA = true;
}
}
}
}
class MyEvent extends Observable implements Runnable {
// boolean typedA;
ObserverStillPolling o;
public MyEvent(ObserverStillPolling o) {
this.o = o;
}
public void run() {
// watch the main forever
while (true) {
// event fire
if (this.o.typedA) {
setChanged();
// in reality, you'd pass something more useful
notifyObservers("You just typed 'a'.");
// reset
this.o.typedA = false;
}
}
}
}
class MyHandler implements Observer {
public void update(Observable obj, Object arg) {
// handle event
if (arg instanceof String) {
System.out.println("We received:" + (String) arg);
}
}
}
运行此代码会输出：
Type 'a' please.
a
We received:You just typed 'a'.
如果if()语句在CPU上是一个NOOP，那我很满意。但实际上它会比较每次循环，这会导致CPU的负载增加。这与轮询一样糟糕。我可以通过睡眠或比较自上次更新以来经过的时间来限制它，但这不是事件驱动的。它只是减少了轮询的次数。那么如何更加智能地完成这个任务呢？如何在不进行轮询的情况下监视POJO的变化？
在C#中似乎有一些有趣的东西，叫做属性。我不是C#专家，所以也许这并没有我想象的那么神奇。
private void SendPropertyChanging(string property)
{
if (this.PropertyChanging != null) {
this.PropertyChanging(this, new PropertyChangingEventArgs(property));
}
}