观察者模式又称为发布-订阅（Publish/Subscribe）模式，是23种设计模式之一。DP中是这么定义观察者模式的：
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有的观察者对象，使它们能够自动更新自己。
举个生活中的例子，例如在某班级里，几个同学都在某个网站上订阅了一本连载的漫画。当漫画更新时，就会通知这几位同学，同学收到通知后就可以去下载漫画的最新篇章。这就是一个典型的观察者模式，在这里同学都是观察者，而漫画则是他们共同监听的一个主题，而漫画更新时也就是主题对象发生变化时，就会通知所有订阅该漫画的同学，所以漫画也就是通知者。同学们收到通知后就可以去下载漫画的新篇章了，这就是主题对象会通知观察者对象让他们进行更新。
我们使用简单的代码，来尝试实现一下这个场景：
漫画类，也就是主题：
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
2
3import java.util.Vector;
4
5// 漫画
6public class Cartoon {
7
8 // 学生列表
9 private Vector<Student> studentList = new Vector();
10 // 漫画状态
11 private String action;
12
13 public String getAction() {
14 return action;
15 }
16
17 public void setAction(String action) {
18 this.action = action;
19 }
20
21 // 添加订阅该漫画的学生
22 public void attach(Student student) {
23 studentList.add(student);
24 }
25
26 // 漫画更新时通知学生
27 public void notifyOfStu() {
28 for (Student student : studentList) {
29 student.update();
30 }
31 }
32}
33
学生类，也就是观察者：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3public class Student {
4
5 private String name;
6 private Cartoon cartoon;
7
8 public Student(String name, Cartoon cartoon) {
9 this.name = name;
10 this.cartoon = cartoon;
11 }
12
13 // 得到通知时，就去下载新漫画
14 public void update() {
15 System.out.println(cartoon.getAction() + ", " + name + "请下载漫画的新篇章！");
16 }
17
18}
19
客户端：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3public class Client {
4
5 public static void main(String[] args) {
6
7 // 订阅的漫画
8 Cartoon cartoon=new Cartoon();
9
10 // 订阅该漫画的学生
11 Student student1=new Student("小明", cartoon);
12 Student student2=new Student("小红", cartoon);
13
14 // 添加订阅的学生
15 cartoon.attach(student1);
16 cartoon.attach(student2);
17
18 // 订阅的漫画更新了
19 cartoon.setAction("您订阅的XXX漫画更新啦");
20 // 通知订阅的学生
21 cartoon.notifyOfStu();
22 }
23}
24
运行结果：
2
3
2您订阅的XXX漫画更新啦, 小红请下载漫画的新篇章！
3
以上的代码实现了一个简单的观察者模式，当漫画这个主题对象的状态发生改变时，就会通知所有的订阅者。
我们编写的代码虽然可以实现以上所说到的场景，但是代码的耦合性很高，不能完全符合观察模式的设计理念。例如，我要增加一个订阅的是小说类型的学生，那么就得去修改 “漫画” 通知者的代码了。如果我还要增加一个 “小说” 通知者，让 小说” 通知者也能通知所有学生的话，也需要去修改学生类的代码，这就不符合开-闭原则了，而且对象之间互相依赖也违背了依赖倒转原则，以及以上的代码中没有编写取消订阅的方法也就是减少观察者的方法。
既然知道代码有哪些问题了，那么我们就来把这些代码重构一下：
代码结构图：
1.首先抽象两个类：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3// 通知者/主题接口
4public interface Subject {
5 public void attach(Observer observer);
6 public void detach(Observer observer);
7 public void notifyOfStu();
8 public void setAction(String action);
9 public String getAction();
10}
11
12package org.zero01.test;
13
14// 抽象观察者
15public interface Observer {
16
17 public abstract void update();
18
19}
20
2.然后才是具体的实现类：
漫画类：
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
2
3import java.util.Vector;
4
5// 漫画主题
6public class Cartoon implements Subject{
7
8 // 学生列表
9 private Vector<Observer> observerList = new Vector();
10 // 主题动作
11 private String action;
12
13 public String getAction() {
14 return action;
15 }
16
17 public void setAction(String action) {
18 this.action = action;
19 }
20
21 // 添加订阅该漫画的学生
22 public void attach(Observer observer) {
23 observerList.add(observer);
24 }
25
26 // 漫画更新时通知学生
27 public void notifyOfStu() {
28 for (Observer observer : observerList) {
29 observer.update();
30 }
31 }
32
33 public void detach(Observer observer) {
34
35 observerList.remove(observer);
36
37 }
38}
39
小说类：
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
2
3import java.util.Vector;
4
5// 小説主題
6public class Story implements Subject{
7
8 // 学生列表
9 private Vector<Observer> observerList = new Vector();
10 // 主题动作
11 private String action;
12
13 public void attach(Observer observer) {
14 observerList.add(observer);
15
16 }
17
18 public void detach(Observer observer) {
19 observerList.remove(observer);
20
21 }
22
23 public void notifyOfStu() {
24 for (Observer observer : observerList) {
25 observer.update();
26 }
27
28 }
29
30 public void setAction(String action) {
31 this.action=action;
32
33 }
34
35 public String getAction() {
36 return action;
37 }
38
39}
40
订阅漫画的学生：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3public class StuOfCartoon extends Observer{
4
5 private String name;
6 private Subject subject;
7
8 public StuOfCartoon(String name, Subject subject) {
9 this.name=name;
10 this.subject=subject;
11 }
12
13 // 得到通知时，就去下载新漫画
14 public void update() {
15 System.out.println(subject.getAction() + ", " + name + "请下载漫画的新篇章！");
16 }
17
18}
19
订阅小说的学生：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3public class StuOfStory extends Observer{
4
5 private String name;
6 private Subject subject;
7
8 public StuOfStory(String name, Subject subject) {
9 this.name=name;
10 this.subject=subject;
11 }
12
13 // 得到通知时，就去下载小说的新篇章
14 public void update() {
15 System.out.println(subject.getAction() + ", " + name + "请下载小说的新篇章！");
16
17 }
18
19}
20
客户端代码：
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
2
3public class Client {
4
5 public static void main(String[] args) {
6
7 // 漫画
8 Cartoon cartoon = new Cartoon();
9
10 // 订阅漫画的学生
11 StuOfCartoon student1 = new StuOfCartoon("小明", cartoon);
12 StuOfCartoon student2 = new StuOfCartoon("小红", cartoon);
13
14 // 订阅小说的学生
15 StuOfStory ofStory=new StuOfStory("小刚", cartoon);
16
17 // 添加订阅的学生
18 cartoon.attach(student1);
19 cartoon.attach(student2);
20 cartoon.attach(ofStory);
21
22 // 取消订阅，减少订阅的学生
23 cartoon.detach(student2);
24
25 // 订阅的主题更新了
26 cartoon.setAction("您订阅的XXX更新啦");
27 // 通知订阅的学生
28 cartoon.notifyOfStu();
29
30 }
31
32}
33
运行结果：
2
3
2您订阅的XXX更新啦, 小刚请下载小说的新篇章！
3
从客户端的代码可以看到，抽象了两个类之后，即便是只有一个 ”漫画“ 通知者也能够通知订阅不同类型主题的观察者，而不需要去修改任何的代码。同样的，我把 ”漫画“ 通知者换成 “小说” 通知者也丝毫不会受到影响：
客户端代码：
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
2
3public class Client {
4
5 public static void main(String[] args) {
6
7 // 小说
8 Story story = new Story();
9
10 // 订阅漫画的学生
11 StuOfCartoon student1 = new StuOfCartoon("小明", story);
12 StuOfCartoon student2 = new StuOfCartoon("小红", story);
13
14 // 订阅小说的学生
15 StuOfStory ofStory=new StuOfStory("小刚", story);
16
17 // 添加订阅的学生
18 story.attach(student1);
19 story.attach(student2);
20 story.attach(ofStory);
21
22 // 取消订阅，减少订阅的学生
23 story.detach(student2);
24
25 // 订阅的主题更新了
26 story.setAction("您订阅的XXX更新啦");
27 // 通知订阅的学生
28 story.notifyOfStu();
29
30 }
31}
32
运行结果：
2
3
2您订阅的XXX更新啦, 小刚请下载小说的新篇章！
3
这样的设计就满足了依赖倒转原则以及开-闭原则，算得上是一个完整的观察者模式设计的代码了。
监听与通知示意图：
我们再来看看观察者模式（Observe）的结构图：
我们来使用代码实现这个结构：
Subject类。该类通常被称为主题或抽象通知者，一般使用一个抽象类或者接口进行声明。它把所有对观察者对象的引用保存在一个集合里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象：
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
2import java.util.Vector;
3
4public abstract class Subject {
5
6 // 观察者列表
7 private List<Observer> observers = new Vector<Observer>();
8
9 // 增加观察者
10 public void attach(Observer observer) {
11 observers.add(observer);
12 }
13
14 // 移除观察者
15 public void detach(Observer observer) {
16 observers.remove(observer);
17 }
18
19 // 通知观察者
20 public void notifyOfObserver() {
21 for (Observer observer : observers) {
22 observer.update();
23 }
24 }
25
26}
27
Observer类，抽象观察者，为为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个update方法，这个方法叫更新方法：
2
3
4
5
6
2
3 public abstract void update();
4
5}
6
ConcreteSubject类，叫做具体的主题或具体的通知者，该类将有关状态存入具体的观察者对象。在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个具体的子类来进行实现：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3 // 具体主题的状态
4 public String getSubjectState() {
5 return subjectState;
6 }
7
8 public void setSubjectState(String subjectState) {
9 this.subjectState = subjectState;
10 }
11
12 private String subjectState;
13
14}
15
ConcreteObserver类，具体的观察者类，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。具体观察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体的子类进行实现：
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
2
3 // 观察者名称
4 private String name;
5 // 观察者状态
6 private String observerState;
7 private ConcreteSubject concreteSubject;
8
9 public ConcreteObserver(String name, ConcreteSubject concreteSubject) {
10 this.name = name;
11 this.concreteSubject = concreteSubject;
12 }
13
14 public ConcreteSubject getConcreteSubject() {
15 return concreteSubject;
16 }
17
18 public void setConcreteSubject(ConcreteSubject concreteSubject) {
19 this.concreteSubject = concreteSubject;
20 }
21
22 // 更新
23 public void update() {
24 observerState = concreteSubject.getSubjectState();
25 System.out.println("观察者" + name + "的新状态是" + observerState);
26 }
27}
28
客户端代码：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3 public static void main(String[] args){
4 ConcreteSubject concreteSubject=new ConcreteSubject();
5
6 concreteSubject.attach(new ConcreteObserver("A",concreteSubject));
7 concreteSubject.attach(new ConcreteObserver("B",concreteSubject));
8 concreteSubject.attach(new ConcreteObserver("C",concreteSubject));
9
10 concreteSubject.setSubjectState("test state");
11 concreteSubject.notifyOfObserver();
12 }
13
14}
15
运行结果：
2
3
4
2观察者B的新状态是test state
3观察者C的新状态是test state
4
观察者模式特点：
将一个系统分割成一系列互相协作的类有一个很不好的副作用，那就是需要维护相关对象之间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和复用都带来不便。而观察者模式的关键对象是主题 Subject 和观察者Observer ，一个 Subject 可以有任意数目的依赖它的 Observer ，一旦Subject的状态发生了改变，所有的Observer 都可以得到通知。Subject发出通知时并不需要知道谁是它的观察者，也就是说，具体观察者是谁，它根本不需要知道。而任何一个具体观察者不知道也不需要知道其他观察者的存在，这样降低了子类之间的耦合。
什么时候考虑使用观察者模式？
1.当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少个对象有待改变时，应该考虑使用观察者模式
2.当一个抽象模型有两个方面，其中一方面依赖于另一方面，这时用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。
观察者模式所做的事情其实就是解耦合，让耦合的双方都依赖于抽象，而不是依赖于具体，从而使得各自的变化都不会影响另一边的变化。
观察者模式的不足：
我们没办法让每个控件都是实现一个 “Observer” 接口，因为这些控件都早已被它们的制造商封装好了。而且我们上面的例子，尽管已经用了依赖倒转原则，但是 “抽象通知者” 还是依赖 ”抽象观察者“ ，也就是说，万一没有了 ”抽象观察者“ 这样的接口，那么通知功能就无法完成了。既然 ”通知者“ 和 ”观察者“ 之间根本就互相不知道，那么我们就换另一种方式，让客户端来决定通知谁，这就是接下来要提到的事件委托模式。
事件委托模式的实现
事件委托模式在Java的Swing图形化中经常使用，但是在Java语言中没有对其做一定的封装，因此实现起来没那么容易，不过反射机制学得还不错的话，其实很好理解实现原理。相比之下C#就容易了很多，C#里有一个delegate关键字，只需要声明一个委托器就可以了。在Java中我们需要自己通过反射机制去实现，正好把上面演示的例子使用事件委托模式进行重构，一会再说明什么是事件委托：
代码结构图：
1.去掉观察者Observer接口，把两个具体的观察者类的代码修改为如下内容：
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
2
3import java.util.Date;
4// 订阅漫画的同学
5public class StuOfCartoon {
6
7 private String name;
8
9 public StuOfCartoon(String name) {
10 this.name = name;
11 }
12
13 // 得到通知时，就去下载新漫画
14 public void downloadNewCartoon(Date date) {
15 System.out.println(date.toLocaleString() + " 您订阅的XXX更新啦, " + name + "请下载漫画的新篇章！");
16 }
17}
18
19package org.zero01.delegate;
20
21import java.util.Date;
22// 订阅小说的同学
23public class StuOfStory {
24
25 private String name;
26
27 public StuOfStory(String name) {
28 this.name = name;
29 }
30
31 // 得到通知时，就去下载小说的新篇章
32 public void downloadNewStory(Date date) {
33 System.out.println(date.toLocaleString() + " 您订阅的XXX更新啦, " + name + "请下载小说的新篇章！");
34
35 }
36}
37
2.定义一个事件类，该类通过反射机制完成对观察者对象方法的调用：
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
49
2
3import java.lang.reflect.Method;
4
5/**
6* 事件类，通过反射机制调用观察者对象的方法
7*/
8public class Event {
9
10 // 要执行方法的对象
11 private Object object;
12 // 要执行的方法名称
13 private String methodName;
14 // 要执行的方法的参数
15 private Object[] params;
16 // 要执行方法的参数类型
17 private Class[] paramTypes;
18
19 public Event() {
20 }
21
22 // 初始化属性
23 public Event(Object object, String methodName, Object... params) {
24 this.object = object;
25 this.methodName = methodName;
26 this.params = params;
27 contractParamTypes(this.params);
28 }
29
30 // 根据参数数组生成参数类型数组
31 private void contractParamTypes(Object[] params) {
32 this.paramTypes = new Class[params.length];
33 for (int i = 0; i < params.length; i++) {
34 this.paramTypes[i] = params[i].getClass();
35 }
36 }
37
38 // 通过反射机制执行该观察者对象的方法
39 public void invoke() throws Exception {
40 Method method = object.getClass().getMethod(this.getMethodName(), this.getParamTypes());
41 if (method == null) {
42 return;
43 }
44 method.invoke(this.getObject(), this.getParams());
45 }
46
47 // 以下都是属性的setter和getter，就省略了
48}
49
3.事件处理类，该类将事件源信息收集给事件类：
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
2
3import java.util.ArrayList;
4import java.util.List;
5
6/**
7 * 事件处理类，收集事件信息交给事件类执行
8 */
9public class EventHandler {
10
11 private List<Event> objects;
12
13 public EventHandler() {
14 objects = new ArrayList<Event>();
15 }
16
17 // 添加某个观察者对象要执行的方法，以及方法所需要的参数
18 public void addEvent(Object object, String methodName, Object... params) {
19 objects.add(new Event(object, methodName, params));
20 }
21
22 // 通知所有的观察者对象执行指定的方法
23 public void notifyOfObserver() throws Exception {
24 for (Event event : objects) {
25 event.invoke();
26 }
27 }
28}
29
4.通知者接口：
2
3
4
5
6
7
8
9
10
11
12
2
3// 通知者、主题接口
4public interface Subject {
5
6 // 增加观察者，也就是订阅的学生
7 public void addListener(Object object, String methodName, Object... params);
8 // 通知学生订阅的内容更新了
9 public void notifyOfObserver();
10
11}
12
5.具体的通知者：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2
3public class Cartoon implements Subject {
4
5 private EventHandler eventHandler;
6
7 public Cartoon(EventHandler eventHandler) {
8 this.eventHandler = eventHandler;
9 }
10
11 // 添加事件
12 public void addListener(Object object, String methodName, Object... params) {
13 eventHandler.addEvent(object, methodName, params);
14 }
15
16 // 转发到事件处理类上
17 public void notifyOfObserver() {
18 try {
19 eventHandler.notifyOfObserver();
20 } catch (Exception e) {
21 e.printStackTrace();
22 }
23 }
24}
25
Story类的代码也是一样的，忽略。
6.客户端代码：
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
2
3import java.util.Date;
4
5public class Client {
6
7 public static void main(String[] args) {
8
9 // 通知者
10 Subject cartoon = new Cartoon(new EventHandler());
11
12 // 订阅漫画的同学
13 StuOfCartoon stuOfCartoon = new StuOfCartoon("小明");
14 // 订阅小说的同学
15 StuOfStory stuOfStory = new StuOfStory("小红");
16
17 // 添加观察者，或者说添加订阅学生，把两个不同的类以及不同的方法委托给事件处理类
18 cartoon.addListener(stuOfCartoon, "downloadNewCartoon", new Date());
19 cartoon.addListener(stuOfStory, "downloadNewStory", new Date());
20
21 // 发出通知
22 cartoon.notifyOfObserver();
23
24 }
25}
26
以上客户端的代码可以看到，为了方便演示，我们是通过字符串来传递需要执行的方法的名称。还有另一种方式就是可以通过接口去定义方法的名称，就像Swing中添加点击事件一样，需要实现ActionListener接口里定义的actionPerformed方法，这样我们就只需要传递观察者对象即可，然后反射机制就扫这个对象是否有实现接口中定义的方法就可以了。不过如果不是像点击事件那种固定不变的方法的话，还是使用字符串来传递需要执行的方法的名称会好一些，这样便于修改。
运行结果：
2
3
22018-1-29 21:10:30 您订阅的XXX更新啦, 小红请下载小说的新篇章！
3
事件委托说明：
现在就可以来解释一下，事件委托是什么了。这就好比我是班长你是班主任，你让我通知某几个学生去办公室，然后我就去通知那几个学生办公室，这就是一个委托，你委托的事情是让我去通知你指定的那几个学生。而我就是通知者，与观察者模式不同的是，我是因为有你的委托才能去通知学生，而观察者模式是当主题状态发生变化时通知观察者。上面的客户端代码里，我们将订阅了相关内容的学生，委托给了通知者，所以通知者就可以对这些学生发出通知，但实际调用观察者方法的是Event类，不是通知者了。
而且一个委托可以搭载多个方法，这些方法可以是不同类的方法，当发送通知时所有的方法会被依次调用。这样我们就不需要在通知者上用一个集合存储观察者了，增加、减少观察者的方法也不需要编写了，而是转到客户端来让给委托搭载多个方法，这就解决了本来与抽象观察者耦合的问题。也就是说观察者模式是由抽象的观察者来决定调用哪个方法，而事件委托模式是由客户端决定调用哪个方法，这样通知者就不需要依赖抽象观察者了。
本文转自 ZeroOne01 51CTO博客，原文链接：http://blog.51cto.com/zero01/2066623，如需转载请自行联系原作者
