【设计模式】—— 观察者模式Observer

　　模式意图

　　观察者模式，也叫发布/订阅模式，从名字来说就能察觉到它的过程应该是，发布——其他人接受。

　　这个模式定义了对象之间的一种依赖关系，当一个对象发生变化时，其他的对象收到更新，也发生变化。

　　模拟我们订阅邮件这个场景，不管我们的邮箱是在登陆还是关闭，邮件都会发送到邮箱里面。只要把自己的邮箱订阅到这个邮件就可以了！这个模式也是这样一个过程。

　　这个模式代码相对来说比较容易理解，而且应用很广泛。

　　应用场景

　　1 当一个模型有几个展现方面，通过修改一个展现，顺便更新其他的。就好比一个网站的有web端，也有移动端，当web端的数据发生变化时，移动端的数据展现也要更新。

　　2 对一个对象发生改变，而不知道将有多少对象会发生改变时，利用这种模式可以有效的管理对象。

　　模式结构

　　Subject 抽象的主题角色

interface Subject{
    public void attach(Observer observer);
    public void detach(Observer observer);
    void notifyObservers();
}

　　ConcreteSubject 具体的主题角色，内部有一个容易，用于存放订阅者

class ConcreteSubject implements Subject{
    List<Observer> list = new ArrayList();
    public void attach(Observer observer) {
        list.add(observer);
    }
    public void detach(Observer observer) {
        list.remove(observer);
    }
    public void notifyObservers() {
        for(Observer o : list){
            o.update();
        }
    }
}

　　Observer 抽象的订阅者角色

interface Observer{
    public void update();
}

　　ConcreteObserver 具体的订阅者

class ConcreteObserver1 implements Observer{
    public void update() {
        System.out.println("ConcreteObserver1 update");
    }
}
class ConcreteObserver2 implements Observer{
    public void update() {
        System.out.println("ConcreteObserver2 update");
    }
}
class ConcreteObserver3 implements Observer{
    public void update() {
        System.out.println("ConcreteObserver3 update");
    }
}

　　全部代码

 1 package com.xingoo.test.design.observer;
 2
 3 import java.util.ArrayList;
 4 import java.util.List;
 5
 6 interface Subject{
 7     public void attach(Observer observer);
 8     public void detach(Observer observer);
 9     void notifyObservers();
10 }
11 class ConcreteSubject implements Subject{
12     List<Observer> list = new ArrayList();
13     public void attach(Observer observer) {
14         list.add(observer);
15     }
16     public void detach(Observer observer) {
17         list.remove(observer);
18     }
19     public void notifyObservers() {
20         for(Observer o : list){
21             o.update();
22         }
23     }
24 }
25 interface Observer{
26     public void update();
27 }
28 class ConcreteObserver1 implements Observer{
29     public void update() {
30         System.out.println("ConcreteObserver1 update");
31     }
32 }
33 class ConcreteObserver2 implements Observer{
34     public void update() {
35         System.out.println("ConcreteObserver2 update");
36     }
37 }
38 class ConcreteObserver3 implements Observer{
39     public void update() {
40         System.out.println("ConcreteObserver3 update");
41     }
42 }
43 public class Client {
44     public static void main(String[] args) {
45         Subject subject = new ConcreteSubject();
46         Observer o1 = new ConcreteObserver1();
47         Observer o2 = new ConcreteObserver2();
48         Observer o3 = new ConcreteObserver3();
49         subject.attach(o1);
50         subject.attach(o2);
51         subject.attach(o3);
52         subject.notifyObservers();
53
54         subject.detach(o2);
55         subject.notifyObservers();
56     }
57 }

　　运行结果

ConcreteObserver1 update
ConcreteObserver2 update
ConcreteObserver3 update
ConcreteObserver1 update
ConcreteObserver3 update

本文转自博客园xingoo的博客，原文链接：【设计模式】—— 观察者模式Observer，如需转载请自行联系原博主。