我注意到有些人写bean支持Property Change观察者模式.
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.Serializable;
public class SampleBean implements Serializable {
public static final String PROP_SAMPLE_PROPERTY = "sampleProperty";
private String sampleProperty;
private PropertyChangeSupport propertySupport;
public ChartBean() {
propertySupport = new PropertyChangeSupport(this);
}
public String getSampleProperty() {
return sampleProperty;
}
public void setSampleProperty(String value) {
String oldValue = sampleProperty;
sampleProperty = value;
propertySupport.firePropertyChange(PROP_SAMPLE_PROPERTY, oldValue, sampleProperty);
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
propertySupport.addPropertyChangeListener(listener);
}
public void removePropertyChangeListener(PropertyChangeListener listener) {
propertySupport.removePropertyChangeListener(listener);
}
}
但是,我记得由于Web应用程序的无状态特性,观察者模式并不常用于基于Web的MVC模式.
在Web应用程序 Java bean中遵循上述模式是一种好习惯吗？
在java的Observer模式类Observer和Observable中,调用Observable对象的notifyObservers(Object arg0),在不同的线程中,线程安全吗？
示例:我有多个线程,所有Observable,将经常调用notifyObservers(...).所有这些线程都报告给一个Observer对象.
我是否会遇到并发问题,以及解决这个问题的更好方法是什么？我知道使用事件侦听器的可能解决方案.但是我不确定如何实现它,如果可能的话,我想坚持使用Observer模式实现.
是否有观察员可以用来观察产品从购物车中取出时的事件？我还没找到.
我发现checkout_cart_update_items_after如果通过改变产品数量来移除产品,可以使用哪些产品,但是当用户使用移除按钮时则不能使用.我现在看到的唯一选择checkout_cart_save_after是每当推车改变时使用.当然,这需要定制逻辑来检查哪个产品被删除.不完美.
那么是否有更好的方法来注意删除事件？
我知道这听起来很重,但我正试图解决一个假设的情况.想象一下,你有一些物体的N个观察者.每个人都对对象状态感兴趣.应用Observer模式时,可观察对象倾向于迭代调用observer notify()|update()方法的观察者列表.
现在想象一下,特定的观察者有很多与可观察对象的状态有关的工作.例如,这会减慢上一次通知的速度.
因此,为了避免减慢对所有观察者的通知,我们可以做的一件事是在一个单独的线程中通知观察者.为了实现这一点,我想每个观察者都需要一个线程.这是一个痛苦的开销,我们正在努力避免因繁重工作导致的通知减慢.如果使用线程方法,最慢的是减速,是由无限循环引起的死线程.阅读这本有经验的程序员会很棒.
这是一个模糊的例子,以展示并希望澄清我甚至没有测试的基本思想:
class Observable(object):
def __init__(self):
self.queues = {}
def addObserver(self, observer):
if not observer in self.queues:
self.queues[observer] = Queue()
ot = ObserverThread(observer, self.queues[observer])
ot.start()
def removeObserver(self, observer):
if observer in self.queues:
self.queues[observer].put('die')
del self.queues[observer]
def notifyObservers(self, state):
for queue in self.queues.values():
queue.put(state)
class ObserverThread(Thread):
def __init__(self, observer, queue):
self.observer = observer
self.queue = queue
def run(self):
running = True
while running:
state = …这里有新手到C++.我正在阅读更深入的信号和插槽,它声称1)回调本质上是类型不安全的,2)为了使它们安全,你需要在你的函数周围定义一个纯虚拟类包装器.我很难理解为什么这是真的.作为一个例子,这里是Qt在其教程页面上提供的信号和插槽的代码:
// Header file
#include <QObject>
class Counter : public QObject
{
Q_OBJECT
public:
Counter() { m_value = 0; }
int value() const { return m_value; }
public slots:
void setValue(int value);
signals:
void valueChanged(int newValue);
private:
int m_value;
};
// .cpp file
void Counter::setValue(int value)
{
if (value != m_value) {
m_value = value;
emit valueChanged(value);
}
}
// Later on...
Counter a, b;
QObject::connect(&a, SIGNAL(valueChanged(int)),
&b, SLOT(setValue(int)));
a.setValue(12); // a.value() == 12, b.value() == …我一直在实现一个准确的观察者模式,并且陷入了一个有点神秘的错误:"成员引用基类型'Observer*'不是结构或联合".我认为这与我使用模板有关,我仍然相当不舒服.这是有问题的代码(为了简化事情,删除了大多数缺点/析构函数):
主题界面:
class Subject {
public:
virtual void notify();
private:
list< Observer * > m_observers;
};
主题实施:
void Subject::notify() {
list< Observer * >::iterator i;
for ( i = m_observers.begin(); i != m_observers.end(); i++ ) {
*i->update( this ); // ERROR !!! ERROR
}
观察者抽象界面:
class Observer {
public:
virtual ~Observer();
virtual void update( Subject * changedSubject ) = 0;
protected:
Observer();
};
具体观察者界面:
class ConcreteObserver: public Observer {
public:
ConcreteObserver( ConcreteSubject * );
virtual ~ConcreteObserver();
virtual void update( Subject …我有观察者模式的问题.它说Observer和Subject都应该是接口.我明白为什么观察者是接口,但为什么将主题作为抽象类更好呢？难道你不能实现至少删除/注册？
我尝试在我的Application子类中实现静态Observable,但它不起作用.没有异常或错误消息,但我的update()回调没有被调用.
MyApplication.java
public class MyApplication extends Application{
public static Observable appObserver = new Observable();
public void onCreate(){
super.onCreate();
}
}
Foo.java
MyApplication.appObserver.notifyObservers( "Hello world" );
BarFragment.java
public class BarFragment extends Fragment implements Observer{
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
MyApplication.appObserver.addObserver(this);
}
@Override
public void onDestroy() {
MyApplication.appObserver.deleteObserver(this);
super.onDestroy();
}
@Override
public void update(Observable observable, Object data) {
Log.i("BarFragment", data.toString()); // Should log, but doesn't
}
}
更重要的是,我试着涂鸦了一个简单的可观察我自己的,然后一切工作就像一个魅力与刚刚替换public static Observable appObserver = new Observable();用public static MyObservable appObserver …
假设我有一个非常简单的数据类型:
class SimpleObject:
def __init__(self, property):
self.property = property
def update_property(self, value):
self.property = value
我是一种特殊的列表来存储数据类型:
class SimpleList(collections.MutableSequence):
def update_useful_property_of_list(self, value):
self.useful_property_of_list = value
我存储它们:
simple1 = SimpleObject(1)
simple2 = SimpleObject(2)
simple_list = SimpleList([simple1, simple2])
有没有办法让SimpleList对象知道其成员的某个属性何时发生变化？例如,当这样的事情发生时,我怎样才能simple_list执行self.update_useful_property_of_list():
simple1.update_property(3)
我有连接的服务Subject()做分页.我正在使用next(newData)传递给主题,这让事情保持活力,现在我需要complete()在每个ajax调用上使用并将其传递给主题.但在做了一个之后,complete()我开始得到错误.
我想知道,如果一旦被触发,我们仍然可以传递Subject可观察量吗？next(newData)completed()