如何避免使用观察者模式进行循环引用？

Question

我遇到了这样的情况：

public class A
{
    private ArrayList<Listener> listeners = new ArrayList<Listener>();

    public A()
    {
        // stub
    }

    public void addListener(Listener listener)
    {
        this.listeners.add(listener);
    }

    public void removeListener(Listener listener)
    {
        this.listeners.remove(listener);
    }

    public interface Listener
    {
        // stub
    }
}

public class B implements A.Listener
{
    private A instanceOfA;

    public B()
    {
        this.instanceOfA = new A();
        this.instanceOfA.addListener(this);
    }
}

我相信 B 永远不会被破坏，因为 A 保留了对它的引用，而 A 永远不会被破坏，因为 B 保留了对它的引用。

这似乎是一种常见的设计模式，但没有人解释如何避免这种循环引用？

Answer 1

在实践中，这已解决，因此观察者B 不会直接引用A。它应该是一个专注于处理其事件的唯一任务的小类，并且不应该与A 有任何直接耦合。事实上，这正是观察者模式的重点：一种向A 添加代码的灵活方式，而无需硬依赖它。

如果事件处理程序必须观察作为事件源的对象 (A)，那么事件回调方法应该声明一个 A 类型的参数，以便它可以以无状态方式传递给处理程序，以仅在事件处理期间使用，之后不保留。

Answer 2

因为您没有按照模式通常定义的方式进行操作。你可以看看这个Tutorial。

将监听器定义为这样的接口，例如：

/**
 * The listener interface for receiving message events. The class that is interested in processing a
 * message event implements this interface.
 *
 * @see MessageEvent
 */
public interface MessageListener
{

  /**
   * Message received notification.
   *
   * @param data the data
   * @throws IOException Signals that an I/O exception has occurred.
   */
  public void MessageReceived( byte[] data ) throws IOException;

  /**
   * Connection closed notification.
   */
  public void closed();
}

现在您可以根据需要创建尽可能多的实现，例如：

public class MessageListenerImpl implements MessageListener
{

  /** The driver. */
  private DeviceClassInternal driver;

  /** The log. */
  private Log log;

  /**
   * Instantiates a new TCP message listener.
   *
   * @param driver the driver
   * @param log the log
   */
  public MessageListenerImpl( DeviceClassInternal driver, Log log )
  {
    this.driver = driver;
    this.log = log;
  }

  /** {@inheritDoc} */
  @Override
  public void MessageReceived( byte[] data ) throws IOException
  {
    log.info( "data received: {1}", new String( data ) );
    driver.dataReceived( data );
  }

  @Override
  public void closed()
  {
    log.info( "{0}: Connection closed", physicalConnection.getName() );
    driver.closed();
  }

}

最后你可以创建它并将这个监听器注册到你想要的对象：

  MessageListenerImpl listener = new MessageListenerImpl( connection, log ); // create the listener and you're good to go.

  physicalConnection.registerListener( listener ); // Just some object with a register function.

Answer 3

这一切都取决于特定的用例。 正如其他人指出的那样，在许多情况下，您不需要在侦听器中保存 A 引用，而是依赖于在事件本身中传递它。但这并不总是足够的 - 例如，您可能希望根据其他事件注销自己，并且您需要原始引用才能调用 removeListener。

但这是一个更通用的问题 - 如果您仍然在其他地方引用 A，那么无论您的侦听器设计如何，它都不会被 GCed。另一方面，如果你忘记了程序中对 A 的引用并且不持有对 B 的引用，那么它们无论如何都会被垃圾回收 - 循环引用不会阻止 Java 中的垃圾回收 (How does Java Garbage Collection work with Circular References?)

过去我也遇到过类似的情况，但我关心的是 B 被 GC 而不是 A。当从外部对 B 的所有引用都丢失时，没有人可以取消注册它，但它仍然会收到 A 的通知事件。如果您没有完美地清理自己，那么在 Java 的 UI 框架中以这种危险的侦听器结束是很常见的（人们通常不会这样做，因为他们认为以图形方式摆脱 UI 组件并忘记所有对这应该足够了——例如，一些全局键盘处理程序的侦听器或某些东西仍然将所有内容保存在强可达集中）。

虽然对于 UI 框架，您没有机会更改核心代码，但您可以使用自己的代码尝试使侦听器列表具有 WeakReference 而不是强引用，并在需要时对每个通知进行一些清理。它的副作用是您必须保持听众对其他代码位置的引用，但无论如何这是一个很好的做法（因为在其他情况下您应该手动取消注册它们） - 如果您不这样做，则参考较弱你会突然停止在随机时间被回调（在几个 gc 循环运行后）。

无论如何，您首先需要了解（并告诉我们），您如何想象 A 和 B 的生命周期以及为什么在 A 可能已经消失后 B 会被强引用。您也可以随时将 B->A 引用设为弱引用，但请首先确保充分了解您对在什么时候忘记什么的期望。