设计模式之观察者模式

设计模式之观察者模式

---

1.观察者模式介绍 
1.1> 设计模式可以说是一种代码规范,也可以说是一种前人总结的技巧经验,对于后来编程者,学习设计模式可以对编程思路有一些启发,其中也包括经验启发。 
1.2> 对象之间定义一对多的依赖关系，当一个对象发生变化时，依赖它的其他对象会收到通知并相应作出反应。发生改变的对象称之为观察目标(被观察者)，收到通知并作出反应的对象称之为观察者。一个观察目标可以有多个观察者，观察者之间相互没有任何关系，可以增加、删除观察者。

2.观察者模式应用场景 
2.1> 基础的发布、订阅关系，比如：博主的粉丝订阅，博主有更新或者回复的时候，给粉丝发生通知， 
2.2> 有一个微信公众号服务，不定时发布一些消息，关注公众号就可以收到推送消息，取消关注就收不到推送消息。 
2.3> 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

3.观察者模式代码详解？ 
3.1> 观察者模式的结构 

观察者模式与发布/订阅模式的区别在于；通知调度的地方，观察者模式中，通知调度的地方在于被观察者中，而发布/订阅模式中有一个专门的调度中心。 
3.2> 观察者模式中主要的对象:2个接口；2个类 
观察目标(被观察者)的抽象接口:观察目标将观察者保存在一个集合中，一个被观察者可以有多个观察者；观察目标提供了 增加观察者、删除观察者的接口。 
观察者的抽象接口:为所有具体的观察者提供一个接口，用于被观察者发生改变时更新自己。 
被观察者的抽象类:存储之被观察者的对象，当其发生改变时，给所有关注的观察者发送通知，一般通过具体的子类来实现。 
观察者抽象类:存储相关状态，通过具体子类实现观察者的抽象接口，通过被观察者的状态更新自己。 
3.3> 
观察目标抽象接口：

1. public interface BeObserver {
2. void addObserver(AbstractObserverDTO abstractObserverDTO);
3. void delObserver(AbstractObserverDTO abstractObserverDTO);
4. void notice(MessageDTO messageDTO);
5. }

定义了三个接口 
1> 增加观察者。 
2> 删除观察者。 
3> 通知观察者，自身发送改变，通知观察者。

被观察者抽象类，具体子类继承该类

1. public class AbstracBeObserverDTO implements BeObserver {
2.  
3. private String name;
4.  
5. private String age;
6.  
7. private List<AbstractObserverDTO> abstractObserverDTOS = new ArrayList<>();
8.  
9. public String getName() {
10. return name;
11. }
12.  
13. public void setName(String name) {
14. this.name = name;
15. }
16.  
17. public String getAge() {
18. return age;
19. }
20.  
21. public void setAge(String age) {
22. this.age = age;
23. }
24.  
25.  
26. @Override
27. public void addObserver(AbstractObserverDTO abstractObserverDTO) {
28. abstractObserverDTOS.add(abstractObserverDTO);
29. }
30.  
31. @Override
32. public void delObserver(AbstractObserverDTO abstractObserverDTO) {
33. abstractObserverDTOS.remove(abstractObserverDTO);
34. }
35.  
36. @Override
37. public void notice(MessageDTO messageDTO) {
38. if (abstractObserverDTOS == null || abstractObserverDTOS.size() == 0) {
39. return;
40. }
41. for (AbstractObserverDTO abstractObserverDTO : abstractObserverDTOS) {
42. abstractObserverDTO.updateMsg(messageDTO);
43. }
44. }
45.  
46. }

实现了被观察者的3个接口。具体的子类继承该抽象类，重写该类的接口。

1. public interface Observer {
2.  
3. /**
4. * 观察者更新的方法
5. *
6. * @param messageDTO
7. */
8. void updateMsg(MessageDTO messageDTO);
9.  
10. }

观察者抽象接口：主要是当被观察发生变更时，调用该方法通知观察者

观察者抽象类,实现了观察者首相接口

1. public class AbstractObserverDTO implements Observer {
2.  
3. private String name;
4.  
5. private Date date;
6.  
7. private List<AbstractObserverDTO> abstractObserverDTOS = new ArrayList<>();
8.  
9.  
10. public String getName() {
11. return name;
12. }
13.  
14. public void setName(String name) {
15. this.name = name;
16. }
17.  
18. public Date getDate() {
19. return date;
20. }
21.  
22. public void setDate(Date date) {
23. this.date = date;
24. }
25.  
26.  
27. @Override
28. public void updateMsg(MessageDTO messageDTO) {
29. System.out.println(this.name + ":" + messageDTO.getName() + ":" + messageDTO.getMessage());
30. }
31. }

具体当观察者子类继承该类，并重写该方法。

消息对象

1. public class MessageDTO {
2.  
3. private String message;
4.  
5. private Integer type;
6.  
7. private String name;
8.  
9. public String getMessage() {
10. return message;
11. }
12.  
13. public void setMessage(String message) {
14. this.message = message;
15. }
16.  
17. public Integer getType() {
18. return type;
19. }
20.  
21. public void setType(Integer type) {
22. this.type = type;
23. }
24.  
25. public String getName() {
26. return name;
27. }
28.  
29. public void setName(String name) {
30. this.name = name;
31. }
32. }

别观察者子类

1. public class BeObserverOneDTO extends AbstracBeObserverDTO {
2.  
3. private String note;
4.  
5. public String getNote() {
6. return note;
7. }
8.  
9. public void setNote(String note) {
10. this.note = note;
11. }
12. }

观察者子类1

1. public class ObserverOneDTO extends AbstractObserverDTO {
2.  
3. private String note;
4.  
5. public String getNote() {
6. return note;
7. }
8.  
9. public void setNote(String note) {
10. this.note = note;
11. }
12.  
13.  
14. @Override
15. public void updateMsg(MessageDTO messageDTO) {
16. System.out.println(this.note + ":" + messageDTO.getName() + ":" + messageDTO.getMessage());
17. }
18.  
19. }

观察者子类2

1. public class ObserverTwoDTO extends AbstractObserverDTO {
2.  
3. private String note;
4.  
5. private String sex;
6.  
7.  
8. public String getNote() {
9. return note;
10. }
11.  
12. public void setNote(String note) {
13. this.note = note;
14. }
15.  
16. public String getSex() {
17. return sex;
18. }
19.  
20. public void setSex(String sex) {
21. this.sex = sex;
22. }
23.  
24. @Override
25. public void updateMsg(MessageDTO messageDTO) {
26. System.out.println(this.note + ":" + messageDTO.getName() + ":" + messageDTO.getMessage());
27. }
28. }

测试

1. public class TestMain {
2.  
3. public static void main(String[] args) {
4.  
5. ObserverOneDTO one = new ObserverOneDTO();
6. one.setNote("粉丝1");
7.  
8. ObserverTwoDTO two = new ObserverTwoDTO();
9. two.setNote("粉丝2");
10. two.setSex("女");
11.  
12. BeObserverOneDTO beObserverOneDTO = new BeObserverOneDTO();
13. beObserverOneDTO.setNote("zuiaicy");
14. beObserverOneDTO.setName("zuiaicy有博客更新");
15. beObserverOneDTO.addObserver(one);
16. beObserverOneDTO.addObserver(two);
17.  
18.  
19. MessageDTO messageDTO = new MessageDTO();
20. messageDTO.setMessage("设计模式之观察者模式");
21. messageDTO.setName(beObserverOneDTO.getName());
22. messageDTO.setType(1);
23.  
24. beObserverOneDTO.notice(messageDTO);
25.  
26.  
27. }
28. }

测试结果：

1. 粉丝1:zuiaicy有博客更新:设计模式之观察者模式
2. 粉丝2:zuiaicy有博客更新:设计模式之观察者模式

优化： 
1> 被观察者的订阅列表(观察者列表)可以存数据库。 
2> 被观察者发生变更时，可以通过异步方式调用观察者的更新接口。 
3> 许多地方还可以做得更加抽象。

4.观察者模式的优缺点？ 
优点： 
1> 面向接口编程的思想 
2> 松耦合，改变了一方，不会影响到另一方。 
3> 观察者模式可以实现表示层和数据逻辑层的分离，定义了稳定的消息更新传递机制，并抽象了更新接口，使得可以有各种各样不同的表示层充当具体观察者角色。 
4> 观察者模式支持广播通信，观察目标会向所有已注册的观察者对象发送通知，简化了一对多系统设计的难度。 
5> 观察者模式满足“开闭原则”的要求，增加新的具体观察者无须修改原有系统代码，在具体观察者与观察目标之间不存在关联关系的情况下，增加新的观察目标也很方便。 
不足： 
1> 如果一个观察目标对象有很多直接和间接观察者，将所有的观察者都通知到会花费很多时间。 
2> 如果在观察者和观察目标之间存在循环依赖，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 
3> 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。