观察者模式—行为型

创建型

结构型

5，代理设计模式
 6，桥接设计模式
 7，装饰设计模式
 8，适配器设计模式
 9，外观设计模式
 10，享元设计模式
 11，组合设计模式

行为型

前言

常把 23 种经典的设计模式分为三类：创建型、结构型、行为型。前面已经学习了创建型和结构型，从这篇起开始学习行为型设计模式。前面讲到了创建型设计模式主要解决“对象的创建”问题，结构型设计模式主要解决“类或对象的组合或组装”问题，那行为型设计模式主要解决的就是“类或对象之间的交互”问题。

简介

观察者模式（Observer Design Pattern）也被称为发布订阅模式（Publish-Subscribe Design Pattern），定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会的到通知并自动更新；

UML图

Subject：抽象主题，也是被观察（Observable）的角色，每个主题可以有任意数量的观察者，抽象主题提供接口，可以增加和删除观察者对象；

ConcreteSubject:具体主题，当具体主题的内部状态放生改变时，给所有的注册过的观察者发通知，具体主题也叫具体别观察者（Concrete Observable）角色；

Observer：抽象观察者，该角色是观察者的接口，它定义了一个更新接口，使得在得到主题的更改通知时更新自己；

ConcreteObserver:具体贯彻着，实现抽象抽象观察者角色所定义的更新接口，以便在主题的状态发生变化时更新自身的状态；

模板代码实现

Subject：

public interface Subject {
    void registerObserver(Observer observer); 
    void removeObserver(Observer observer); 
    void notifyObservers(Message message);
}

Observer


public interface Observer { 
    void update(Message message);
}

ConcreteSubject

public class ConcreteSubject implements Subject {  
    private List<Observer> observers = new ArrayList<Observer>();  
    @Override  
    public void registerObserver(Observer observer) {    
        observers.add(observer);  
    }  
    @Override 
    public void removeObserver(Observer observer) {  
          observers.remove(observer); 
    }  
    @Override 
    public void notifyObservers(Message message) {    
        for (Observer observer : observers) {     
             observer.update(message);    
        }  
    }
}

ConcreteObserver

public class ConcreteObserverOne implements Observer {  
    @Override  
    public void update(Message message) {    
    //TODO: 获取消息通知，执行自己的逻辑...    
        System.out.println("ConcreteObserverOne is notified.");  
    }
}

public class ConcreteObserverTwo implements Observer {  
    @Override  
    public void update(Message message) {    
        //TODO: 获取消息通知，执行自己的逻辑...    
        System.out.println("ConcreteObserverTwo is notified.");  
    }
}

使用：

public class Demo {  
    public static void main(String[] args) {    
        ConcreteSubject subject = new ConcreteSubject();    
        subject.registerObserver(new ConcreteObserverOne());   
        subject.registerObserver(new ConcreteObserverTwo());   
        subject.notifyObservers(new Message()); 
    }
}

上面的代码算是观察者模式的"模板代码"，只能反映大体的设计思路。在真实的软件开发中，并不需要照搬上面的模板代码。

JavaAPI实现观察者模式

Java中JDK中也内置了Observable和Observer类型，可见观察者模式的重要性；Observable是抽象主题（Subject）的角色，Observer是抽象观察者角色；

ConcreteSubject

public class DouYin extends Observable {
    public void postNewPublication(String data) {
        setChanged();
        notifyObservers(data);
    }
}

ConcreteObserver

public class User implements Observer {
    private static String TAG = char.class.getSimpleName();

    private String name;

    public User(String name) {
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Hi" + name + "你关注的 更新了，内容：" + arg);
    }
}

使用

public class Test {
    public static void main(String[] args) {
        //观察者
        User coder = new User("张三");

        //被观察者
        DouYin frontier = new DouYin();

        frontier.addObserver(coder);
        frontier.postNewPublication("发布了新视频");
    }
}

以上实现都是同步阻塞的方式，观察者和被观察者代码在同一个线程内执行，被观察者一直阻塞，直到所有的观察者代码都执行完成之后，才执行后续的代码。如何实现异步非阻塞的呢，在每个 update() 函数中，创建一个新的线程执行代码。这是最简单的而是方式；但是不管是同步阻塞实现方式还是异步非阻塞实现方式，都是进程内的实现方式。那如何实现一个跨进程的观察者模式呢？在 update() 函数中实现进程间通信；