标签: observer-pattern

Rails:如何观察实际上没有模型的连接记录?

是否可以使用Observer观察JOIN记录的创建?例如,您有一个用户模型has_and_belongs_to_many图书模型.是否可以在创建或删除books_users记录时对其进行监控,或者我是否必须拥有BookUser模型才能执行此操作?

我要观察的例子:

User.books << book
Run Code Online (Sandbox Code Playgroud)

要么

User.books.push(book)
Run Code Online (Sandbox Code Playgroud)

管他呢!

谢谢,

戴夫K.

ruby ruby-on-rails associations has-and-belongs-to-many observer-pattern

5
推荐指数
1
解决办法
766
查看次数

观察者设计模式

在观察者设计模式中,主体通过调用update()每个观察者的操作来通知所有观察者.一种方法是这样做

void notify() {
   for (observer: observers) {
      observer.update(this);
   }
}
Run Code Online (Sandbox Code Playgroud)

但是这里的问题是每个观察者都按顺序更新,观察者的更新操作可能不会被调用,直到更新之前的所有观察者.如果有一个观察者有一个无限循环的更新,那么它之后的所有观察者将永远不会得到通知.

题:

  1. 有办法解决这个问题吗?
  2. 如果是这样,那会是一个很好的例子吗?

java design-patterns observer-pattern

5
推荐指数
3
解决办法
4244
查看次数

Rails:访问模型中的当前用户会话(

使用mod_passenger维护部署在Apache上的Rails v2.3.8应用程序.

我需要访问其中一个模型中的当前用户会话(准确地说是Auditor观察者).我知道这打破了MVC的原则.但我必须违反它,因为我有一个需要知道当前登录用户的观察者.我有很多控制器,并且调用Auditor记录器不会很干.

我只是想在返回当前登录的用户会话时调用User.current.但是我遇到了缓存/线程安全的问题.原作者使用类变量(@@ current)来存储当前用户.但这不是线程安全的,所以我把它变成了这个

class User < AR:Base
  ...
  def self.current
    Thread.current[:user]
  end

  def self.current=(user)
    Thread.current[:user] = user
  end
  ...
end
Run Code Online (Sandbox Code Playgroud)

所以它应该是线程安全的.在Auditor观察员中,我有一个电话:

Auditor(subject, action, object)
Run Code Online (Sandbox Code Playgroud)

我在User.current中传递的主题.

这段代码在开发中很有用,但在制作中我从User.current获得了不正确的值.有时我得到另一个登录用户的记录而不是当前记录.所以仍然存在一些线程安全/类缓存问题,但我无法弄清楚如何修复它.

有什么建议?谢谢

session ruby-on-rails thread-safety observer-pattern

5
推荐指数
1
解决办法
3431
查看次数

Content Provider和Content Observer示例?

我是Android开发的新手,并且与内容提供商和内容观察员一起玩.但是,我无法在线查找示例.我一直在玩和读这个但是已经卡住了.这是我想要做的:

我创建了一个小内容提供商(我已经确认它正在工作并在手机上的数据库中插入/删除数据).我们称之为A.apk.现在我想创建一个B.apk,它将通过对db进行的任何更新得到通知.因此,如果创建新内容,B将显示它,如果内容被删除,它将从B的视图中删除.

我很困难,很想看看如何使用最佳实践正确完成这项工作.一个例子将非常感谢!

database android android-contentprovider observer-pattern

5
推荐指数
1
解决办法
9121
查看次数

将类定义为Observable和Observer

从技术上讲,似乎可以将a定义Class为两者Observable并Observer使用以下代码:

public class Data extends Observable implements Observer
Run Code Online (Sandbox Code Playgroud)

但是,试图实现它,它不起作用.

public class Data extends Observable implements Observer {

    @Override
    public void update(Observable o, Object o1) {
        System.out.println("SC");        
    }

    Integer A;
    String B;
    Float C;

    public Data() {
        this.addObserver(this);
    }

    public void setA(Integer A) {
        this.A = A;
        notifyObservers();
    }

    public void setB(String B) {
        this.B = B;
        notifyObservers();
    }

    public void setC(Float C) {
        this.C = C;
        notifyObservers(this.C);
    }

}
Run Code Online (Sandbox Code Playgroud)

与main如下功能:

public static …
Run Code Online (Sandbox Code Playgroud)

java design-patterns observer-pattern

5
推荐指数
1
解决办法
3195
查看次数

松散耦合的观察者模式

我意识到这个问题已经被解决了,但我仍在努力,可以做一些具体的帮助.

我的目标是在某种可观察的(可以说是狗)和某种倾听者(比如所有者)之间实现一个简单的观察者模式.

最终,所有者将成为MVC范例中的"视图"和"狗"模型.我正在使用Dog和Owner来尝试简化这里的事情.

我试图使用Java内置的Observer/Observable类,但已经意识到Observers update()方法有多糟糕 - 它接收到POJO,我需要在update()方法中检查/转换该POJO.我更愿意让我的'update()'方法收到它可以期待的东西.

所以,我遵循了一些教程,包括使用Dog/Owner作为示例的教程:

http://www.youtube.com/watch?v=qw0zZAte66A

在这里,我已经展示了如何滚动我自己的Observer/Observed类.在伪代码中,我现在拥有的是:

Dog/Model {

    List listeners;

    public fireDogHungryEvent() {

        foreach listener {
            listener.onDogHungry(this);
        }
    }

    public fireDogPeeEvent() {

        foreach listener {
            listener.onDogNeedsToPee(this);
        }
    }

    public getHungerLevel() { return hungerLevel; }
    public getBladderCapacity() { return bladderCapacity; }
}

Owner/View {

    public onDogHungry(model) {
        println(model.getHungerLevel());
    }

    public onDogNeedsToPee(model) {
        println(model.getBladderCapacity());
    }
}
Run Code Online (Sandbox Code Playgroud)

所以现在而不是一个update()方法,我有处理特定事件的方法.辉煌.我目前对所有者/视图类感到满意.它知道Dog/model的方法,这很好(我认为).

我不喜欢的是Dog/model引用了Owner/view中的方法.我已经阅读过无数次并且完全同意模型不应该与其视图紧密耦合,例如它似乎在上面.我也不热衷于狗/模型中的所有'火'方法几乎做同样的事情; 循环遍及其所有侦听器,并在每个侦听器上调用不同的方法.

是否有可能进一步解除这种关系,而不是具有Dog/model调用特定方法?如果是这样,将狗/模型数据接收到所有者/视图并适当地使用它的最佳方法是什么?

谢谢

java model-view-controller loose-coupling observer-pattern

5
推荐指数
1
解决办法
1082
查看次数

n:1是否可观察:java中可能存在泛型的观察者?(观察者模式)

我想听听你对应用观察者模式的看法.

我的目标是实现一个可以监听多个可观察对象的具体观察者类.

如果我像下面那样开发每个不同的观察者,那么下面就会很简单.

public class ConcreteObserver implements EventObserverA , EventObserverB {

    updateEventA(EventA event) {}
    updateEvetnB(EventB event) {}

}
Run Code Online (Sandbox Code Playgroud)

在这种情况下,我应该编写许多不同的观察者/可观察的类/接口,里面几乎相同的代码片段.

为了避免像上面这样的麻烦,我想要对观察者进行生成/但是你们知道多重继承规则不允许像下面这样的代码.

public class ConcreteObserver implements Observer<EventA> , Observer<EventB> {

    update(EventA event) {}
    update(EventB event) {}
Run Code Online (Sandbox Code Playgroud)

}

因为我在一个具体的观察者中至少​​有两位数的Observable事件,所以我希望尽可能避免单独实现每个观察者/可观察对.

我可能会猜测这种情况可能比观察者模式有更好的模式,因为观察者模式是为n:1观察者设计的:可观察的,而我的情况需要1:n观察者:观察者.

你们对这个案子有什么想法/建议吗?

java generics design-patterns observer-pattern

5
推荐指数
1
解决办法
372
查看次数

在javascript中可以阻止已失效的侦听器吗?

我的问题是" javascript中是否可以阻止失效的侦听器问题?" 但显然"问题"这个词会导致问题.

维基百科页面说,失败的监听器问题可以通过持有对观察者的弱引用的主题来解决.我之前在Java中已经实现了它并且它运行良好,我认为我将在Javascript中实现它,但现在我不知道如何.javascript甚至有弱引用吗?我看到有WeakSet和WeakMap具有在其名称中的"弱",但他们似乎并没有被这个有帮助,据我所看到的.

这是一个jsfiddle,显示了问题的典型案例.

html:

<div id="theCurrentValueDiv">current value: false</div>
<button id="thePlusButton">+</button>
Run Code Online (Sandbox Code Playgroud)

javascript:

'use strict';
console.log("starting");
let createListenableValue = function(initialValue) {
  let value = initialValue;
  let listeners = [];
  return {
    // Get the current value.
    get: function() {
      return value;
    },
    // Set the value to newValue, and call listener()
    // for each listener that has been added using addListener().
    set: function(newValue) {
      value = newValue;
      for (let listener …
Run Code Online (Sandbox Code Playgroud)

javascript dom garbage-collection weak-references observer-pattern

5
推荐指数
1
解决办法
268
查看次数

此代码是否遵循观察者模式?

我试图将观察者模式应用于Rust.与其他GC语言(如JS或Java)一样,我想Observable在事件中发送对数据的引用Observer.但是由于借用检查器,编译器继续让我头疼.因此,我学会了使用,Rc但它没有让我改变价值,Observable然后我使用了一个RefCell内部可变性,这是我想要的.霍拉我说.但后来我意识到Rc导致从不同地方引用单个位置的原因导致事件系统Observer过时.所以在删除事件方法之后Observer,我得到了:

struct Observable<T: Clone> {
    value: Rc<RefCell<T>>
}

impl<T: Clone> Observable<T> {
    fn new(value: T) -> Observable<T> {
        Observable {
            value: Rc::new(RefCell::new(value))
        }
    }

    fn set_value(&mut self, value: T) {
        *self.value.borrow_mut() = value;
    }

    fn register(&mut self) -> Observer<T> {
        Observer::new(self.value.clone())
    }
}

struct Observer<T: Clone> {
    value: Rc<RefCell<T>>
}

impl<T: Clone> Observer<T> {
    fn new(value: Rc<RefCell<T>>) -> Observer<T> {
        Observer {
            value
        } …
Run Code Online (Sandbox Code Playgroud)

rust observer-pattern

5
推荐指数
1
解决办法
254
查看次数

如何使用Java 10中的Flow API替换Observable / Observer代码(最好不使用多线程)?

最近,我将我的项目从Java 8升级到Java 10,并发出了很多警告,指出现在不推荐使用Observer和Observable。替换它们的建议是Flow API-问题是我尚未找到有关如何为Flow API编写代码的不错的教程。我发现的所有内容都说不能直接实现发布者/订阅者,而且我发现的许多内容都表明Flow API很大程度上基于多线程。

注意:我已经在StackOverflow以及Quora和其他一些站点上找到了这个答案,有人引用不能对Observable对象进行序列化,这在我为我的每个bean和许多bean实现Serializable时都完全不正确。我的其他类也是如此,甚至已经序列化以归档我的一些对象,并将它们从文件中读回到对象形式。

但是,多线程是一个问题-我不希望在响应模型对象的更改时使用流或多线程。问题1是-是否绝对需要使用Flow API,还是存在另一组不需要多线程和流​​的类/接口?

在查看Flow.publisher的javadocs时,我将用Observable替换-因为这是一个接口,这意味着我想我必须放入(类似于ListModel和TableModel类的实现)订阅者集合(类似于Observers?),并放置自定义代码以将其添加到我的发布商中或从中删除?问题2-我有权利吗?

问题3.)Flow.Publisher和Flow.Subscriber中的通用类型参数是什么?它显示了一个类型,但是我不知道在哪里使用该类型-我将在这里为我的一个模型类放置代码:

package net.draconia.frenchstudy.model;

import java.io.Serializable;

import java.util.concurrent.Flow.Publisher;
import java.util.concurrent.Flow.Subscriber;

public class Category implements Publisher<Category>, Serializable
{
    private static final long serialVersionUID = 5281400324476454101L;

    public static final Category EMPTY_CATEGORY = new Category(); 

    private Integer miId;
    private String msCategory;

    public Category()
    { }

    public Category(final int iId)
    {
        setId(iId);
    }

    public Category(final String sCategory)
    {
        setCategory(sCategory);
    }

    public Category(final int iId, final String sCategory)
    {
        setId(iId);
        setCategory(sCategory);
    }

    public String getCategory()
    { …
Run Code Online (Sandbox Code Playgroud)

java observable observer-pattern java-10

5
推荐指数
0
解决办法
443
查看次数