6.观察者模式

2019-10-19更新

更新内容：

1. 观察者模式的清楚定义
2. 观察者模式的组件介绍
3. 从0-1搭建观察者模式（具体步骤）
4. 观察者模式的应用场景

1.观察者模式是什么？

观察者模式：它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主题是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。

2.观察者模式组件介绍

一般来说，观察者模式中有四个组件，Observer(主动观察者，订阅者) Obserable(被订阅者，主题) ObserverImpl(具体的订阅者) ObserableImpl(被动订阅者的具体实现)

3.从0-1搭建观察者模式（具体步骤）

问题背景：一个课程互动产品中，要实现学生在某个课程中提出一个问题之后，老师需要收到通知
模型分析：课程是Obserable的一个具体实现，老师是主动观察者（Observer的一个具体实现）

说明：1-2步骤在实际的编写代码中可以忽略，因为JDK中提供了Obserable 类和Observer接口
//1.编写抽象的Observerable，需要包含以下基本内容
//下述Obserable只是一个例子，要想系统了解请查看JDK Obserable类源码
public interface Obserable {	  
    	private Vector<Observer> obs;
	    void addObserver(Observer o) {}
	    void notifyOne(Observer o){}
	    void notifyAll(){}
    }
}
//2.编写抽象的Observer
public interface Observer{
	//用于通知消息，进行的逻辑处理
	public void update(){}
}
-----以下使用的Observable,Observer是JDK中提供的
//3.编写具体的Obserable(Course)
public class Course extends Observable {
    Question question = null;
    public String name ;
    @Override
    public void addObserver(Observer obs) {
        super.addObserver(obs);
    }
    public Course(String name){
        this.name = name;
    }
    public void productQuestion(Question question) {
        this.question = question;
        setChanged();
        notifyObservers();
    }
}
//4.编写具体的Observer(Teacher)
public class Teacher implements Observer {
    public String name ;
    public Teacher(String name){
        this.name = name;
    }
    @Override
    public void update(Observable o, Object arg) {
        Course course = (Course)o;
        System.out.println(course.name+"产生了一个问题:"+course.question.getDetail());
    }
}
//5.编写其他类
public class Question {
    private String detail;
    public Question(String detail) {
        this.detail = detail;
    }
    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }
}
//6.编写测试类
public class Main {
    public static void main(String[] args) {
        Course course = new Course("黑客从入门到入狱");
        Teacher teacher = new Teacher("Lilly");
        Question question = new Question("学完真的会入狱吗？");
        course.addObserver(teacher);
        course.productQuestion(question);
    }
}
运行结果：黑客从入门到入狱产生了一个问题:学完真的会入狱吗？

4.应用场景：

1、当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
2、当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象需要被改变。
3、当一个对象必须通知其他对象，而它又不能假定其他对象是谁。换言之，不希望这些对象是紧密耦合的

2019-10-19更新

---

2019-9-19初次编辑

（学习者可不看以下内容，以下内容仅是记录个人博客的痕迹）

观察者模式

观察者模式也叫发布订阅模式
**组成：**Observer(主动观察者)，被订阅者（Observable）
当Observable发生状态更新时，会提醒Observer
如何实现此模式：
背景：有一个在线视频教育系统，里面有两个角色（Teacher,Student)
有课程(Course) 每个课程都会有各种各样的问题。如果学生针对某个课程提出问题后，老师会收到通知。
UML图

Java中如何实现：
1.借助java.util.Observable,java.util.Observer

A.定义一个课程，课程为Observable(被订阅者)

public class Course  extends Observable {
    List<Teacher> list = new ArrayList<>();
    Question question = null;
    public String name;

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

    @Override
    public void addObserver(Observer obj) {
        super.addObserver((Teacher) obj);//添加订阅者
    }
//当产生具体问题时，通知订阅者们，并且传递参数（具体的课程问题给订阅者（老师））
    public void productQuestion(Question ques) {
        this.question = ques;
        setChanged();//为Observable中的方法，用于修改其属性change的值，只有当change==true时notifyObservers（）才可执行
        notifyObservers(ques);
    }

}

B.定义一个Observer的实现类(Teacher,负责接受课程中出现的问题)

public class Teacher implements Observer {
    public String name;

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

    @Override
    public void update(Observable o, Object arg) {
        Course course = (Course) o;
        Question question = (Question) arg;
        System.out.println(course.name + "提出一个问题" + question.getDetail() + "老师：" + name + "将解答");
    }
}

C.定义一个Question,表明课程中可能会遇到的具体问题

public class Question {
    public String detail;

    public Question(String detail) {
        this.detail = detail;
    }

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }
}

D.测试类

public class Main {
    public static void main(String[] args) {
        Course course = new Course("Java课程");
        Question question = new Question("Java难不难啊老师");
        course.addObserver(new Teacher("tigpan"));
        course.productQuestion(question);//Java课程提出一个问题Java难不难啊老师老师：tigpan将解答
    }
}

2.自己实现Observable，Observer去搭建一个观察者模式demo
因为Observable是一个抽象类，所以我们有必要自定义一个Observable接口去取代java.util.Observable，在此不予实现。