设计模式之观察者模式(Java实现)

左手的ㄟ右手 2024-04-20 08:09 137阅读 0赞
  1. 观察者模式是设计模式中常见的一种模式,他的思想犹如他的名字一样,就是想构建一个观察者观察他所关注的主题,当主题发生变化了,就会通知观察者。观察者模式也叫发布订阅模式,这种设计模式用在了很多地方,比如zookeeper的节点观察机制。
  2. 这里我们构建一个如下模型,Subject<-AbstractSubject<-TopSubject Observer<-Watcher,他们的关系如下图所示:

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70

通过java实现:

Observer.java

  1. package com.xxx.design.watcher;
  2. public interface Observer {
  3. void update();
  4. }

Watcher.java

  1. package com.xxx.design.watcher;
  2. /**
  3. * 观察者
  4. *
  5. */
  6. public class Watcher implements Observer {
  7. private String name;
  8. public Watcher(String name) {
  9. this.name = name;
  10. }
  11. @Override
  12. public void update() {
  13. System.out.println("watcher "+name+" update state.");
  14. }
  15. }

Subject.java

  1. package com.xxx.design.watcher;
  2. public interface Subject {
  3. void add(Observer observer);
  4. void delete(Observer observer);
  5. void notifyObserver();
  6. void action();
  7. }

AbstractSubject.java

  1. package com.xxx.design.watcher;
  2. import java.util.Enumeration;
  3. import java.util.Vector;
  4. public abstract class AbstractSubject implements Subject{
  5. private Vector<Observer> obs = new Vector<Observer>();
  6. @Override
  7. public void add(Observer observer) {
  8. obs.add(observer);
  9. }
  10. @Override
  11. public void delete(Observer observer) {
  12. obs.remove(observer);
  13. }
  14. @Override
  15. public void notifyObserver() {
  16. Enumeration<Observer> eles = obs.elements();
  17. while(eles.hasMoreElements()){
  18. eles.nextElement().update();
  19. }
  20. }
  21. }

TopSubject.java

  1. package com.xxx.design.watcher;
  2. public class TopSubject extends AbstractSubject {
  3. @Override
  4. public void action() {
  5. System.out.println("i am a subject,update now.");
  6. notifyObserver();
  7. }
  8. public static void main(String[] args) {
  9. Subject subject = new TopSubject();
  10. subject.add(new Watcher("aa"));
  11. subject.add(new Watcher("bb"));
  12. subject.add(new Watcher("cc"));
  13. subject.action();
  14. }
  15. }
  16. 运行程序,打印结果如下:
  17. i am a subject,update now.
  18. watcher aa update state.
  19. watcher bb update state.
  20. watcher cc update state.
  21. 观察者需要注意的是:避免循环引用,如果是顺序执行,考虑采用异步实现,避免因为一个处理异常导致整个系统卡壳。另外,现在java.util包中api已经提供了观察者模式的实现。我们可以利用Observable类和Observer接口来实现一个观察者模式:

Subscribe.java

  1. package com.xxx.design.watcher.jdk;
  2. import java.util.Observable;
  3. import java.util.Observer;
  4. public class Subscribe implements Observer {
  5. private String name;
  6. public Subscribe(String name){
  7. this.name = name;
  8. }
  9. public void add(Observable o){
  10. o.addObserver(this);
  11. }
  12. @Override
  13. public void update(Observable o, Object arg) {
  14. System.out.println(name+" 收到通知:"+((Publish)o).getData());
  15. }
  16. }

Publish.java

  1. package com.xxx.design.watcher.jdk;
  2. import java.util.Observable;
  3. public class Publish extends Observable {
  4. private String data = "";
  5. public String getData() {
  6. return data;
  7. }
  8. public void setData(String data) {
  9. if(!this.data.equals(data)){
  10. this.data = data;
  11. setChanged();
  12. }
  13. notifyObservers();
  14. }
  15. public static void main(String[] args) {
  16. Publish publish = new Publish();
  17. Subscribe subscribe = new Subscribe("aaa");
  18. subscribe.add(publish);
  19. Subscribe subscribe2 = new Subscribe("bbb");
  20. subscribe2.add(publish);
  21. publish.setData("start");
  22. publish.setData("end");
  23. }
  24. }

运行程序,打印信息如下:

  1. bbb 收到通知:start
  2. aaa 收到通知:start
  3. bbb 收到通知:end
  4. aaa 收到通知:end

发表评论

表情:
评论列表 (有 0 条评论,137人围观)

还没有评论,来说两句吧...

相关阅读

    相关 Java 设计模式观察模式

    一、了解观察者模式 1.1 什么是观察者模式 观察者模式定义了对象之间的一对多依赖,这样一来,当一个对象状态改变时,它的所有依赖者都会收到通知并自动更新。 典型的问

    相关 JAVA设计模式观察模式

    1、初步认识 观察者模式的定义:   在对象之间定义了一对多的依赖,这样一来,当一个对象改变状态,依赖它的对象会收到通知并自动更新。 大白话:   其实就是