观察者模式--彻底理解运用Java设计模式之观察者模式

    定义与意义：

      观察者模式是对象的行为模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 我们又把这种模式成为发布--订阅模式（Publish/Subscribe）或者模型-视图模式（Model/View）模式。该模式的最重要作用是解耦，将被观察者和观察者进行解耦，使得它们的依赖性更小，甚至做到无依赖。

     实例实现

       我们假定一个场景，在一个图书管理系统中，现在有这么一个需求，部分读者希望在图书馆添加新书的时候能够收到通知。于是这些读者就订阅该功能。而当图书馆添加新书的时候，系统会自动将新书的信息发送给订阅的读者。 
　　上面这个场景就是典型的观察者模式。对于读者我们可以称为观察者，而图书管理系统则可以作为被观察者。在图书管理系统（被观察者）中去添加注册需要接收通知的读者（观察者）。这时候在系统中添加新书后，系统便会通知在系统注册该功能的读者。下面看一下代码实现。 

        首先我们创建一个观察者接口。

package demo.springboot.web;

/**
 * @author 
 * @date 2018/12/25 16:08
 */
//观察者接口
public interface Observer {
    public void update(Object object);
}

         紧接着我们在创建一个被观察者，对于被观察者，里面的功能实现必然有添加一个观察者，删除观察者，通知更新观察者这三个公共方法，于是我们可以写一个抽象类。

package demo.springboot.web;

import java.util.Vector;

/**
 * @author 
 * @date 2018/12/25 16:09
 */
//被观察者的抽象类
public abstract class AbsObservable {
    //定义一个观察者数组
    private Vector<Observer> obVector = new Vector<>();

    //添加观察者
    public void addObserver(Observer ob){
        this.obVector.add(ob);
    }
    //删除观察者
    public void  deleObserver(Observer ob){
        this.obVector.remove(ob);
    }
    //通知所有观察者
    public void notifyAllObserver(Book book){
        for(Observer obs : obVector){
            obs.update(book);
        }

    }
}

下面我们就来实现上述场景。既然是图书管理系统，我们首先需要创建一个Book类（上面抽象类中的Book引用的即为即将创建的类）。

package demo.springboot.web;

/**
 * 
 * @date 2018/12/25 16:19
 */
public class Book {
    //书名
    public String bookName;
    //作者
    public String author;

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Book(String bookName, String author) {
        this.bookName = bookName;
        this.author = author;
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", author='" + author + '\'' +
                '}';
    }
}

  下面创建一个Library类，由于这个Library作为被观察者，我们使其继承自抽象类AbsObservable

package demo.springboot.web;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @date 2018/12/25 16:22
 */
public class Library extends AbsObservable {
    //使用list用于存放图书
    private List<Book> bookList;

    public Library() {
        // TODO Auto-generated constructor stub
        this.bookList = new ArrayList<>();
        //添加两本书
        Book ShuiHu = new Book("水浒传","施耐庵");
        Book HongLou = new Book("红楼梦", "曹雪芹");
        this.bookList.add(ShuiHu);
        this.bookList.add(HongLou);
    }


    public void addBook(Book book) {
        this.bookList.add(book);
        super.notifyAllObserver(book);
    }

    public void delBook(Book book) {
        this.bookList.remove(book);
    }

}

下面再创建两个读者类ReaderA，ReaderB。它们作为观察者，就叫他们实现Observer接口。 
 ReaderA如下

package demo.springboot.web;

/**
 * @date 2018/12/25 16:30
 */
public class ReaderA implements Observer {

    public ReaderA() {
    }

    @Override
    public void update(Object object) {
        System.out.println("我是读者A,收到了新书:" + object.toString());
    }
}

ReaderB如下

package demo.springboot.web;

/**
 * @date 2018/12/25 16:31
 */
public class ReaderB implements Observer {

    public ReaderB() {
    }

    @Override
    public void update(Object object) {
        System.out.println("我是读者B,收到了新书:" + object.toString());
    }
}

接下来，写个main函数，测试一下结果输出。

package demo.springboot.web;

/**
 * @date 2018/12/25 16:31
 */
public class TestObserver {
    public static void main(String[] args) {
        Library library = new Library();
        Observer readerAObserver = new ReaderA();
        Observer readerBObserver = new ReaderB();

        library.addObserver(readerAObserver);
        library.addObserver(readerBObserver);

        Book book = new Book("朝花夕拾", "鲁迅");
        library.addBook(book);
    }
}

输出结果如下所示：

 

观察者模式通用类图和通用代码

 首先我们看一下观察者模式的通用类图 

 

在这里对上面类图中的角色进行一下详细介绍

Subject:抽象主题，也就是上面的被观察者(Observable)角色。Subject把所有观察者对象的引用保存在一个集合里，并且能够动态的增加、取消观察者。
Observer:抽象观察者，他是观察者的抽象类，在这里定义个一个更新的接口，目的就是为了在接收到被观察者的更改通知是更新自己。
ConcreteSubject:具体主题，也就是具体的被观察者，在上面对应于Library类。在ConcreteSubject里面定义一些被观察者自己的业务逻辑，当ConcreteSubject内部状态发生改变时，给所有注册过的观察者发送通知。
ConcreteObserver:具体观察者，ConcreteObserver实现了抽象观察者所定义的更新接口，再被观察者通知改变是更新自身状态。 

下面我们就来看一下观察者模式的通用代码。 
Subject（被观察者类）

package demo.springboot.web.observer;

import java.util.Vector;

/**
 * @date 2018/12/25 17:02
 */
public abstract class Subject {

    //定义一个观察这数组
    private Vector<Observer> obVector = new Vector<>();

    //添加一个观察者
    public void addObserver(Observer observer) {
        this.obVector.add(observer);
    }

    //删除一个观察者
    public void delObserver(Observer observer) {
        this.obVector.remove(observer);
    }

    //通知所有观察者
    public void notifyObservers() {
        for (Observer observer : obVector) {
            observer.update();
        }
    }
}

ConcreteSubject（具体被观察者）

package demo.springboot.web.observer;

/**
 * @date 2018/12/25 17:04
 */
public class ConcreteSubject extends  Subject {
    // 具体业务
    public void doSomething() {
        super.notifyObservers();
    }
}

Observer（观察者类）

package demo.springboot.web.observer;

/**
 * @date 2018/12/25 17:05
 */
public interface Observer {
    public void update();
}

ConcreteObserver（具体观察者类）

package demo.springboot.web.observer;

/**
 * @date 2018/12/25 17:06
 */
public class ConcreteObserver implements Observer {
    public ConcreteObserver() {
        // TODO Auto-generated constructor stub
    }
    //实现更新方法
    @Override
    public void update() {
        // TODO Auto-generated method stub
        System.out.println("我已接收到消息");
    }
}

　Client（场景类）

package demo.springboot.web.observer;

/**
 * @date 2018/12/25 17:06
 */
public class Client {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer = new ConcreteObserver();
        subject.addObserver(observer);
        subject.doSomething();
    }
}

  Java对观察者模式提供的支持

   在java.util库里面，提供了一个Observable类和一个Observer接口。下面我们就来看一下这个Observable类和Observer接口。 
    Observer接口 
    在Observer接口中只提供了一个update方法，在被观察者发生变化时通过notifyObservers方法通知观察者做出改变，也就是执行了update方法。

package java.util;

public interface Observer {
    void update(Observable o, Object arg);
}

　Observable类 
　下面被观察者类也是为我们提供了对于观察者添加，删除，通知观察者改变等方法。当我们的需要通知观察者并且需要调用观察者update方法，我们需要调用setChanged方法。

package java.util;

public class Observable {
    private boolean changed = false;  //标记此 Observable对象为已改变的对象

    private Vector<Observer> obs;

    public Observable() {
        obs = new Vector<>();
    }

    /**
     * 添加观察者
     */
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    /**
     * 删除观察者
     */
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    public void notifyObservers() {
        notifyObservers(null);
    }

     /**
     * 如果当前Observable对象有变化（那时hasChanged 方法会返回true）
     * 调用这个方法通知所有登记的观察者，即调用它们的update()方法
     * 传入Observer和arg作为参数
     */
    public void notifyObservers(Object arg) {

        Object[] arrLocal;

        synchronized (this) {

            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    /**
     * 删除所有的观察者
     */
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    /**
     *将此Observable对象标记为已改变
     */
    protected synchronized void setChanged() {
        changed = true;
    }

    /**
     *将此Observable对象标记为未改变
     */
    protected synchronized void clearChanged() {
        changed = false;
    }

    /**
     *检测当前的Observable是否发生改变
     */
    public synchronized boolean hasChanged() {
        return changed;
    }

    /**
     * 观察者的数量
     */
    public synchronized int countObservers() {
        return obs.size();
    }
}

 

　　下面我们就用Java为我们提供的接口来实现我们文章开始所假定的场景。 
　　Library类（注意：已标注了更改处。）

package demo.springboot.web;

import java.util.ArrayList;
import java.util.List;
//更改处：1
import java.util.Observable;

/**
 * @date 2018/12/25 16:22
 */
//更改处：2
public class Library extends Observable {
    //使用list用于存放图书
    private List<Book> bookList;

    public Library() {
        // TODO Auto-generated constructor stub
        this.bookList = new ArrayList<>();
        //添加两本书
        Book ShuiHu = new Book("水浒传","施耐庵");
        Book HongLou = new Book("红楼梦", "曹雪芹");
        this.bookList.add(ShuiHu);
        this.bookList.add(HongLou);
    }


    public void addBook(Book book) {
        //更改处3：重要
        super.setChanged();
        this.bookList.add(book);
        //更改处：4
        super.notifyObservers(book);
    }

    public void delBook(Book book) {
        this.bookList.remove(book);
    }

}

　当我们添加一本书的时候，也就是addBook方法内，我们调用了父类setChanged方法，这样才能够执行观察者的update方法。对于具体观察者Reader我们只需要实现java.util中的Observer接口即可。ReaderB与ReaderA一样

package demo.springboot.web;

import java.util.Observable;
//更改处：1
import java.util.Observer;

/**
 * @date 2018/12/25 16:30
 */
//更改处：2
public class ReaderA implements Observer {

    public ReaderA() {
    }

//    @Override
//    public void update(Object object) {
//        System.out.println("我是读者A,收到了新书:" + object.toString());
//    }

    @Override
    //更改处：3
    public void update(Observable o, Object object) {
        System.out.println("我是读者A,收到了新书:" + object.toString());
    }
}

测试上述程序，代码及结果如下所示：

package demo.springboot.web;
import java.util.Observer;

/**
 * @date 2018/12/25 16:31
 */
public class TestObserver {
    public static void main(String[] args) {
        Library library = new Library();
        Observer readerAObserver = new ReaderA();
        Observer readerBObserver = new ReaderB();

        library.addObserver(readerAObserver);
        library.addObserver(readerBObserver);

        Book book = new Book("朝花夕拾", "鲁迅");
        library.addBook(book);
        System.out.println("hahaha");
    }
}

END

注：文章转载自Java设计模式之观察者模式--无嘴小呆子

对其中的代码自己手动输入执行了一次，且更改了部分文字输入错误部分以及容易让人困惑的类名。该文讲解观察者模式清晰透彻，值得推荐！