观察者模式

定义

定义对象间一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖它的对象都会得到通知并被自动更新

代码

被观察者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public abstract class Subject {

private Vector<MyObserver> observerVector = new Vector<>();

public void addObserver(MyObserver observer){
this.observerVector.add(observer);
}

public void delObserver(MyObserver observer){
this.observerVector.remove(observer);
}

public void notifyObservers(){
for (MyObserver observer : this.observerVector) {
observer.update();
}
}
}

被观察者的实现

1
2
3
4
5
6
7
public class ConcreteSubject extends Subject {

public void doSomething(){
System.out.println("subject do something");
super.notifyObservers();
}
}

观察者

1
2
3
4
public interface MyObserver {

void update();
}

观察者的实现

1
2
3
4
5
6
public class ConcreteMyObserver implements MyObserver {
@Override
public void update() {
System.out.println("observer receive notify info!");
}
}

测试

1
2
3
4
5
6
7
8
9
public class ConcreteObserverTest {
@Test
public void testObserver(){
ConcreteSubject subject = new ConcreteSubject();
MyObserver observer = new ConcreteMyObserver();
subject.addObserver(observer);
subject.doSomething();
}
}
扩展

JDK已经自带了Observable类和Observer接口,修改上面的代码

被观察者

1
2
3
public abstract class Subject extends Observable{

}

1
2
3
4
5
6
7
8
public class ConcreteSubject extends Subject {

public void doSomething(){
System.out.println("subject do something");
super.setChanged();
super.notifyObservers("from subject");
}
}

观察者

1
2
3
public interface MyObserver extends Observer {

}

1
2
3
4
5
6
public class ConcreteMyObserver implements MyObserver {
@Override
public void update(Observable o, Object arg) {
System.out.println("observer receive:"+arg.toString());
}
}

测试

1
2
3
4
5
6
7
8
9
10
public class ConcreteObserverTest {
@Test
public void testObserver(){
ConcreteSubject subject = new ConcreteSubject();
MyObserver observer = new ConcreteMyObserver();
subject.addObserver(observer);
subject.doSomething();

}
}