文章目录
  1. 1. 观察者模式 Observer
    1. 1.1. 问题:
    2. 1.2. 意图:
  2. 2. 小结

观察者模式貌似就是传说中的Listener吧~

观察者模式 Observer

观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使他们能够自动更新自己。

问题:

A large monolithic design does not scale well as new graphing or monitoring requirements are levied.

意图:

  • Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
  • Encapsulate the core (or common or engine) components in a Subject abstraction, and the variable (or optional or user interface) components in an Observer hierarchy.
  • The “View” part of Model-View-Controller.

例:这个模式比较像SQL里面的trigger,但实际用起来比较郁闷,说白了就是两个对象互调,就像AWT里面的我把按钮点一下,想要调用一个方法,需要ADDLISTENER之类的玩意。这种代码苦逼啊

代码1:观察者(监听器)接口,以类不同类型的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public interface Observer {
public void update(Subject sub);
}
public class LogicObserver implements Observer{
@Override
public void update(Subject sub) {
if(sub.getState()==Subject.TRAN_ERROR)
System.out.println("警告,对象"+ sub.toString()+"出了逻辑问题" );
}
}
public class SafeObserver implements Observer{
@Override
public void update(Subject sub) {
if(sub.getState()==Subject.SAFE_ERROR)
System.out.println("警告,对象"+ sub.toString()+"出了安全问题" );
}
}

代码2:需要监听的对象,简单来几个实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.ArrayList;
/**
* @author xdnote.com
* 需要监听的对象,实现Subject类,并通过addListener注册
* */
public class Subject {

public static int SAFE_ERROR = 1;

public static int TRAN_ERROR = 2;

private int state =0;

public int getState() {
return state;
}

public void setState(int state) {
this.state = state;
this.notice();
}

private ArrayList<Observer> listeners = new ArrayList<Observer>();

public void addListener(Observer listener){
this.listeners.add(listener);
}

private void notice(){
for(int i=0,j=this.listeners.size();i<j;i++){
listeners.get(i).update(this);
}
}
}
public class Subject1 extends Subject{

@Override
public String toString() {
return "对象 Subject1 ";
}
}
public class Subject2 extends Subject{

@Override
public String toString() {
return "对象 Subject2 ";
}
}

代码3:客户端调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) {
Subject sub1 = new Subject1();
sub1.addListener(new SafeObserver());
sub1.setState(Subject.SAFE_ERROR);
sub1.setState(Subject.TRAN_ERROR);

sub1.addListener(new LogicObserver());
sub1.setState(Subject.TRAN_ERROR);

Subject2 sub2 = new Subject2();
sub2.setState(Subject.TRAN_ERROR);
sub2.addListener(new LogicObserver());
sub2.setState(Subject.TRAN_ERROR);
}

小结

观察者模式 Observer

  • 使用频率:
    说实话,写了这么多的代码,行为型的模式真的都见得少,构造型的模式到处可见,主要是逻辑型的东西都喜欢自己解决,懒得去写那么多的模式去弄,或根本就没有考虑到模式,还是或者说,编程时更趋向于自己感知中认为安全的写法(也就是最基础的写法)呢?

  • 利弊影响:
    这个模式有点恶心,需要被观查者“配合”才能实现。

文章目录
  1. 1. 观察者模式 Observer
    1. 1.1. 问题:
    2. 1.2. 意图:
  2. 2. 小结