Question

我目前遇到的问题是我有一个应该侦听另一个对象的对象。

问题是：我该如何处理订阅？目前，我只知道两种可能的方式：

使用registrator：

var Registrator = function() {
    this.listener = new Listener();
};

Registrator.prototype.register = function(subsriber) {
    var self = this;
    subscriber.on('event', function(info) {
        self.listener.doSomething(info);
    });

};

在构造函数中：

var Subscriber = function() {
    var listener = require('./instanced-listener');
    this.on('event', function(info) {
        listener.doSomething(info);
    });

};

正如你所看到的，这两种方法都不是那么整洁。还有其他模式可以用于解决这个问题吗？

此致

PS：

如果示例看起来太抽象，那么这是源：

https://github.com/bodokaiser/documents/blob/master/lib/repository.js

检查构造函数以查看我的不快乐：）

Answer 1

这实际上取决于对象将如何广播和收听，以及您需要它们的耦合或解耦方式。一般来说，这种类型的事件体系结构的最佳用途是对象可以不加区分地向其他对象宣告事件，并且这些对象可以自行选择监听（注册）或停止监听（取消注册）。

1。听众依赖于广播公司

在某些情况下，使侦听器成为广播者的依赖可能是有意义的，在这种情况下，它将与事件名称和该广播公司宣布的事件的参数强烈耦合。

var Listener = function(broadcaster) {
  var self = this;
  broadcaster.on("event", function(info) {
    self.doSomething(info);  
  });
};

也可以创建其他侦听器类，并使用同一个广播器注册自己。广播公司不了解听众，只有听众才知道这种关系。

2。广播公司依赖于听众

广播公司仅为听众宣布活动。在这种情况下，事件体系结构可能过度，您可以使用直接调用替换事件。您的第二个示例暗示了这一点，因为广播公司的构造函数中与侦听器的一对一关系。

var Broadcaster = function(listener) {
  this.doSomething = function() {
    // do something...
    listener.doSomething(info);
  };
};

这为广播者和听众的界面创造了强大的耦合。这种模式并不像它首先出现的那样具有限制性。扩展此模式的有用性的常用方法是用广播适配器替换基本侦听器。广播适配器看起来与基本侦听器相同，因为它带有相同的doSomething接口，但实现了一个事件体系结构以将此调用传递给其他对象。这使得广播公司非常简单，并且可以以额外的课程为代价将与事件有关的任何内容外部化。

3。两者都是独立的

你的第一个例子是发布这种耦合的一个很好的例子，成本是一个额外的类。中间类充当两个类之间的桥接器或适配器，因此两者都不依赖于彼此的信息。事件签名对于侦听器是隐藏的，并且侦听器的方法签名对广播器是隐藏的。通常这种解耦程度是不必要的，但却是一个重要的工具，需要注意保持两个类彼此隔离的重要性。

var Bridge = function(listener, broadcaster) {
  broadcaster.on("event", function(info) {
    // if necessary translate the arguments as well
    listener.doSomething(info);
  });
};

Answer 2

修改

根据您的评论，我不确定您认为哪些内容不可读，但您可以尝试使用Stream个对象和优雅的Stream#pipe方法。

The Streams

var Stream = require('stream').Stream;
var util = require('util');

var Sender = function() {
  this.readable = true;
  this.saySomething = function(message) {
    this.emit('data', message);
  };
};
util.inherits(Sender, Stream);

var Receiver = function() {
  this.writable = true;
  this.write = function(message) {
    console.log('received: ' + message);
  }
};
util.inherits(Receiver, Stream);

用法

// instance of each
var s = new Sender();
var r = new Receiver();

// connect using pipe!
s.pipe(r);

// an event
s.saySomething('hello world'); //=> received: hello world

我特别喜欢使用Stream个对象。 pipe方法非常方便:)每个流都有一个输入和输出。我喜欢它们，因为它鼓励您构建负责特定任务的小型功能组件。然后，您可以根据自己的需要链接/重复使用它们。

原帖

您需要使用EventEmitter

这是一个简单的例子

var events = require('events');
var util = require('util');

var SampleEmitter = function() {
    events.EventEmitter.call(this);

    this.sayHello = function() {
      this.emit('hello', 'hello world');
    };
};
util.inherits(SampleEmitter, events.EventEmitter);

var SampleListener = function(emitter) {
    emitter.on('hello', function(data) {
        console.log(data);
    });
};

var se = new SampleEmitter();
var sl = new SampleListener(se);

se.sayHello(); //=> 'hello world'

Nodejs：如何处理对象之间的事件监听？

2 个答案:

1。听众依赖于广播公司

2。广播公司依赖于听众

3。两者都是独立的

修改

The Streams

用法

原帖