23种设计模式第三部分关系模式（3）观察者模式

浅浅的花香味﹌ 2022-07-17 03:37 149阅读 0赞

![57a92d42-4d84-3aa9-a8b9-63a0b02c2c36.jpg][]

![5e2feb58-4170-3c07-a370-ed99bdcab223.jpg][]

## 理解 ##

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，她的所有依赖者都会受到通知并自动更新。

简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化。

![d588525c-fbad-3040-971c-69b2716c67a4.jpg][]

MySubject类就是我们的主对象（类似于期刊），Observer1和Observer2是依赖于MySubject的对象（类似于订阅者）。当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象。

## 实现    ##

subject接口和实现类：

public interface Subject {  
          
        /*增加观察者*/  
        public void add(Observer observer);  
          
        /*删除观察者*/  
        public void del(Observer observer);  
          
        /*通知所有的观察者*/  
        public void notifyObservers();  
          
        /*自身的操作*/  
        public void operation();  
    }

public abstract class AbstractSubject implements Subject {  
      
        private Vector<Observer> vector = new Vector<Observer>();  
        @Override  
        public void add(Observer observer) {  
            vector.add(observer);  
        }  
      
        @Override  
        public void del(Observer observer) {  
            vector.remove(observer);  
        }  
      
        @Override  
        public void notifyObservers() {  
            Enumeration<Observer> enumo = vector.elements();  
            while(enumo.hasMoreElements()){  
                enumo.nextElement().update();  
            }  
        }  
    }

public class MySubject extends AbstractSubject {  
      
        @Override  
        public void operation() {  
            System.out.println("update self!");  
            notifyObservers();  
        }  
      
    }

Observer接口和实现类：

public interface Observer {  
        public void update();  
    }

public class Observer1 implements Observer {  
      
        @Override  
        public void update() {  
            System.out.println("observer1 has received!");  
        }  
    }

public class Observer2 implements Observer {  
      
        @Override  
        public void update() {  
            System.out.println("observer2 has received!");  
        }  
    }

测试：

public class ObserverTest {  
      
        public static void main(String[] args) {  
            Subject sub = new MySubject();  
            sub.add(new Observer1());  
            sub.add(new Observer2());  
              
            sub.operation();  
        }  
    }

输出：

pdate self!
    observer1 has received!
    observer2 has received!

其实可以用java API内置的观察者模式，原理类似。

java.util包内包含最基本的Observer接口和Observable类，使用方便。可以支持pull或者 push两种方式。java.util.Observable中有两种notifyObservers()方法，一种是notifyObservers()，一种是notifyObservers(Object arg)，如果想“推”（push）数据给观察者，就可以吧数据当做数据对象传给notifyObservers(Object arg)方法。否则，观察者就必须从可观察对象中“拉”（pull）数据。

[57a92d42-4d84-3aa9-a8b9-63a0b02c2c36.jpg]: /images/20220717/d5ec2c757fb344f9ba2ad94c8e49587e.png
[5e2feb58-4170-3c07-a370-ed99bdcab223.jpg]: /images/20220717/9a20a61212b14915baffc2bf9882e11a.png
[d588525c-fbad-3040-971c-69b2716c67a4.jpg]: /images/20220717/9fece43a58fa4b2093d12f8eab8e5d6e.png