我正在使用一个名为 Processing 的框架，它基本上是一个 Java applet。它具有执行关键事件的能力，因为 Applet 可以。您还可以将自己的各种回调滚动到父级中。我现在不这样做，也许这就是解决方案。现在，我正在寻找更 POJO 的解决方案。所以我写了一些例子来说明我的问题。

请忽略在命令行(控制台)上使用按键事件。当然，这将是一个非常干净的解决方案，但在命令行上是不可能的，而且我的实际应用程序不是命令行应用程序。事实上，按键事件对我来说是一个很好的解决方案，但我试图了解事件和轮询，而不仅仅是键盘特定问题。

这两个例子都翻转了一个 boolean 值。当 boolean 值翻转时，我想触发一次。我可以将 boolean 值包装在一个对象中，这样如果对象发生变化，我也可以触发一个事件。我只是不想不必要地使用 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'.

在一些论坛上，人们建议使用 Observer。尽管这将事件处理程序与被观察的类分离，但我仍然有一个永远循环的 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 负载。这和投票一样糟糕。我也许可以通过 sleep 来限制它，或者比较自上次更新以来耗时，但这不是事件驱动的。这只是较少的轮询。那么我怎样才能更聪明地做到这一点呢？如何在不进行轮询的情况下观察 POJO 的变化？

在 C# 中似乎有一些有趣的东西叫做属性。我不是 C# 专家，所以也许这并不像我想的那么神奇。

private void SendPropertyChanging(string property)
{
  if (this.PropertyChanging != null) {
    this.PropertyChanging(this, new PropertyChangingEventArgs(property));
  }
}

最佳答案

是的，事件处理是您问题的关键。您显示的 C# 片段还使用事件处理来告知监听器属性已更改。 Java 也有这些用于大多数 Bean 的 PropertyChangeEvent。 (例如:Swing 组件使用它们)。

但是，您可以手动执行此操作:(尽管这不再是 POJO，而是更多的 Java Bean)

EventBean.java:

import java.util.LinkedList;
import java.util.List;

public class EventBean {

    private final List<Listener> listeners = new LinkedList<Listener>();

    protected final <T> void firePropertyChanged(final String property,
            final T oldValue, final T newValue) {
        assert(property != null);
        if((oldValue != null && oldValue.equals(newValue))
                || (oldValue == null && newValue == null))
            return;
        for(final Listener listener : this.listeners) {
            try {
                if(listener.getProperties().contains(property))
                    listener.propertyChanged(property, oldValue, newValue);
            } catch(Exception ex) {
                // log these, to help debugging
                ex.printStackTrace();
            }
        }
    }

    public final boolean addListener(final Listener x) {
        if(x == null) return false;
        return this.listeners.add(x);
    }
    public final boolean removeListener(final Listener x) {
        return this.listeners.remove(x);
    }

}

Listener.java:

import java.util.Collections;
import java.util.Set;
import java.util.TreeSet;

// Must be in same package as EventBean!
public abstract class Listener {

    private final Set<String> properties;

    public Listener(String... properties) {
        Collections.addAll(this.properties = new TreeSet<String>(), properties);
    }

    protected final Set<String> getProperties() {
        return this.properties;
    }

    public abstract <T> void propertyChanged(final String property,
            final T oldValue, final T newValue);
}

然后像这样实现你的类:

public class MyBean extends EventBean {

    private boolean typedA;

    public void setTypedA(final boolean newValue) {
        // you can do validation on the newValue here
        final boolean oldValue = typedA;
        super.firePropertyChanged("typedA", oldValue, newValue);
        this.typedA = newValue;
    }
    public boolean getTypedA() { return this.typedA; }

}

您可以用作:

MyBean x = new MyBean();
x.addListener(new Listener("typedA") {
    public <T> void propertyChanged(final String p,
                 final T oldValue, final T newValue) {
        System.out.println(p + " changed: " + oldValue + " to " + newValue);
        // TODO
    }
});

x.setTypedA(true);
x.setTypedA(false);
x.setTypedA(true);
x.setTypedA(true);

关于java - 在没有轮询的情况下观察变量的变化，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/2822901/