标签: publish-subscribe

观察者模式,发布/订阅和数据绑定有什么区别？

我在Stack Overflow上搜索了一下,没有找到任何好的答案.

我所相信的是,数据绑定是一个通用术语,有不同的实现方式,如观察者模式或发布/子模式.使用Observer模式,Observable更新其观察者.使用Pub/Sub,0-many发布者可以发布某些类的消息,0-many订阅者可以订阅某些类的消息.

是否有其他实施"数据绑定"的模式？

Socket.IO似乎是最流行和最活跃的WebSocket仿真库.Juggernaut使用它来创建一个完整的pub/sub系统.

Faye也很受欢迎,并拥有自己的javascript库,使其完整的功能可与Juggernaut相媲美.Juggernaut使用节点作为其服务器,而Faye可以使用节点或机架.Juggernaut使用Redis进行持久化(更正:它使用Redis作为pub/sub),而Faye只将状态保存在内存中.

1. 一切都准确吗？
2. Faye说它实现了Bayeux - 我认为Juggernaut没有这样做 - 是因为Juggernaut处于较低级别(IE,我可以使用Juggernaut实现Bayeux)
3. 如果想要,Faye可以切换到使用Socket.IO浏览器javascript库吗？或者他们的javascript库做了根本不同的事情？
4. 项目之间是否还有其他建筑/设计/哲学差异？

所以,一位同事向我介绍了发布/订阅模式(在JS/jQuery中),但是我很难掌握为什么会使用这种模式而不是'普通'的JavaScript/jQuery.

例如,之前我有以下代码......

$container.on('click', '.remove_order', function(event) {
    event.preventDefault();
    var orders = $(this).parents('form:first').find('div.order');
    if (orders.length > 2) {
        orders.last().remove();
    }
});

我可以看到这样做的优点,例如......

removeOrder = function(orders) {
    if (orders.length > 2) {
        orders.last().remove();
    }
}

$container.on('click', '.remove_order', function(event) {
    event.preventDefault();
    removeOrder($(this).parents('form:first').find('div.order'));
});

因为它引入了removeOrder为不同事件等重用功能的能力.

但是,为什么你决定实现发布/订阅模式并转到以下长度,如果它做同样的事情？(仅供参考,我使用jQuery tiny pub/sub)

removeOrder = function(e, orders) {
    if (orders.length > 2) {
        orders.last().remove();
    }
}

$.subscribe('iquery/action/remove-order', removeOrder);

$container.on('click', '.remove_order', function(event) {
    event.preventDefault();
    $.publish('iquery/action/remove-order', $(this).parents('form:first').find('div.order'));
});

我肯定已经读过关于这种模式的内容,但我无法想象为什么这种模式是必要的.我看过的解释如何实现这种模式的教程只是作为我自己的基本示例.

我认为pub/sub的有用性会在更复杂的应用程序中显现出来,但我无法想象.我担心我完全忽略了这一点; 但是如果有的话,我想知道这一点!

你能简洁地解释为什么以及在什么情况下这种模式是有利的？是否值得像上面的例子那样使用pub/sub模式进行代码片段？

我有一个简单的应用程序设置,显示一个列表Projects.我已经删除了autopublish包,所以我不会将所有内容发送给客户端.

 <template name="projectsIndex">    
   {{#each projects}}      
     {{name}}
   {{/each}}
 </template>

当autopublish打开时,这将显示所有项目:

if Meteor.isClient
  Template.projectsIndex.projects = Projects.find()

删除后,我还要另外做:

 if Meteor.isServer
   Meteor.publish "projects", ->
     Projects.find()
 if Meteor.isClient
   Meteor.subscribe "projects"
   Template.projectsIndex.projects = Projects.find()

那么,说客户端find()方法只搜索从服务器端发布的记录是否准确？它一直在绊倒我,因为我觉得我应该只打电话find()一次.

当连接socket.io/node.js和redis pub/sub以尝试创建由可处理多个传输的服务器事件驱动的实时Web广播系统时,似乎有三种方法:

1. 'createClient'是一个redis连接并订阅了频道.在socket.io客户端连接上,将客户端加入socket.io会议室.在redis.on("message",...)事件中,调用io.sockets.in(room).emit("event",data)以分发给相关房间中的所有客户端.喜欢如何在socket.io中重用redis连接？

2. 'createClient'是一个redis连接.在socket.io客户端连接上,将客户端加入socket.io会议室并订阅相关的redis频道.在客户端连接闭包内和收到消息调用client.emit("event",data)时包含redis.on("message",...)以在特定客户端上引发事件.就像在socket.io中使用RedisStore的示例中的答案一样

3. 使用RedisStore烘焙到socket.io和'广播'从Redis中的单个"调度"通道遵循socketio-spec协议.

Number 1允许为所有客户端处理一次Redis子和相关事件.Number 2为Redis pub/sub提供了更直接的钩子.3号更简单,但几乎无法控制消息传递事件.

但是,在我的测试中,所有连接的客户端都表现出意外的低性能.有问题的服务器事件是尽快发布到redis频道的1,000条消息,以便尽快分发.性能是通过连接客户端的时间来衡量的(socket.io-client基于该日志时间戳到Redis列表中进行分析).

我猜测在选项1中,服务器接收消息,然后顺序将其写入所有连接的客户端.在选项2中,服务器多次接收每个消息(每个客户端订阅一次)并将其写入相关客户端.在任何一种情况下,服务器都不会进入第二个消息事件,直到它被传递给所有连接的客户端.随着并发性的上升,情况显然更加恶化.

这似乎与堆栈功能的感知智慧不一致.我想相信,但我在苦苦挣扎.

这种情况(大量消息的低延迟分布)是不是这些工具的选项(但是？),还是我错过了一个技巧？

假设存在对套接字服务器进行订阅的对象,如下所示:

socket.on('news', obj.socketEvent)

这些对象的生命周期很短,并且经常被创建,从而生成许多订阅.这似乎是一个内存泄漏和容易出错的情况,直观地阻止这种情况:

socket.off('news', obj.socketEvent)

在删除对象之前,但唉,off套接字中没有方法.还有另一种方法吗？

编辑:找不到答案我正在指定一个空白方法来覆盖原始事件处理程序的包装器方法,下面是一个示例.

var _blank = function(){};

var cbProxy = function(){
    obj.socketEvent.apply(obj, arguments)
};
var cbProxyProxy = function(){
    cbProxy.apply ({}, arguments)
}
socket.on('news', cbProxyProxy);

// ...and to unsubscribe 
cbProxy = _blank;

我是Redis和Kafka的初学者.Redis可以用作实时pub-sub.然而,Kafka也是实时的pub-sub.我很困惑哪个时候使用.任何用例都将是一个很大的帮助!谢谢!

当actions在EmberJS控制器中包含时,如何从另一个动作调用一个动作？

使用现已弃用的方法定义操作的原始代码:

//app.js
App.IndexController = Ember.ArrayController.extend({
    // properties
    /* ... */

    // actions
    actionFoo: function() {
        /* ... */
        this.actionBar();
    },
    actionBar: function() {
        /* ... */
    }
});

//app.html
<div class="foo" {{action actionFoo this}}>
<div class="bar" {{action actionBar this}}>

但是,使用EmberJS 1.0.0,我们会收到弃用警告,说必须将操作放在控制器内的操作对象中,而不是直接放在控制器中,如上所述.

根据建议更新代码:

//app.js
App.IndexController = Ember.ArrayController.extend({
    // properties
    /* ... */

    // actions
    actions: {
        actionFoo: function() {
            /* ... */
            this.actionBar(); //this.actionBar is undefined
            // this.actions.actionBar(); //this.actions is undefined
        },
        actionBar: function() {
            /* ... */ …

是否有一个提供发布/订阅模式的java的轻量级框架？

一些理想的功能

• 支持泛型
• 向发布者注册多个订阅者
• API主要是接口和一些有用的实现
• 纯粹的内存,持久性和事务保证不是必需的.

我知道JMS,但这对我的需求来说太过分了.发布/订阅数据是扫描文件系统的结果,扫描结果被送到另一个组件进行处理,然后在被送到另一个组件之前进行处理,依此类推.

编辑:所有在同一过程中.来自beans的PropertyChangeListener并没有完全削减它,因为它报告了属性的变化,而不是发布特定的项目.我可以通过拥有"最后发布的对象"属性以及已发布的对象来使用工作模式来使用ProprtyChangeListener.PropertyChangeListeners不支持泛型,并且在属性更改语义中是根深蒂固的,而不是纯粹的发布/订阅.java.util Observer/Observable模式会很好,但是Oberver是一个具体的类.

我试图将Observer设计模式理解为主要事件调度设计模式.观察者模式似乎是发布 - 订阅设计模式的类型或类型,我想知道为什么有两个相似的外观设计模式以及我应该如何在两者之间进行选择.

在这两种情况下,信息消息都在实体之间发送,在这两种情况下,实体必须以某种方式注册或订阅才能接收消息.

两种设计模式之间的主要区别似乎是:

• 观察者模式似乎具有较低的消息量.观察员向他们观察的实体注册,以获得某一事件的通知.发布 - 订阅模式似乎涉及单向对话,一种从一个实体到另一个实体的独白,具有更多不同类型的消息.
• 在Observer模式中,Observers期望一种特定类型的事件通知,其中Publish-Subscribe似乎具有更开放的消息协议,具有更广泛的可能消息类型和消息内容(由特定类型的事件触发的消息之间的差异)指示事件发生与更一般的消息协议相对应,消息包含可能不是事件触发器的信息,例如包含由周期性定时器触发的温度数据的消息.
• Observer在应用程序的边界内或在单个进程内实现.Publish-Subscribe是一种跨应用程序通信模式,消息在不同进程之间交换.
• 架构的不同之处在于,当Observer使用组合的发布者/代理和订阅者(​​观察者)实体时,Publish-Subscribe具有单独的发布者,代理和订阅者实体.

我想到的一个想法是,在多线程应用程序中,可以在多个线程之间进行通信而不是Observer模式时使用Publish-Subscribe模式.也许Obse​​rver模式可以在进程之间使用,例如进程注册与另一个进程注册,以便在事件发生时得到通知.一个示例是农场管理仪表板应用程序,其注册多个动物饲料箱,如果由箱测量的饲料水平或重量下降到某个阈值以下则通知.

这两种设计模式之间是否存在其他重要差异,这些设计模式可以为选择一种模式提供标准？