观察者模式又叫作发布-订阅模式、模型-视图模式、源-监听器，模式或从属者模式。定义一种一对多的依赖关系，一个主题对象可被

多个观察者对象同时监听，使得每当主题对象状态变化时，所有依赖它的对象都会得到通知并自动更新，属于行为型设计模式。

观察者模式的应用场景：

1. 当一个抽象模型包含两方面内容，其中一方面依赖另一方面。
2. 其他一个或多个对象的变化依赖另一个对象变化。
3. 实现类似广播机制的功能，不需要知道具体收听者，只需分发广播，系统中敢兴趣的对象会自动接收该广播。
4. 多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知。

观察者模式的UML类图：

 

由上图可以看到观察者模式包含4个角色。

1. 抽象主题（ISubject）：指被观察的对象，该角色使一个抽象类或接口，定义了增加、删除、通知观察者对象的方法。
2. 具体主题（ConcreteSubject）：具体被观察者，当其内部状态变化时，会通知已注册的观察者。
3. 抽象观察者（IObserver）：定义了响应通知的更新方法。
4. 具体观察者（ConcreteObserver）：当得到状态更新的通知时，会自动做出响应。

基于java API实现通知机制：

　　当小伙伴们在GPer生态圈中提问时，如果有设置指定的老师回答，则对应的老师就会收到邮件通知，这就是观察者模式的一种应用场景。

有些小伙伴可能会想到用mq、异步队列等，其实JDK本身就提供这样的API。我们用代码来还原这样一个应用场景，首先创建GPer类。

[plain] view plaincopy  

1. /** 
2. * 被观察者 
3. */  
4. public class GPer extends Observable {  
5. private String name = "GPer生态圈";  
6. private static final GPer gper = new GPer();  
7.   
8. private GPer() {}  
9.   
10. public static GPer getInstance(){  
11. return gper;  
12. }  
13.   
14. public String getName() {  
15. return name;  
16. }  
17.   
18. public void publishQuestion(Question question){  
19. System.out.println(question.getUserName() + "在" + this.name + "上提交了一个问题。");  
20. setChanged();  
21. notifyObservers(question);  
22. }  
23. }  

然后创建问题Question类。

[plain] view plaincopy  

1. public class Question {  
2. private String userName;  
3. private String content;  
4.   
5. public String getUserName() {  
6. return userName;  
7. }  
8.   
9. public void setUserName(String userName) {  
10. this.userName = userName;  
11. }  
12.   
13. public String getContent() {  
14. return content;  
15. }  
16.   
17. public void setContent(String content) {  
18. this.content = content;  
19. }  
20. }  

接着创建观察者老师类。

[plain] view plaincopy  

1. public class Teacher implements Observer {  
2.   
3. private String name;  
4.   
5. public Teacher(String name) {  
6. this.name = name;  
7. }  
8.   
9. public void update(Observable o, Object arg) {  
10. GPer gper = (GPer)o;  
11. Question question = (Question)arg;  
12. System.out.println("======================");  
13. System.out.println(name + "老师，你好！\n" +  
14. "您收到了一个来自" + gper.getName() + "的提问，希望您解答。问题内容如下：\n" +  
15. question.getContent() + "\n" +  
16. "提问者：" + question.getUserName());  
17. }  
18. }  

最后编写客户端测试代码。

[plain] view plaincopy  

1. public class Test {  
2. public static void main(String[] args) {  
3. GPer gper = GPer.getInstance();  
4. Teacher tom = new Teacher("Tom");  
5. Teacher jerry = new Teacher("Jerry");  
6.   
7. gper.addObserver(tom);  
8. gper.addObserver(jerry);  
9.   
10. //用户行为  
11. Question question = new Question();  
12. question.setUserName("张三");  
13. question.setContent("观察者模式适用于哪些场景？");  
14.   
15. gper.publishQuestion(question);  
16. }  
17. }  

Observable类是JDK自带的被观察者类，我们可以通过继承的方式实现自己的业务，通过addObserver方法可以添加多个观察者，当我们发生改变时

设置状态为改变，然后再调用notifyObservers调用添加进来的所有的观察者。

观察者模式的优点：

• 观察者和被观察者是松耦合的，符合依赖倒置原则。
• 分离了表示层（观察者）和数据逻辑层（被观察者），并且建立了一套触发机制，使得数据得变化可以响应到多个表示层上。
• 实现了一对多的通信机制，支持事件注册机制，支持兴趣分发机制，当被观察者触发事件时，只有感兴趣的观察者可以接收到通知

观察者模式的缺点：

• 如果观察者数量过多，则事件通知会耗时较长。
• 事件通知呈线性关系，如果其中一个观察者处理事件卡壳，则会影响后续的观察者接收该事件。
• 如果观察者和被观察者之间存在循环依赖，则可能造成两者之间的循环调用，导致系统崩溃。