java 观察者模式_java中的观察者模式

观察者模式简介

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

观察者模式的实现

观察者模式的主要角色如下：

抽象主题（Subject）角色： 也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
具体主题（Concrete Subject）角色： 也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
抽象观察者（Observer）角色： 它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
具体观察者（Concrete Observer）角色： 实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

抽象观察者Observer：

abstract class Observer
{
    public abstract void Update();
}
1
2
3
4

抽象主题Subject:

public abstract class Subject
{
    //增加观察者
    public abstract void Attach(Observer observer);
    //移除观察者
    public abstract void Detach(Observer observer);
    //通知
    public abstract void Notify();
}
1
2
3
4
5
6
7
8
9

具体主题ConcreteSubject：

class ConcreteSubject extends Subject{
	
	//被观察者的状态
    private String subjectState;
    private List<Observer> observers = new ArrayList<Observer>();

    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }

    @Override
    public void Attach(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void Detach(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void Notify()
    {
        for(Observer item:observers)
        {
            item.Update();
        }
    }
}

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

具体观察者ConcreteObserver：

public class ConcreteObserver extends Observer{

    private String name;
    private String observerState;
    private ConcreteSubject subject;

    public ConcreteObserver(String name, ConcreteSubject subject) {
        this.name = name;
        this.subject = subject;
    }

    @Override
    public void Update() {
        observerState=subject.getSubjectState();
        System.out.println("观察者"+name+"的新状态是："+observerState);
    }

    public ConcreteSubject getSubject() {
        return subject;
    }

    public void setSubject(ConcreteSubject subject) {
        this.subject = subject;
    }

}

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

测试：

public static void main(String[] args) {
        //被观察者
        ConcreteSubject cs=new ConcreteSubject();

        //为cs增加三个观察者
        cs.Attach(new ConcreteObserver("x",cs));
        cs.Attach(new ConcreteObserver("y",cs));
        cs.Attach(new ConcreteObserver("z",cs));

        //cs发生变化
        cs.setSubjectState("ss");
        cs.Notify();
        
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

观察者x的新状态是：ss
观察者y的新状态是：ss
观察者z的新状态是：ss
1
2
3

总结

主要优点：

• 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
• 目标与观察者之间建立了一套触发机制。

主要缺点：

• 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
• 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

观察者模式的应用场景如下：

• 一个对象的数据或状态更新需要其它对象同步更新时；
• 系统存在事件多级触发时；
• 一个对象仅需要将自己的更新通知给其它对象而不需要知道其它对象细节时，如消息推送；
• 跨系统的消息交换场景，如通信过程中的消息队列处理机制。