一、定义
当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。
二、主要解决
一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作
三、优缺点
1、优点
观察者和被观察者是抽象耦合的。
建立一套触发机制。
2、缺点
目标与观察者之间的依赖关系并没有完全解除,而且有可能出现循环引用。
当观察者对象很多时,通知的发布会花费很多时间,影响程序的效率。
四、主要角色
- 抽象主题(Subject)角色:也叫抽象目标类,它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法,以及通知所有观察者的抽象方法。
- 具体主题(Concrete Subject)角色:也叫具体目标类,它实现抽象目标中的通知方法,当具体主题的内部状态发生改变时,通知所有注册过的观察者对象。
- 抽象观察者(Observer)角色:它是一个抽象类或接口,它包含了一个更新自己的抽象方法,当接到具体主题的更改通知时被调用。
- 具体观察者(Concrete Observer)角色:实现抽象观察者中定义的抽象方法,以便在得到目标的更改通知时更新自身的状态。
五、代码结构
package obersver.v1;
import java.util.ArrayList;
import java.util.List;
/**
* @Package: obersver.v1
* @ClassName: Subject
* @Author: tanp
* @Description: 也叫抽象目标类,它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法,以及通知所有观察者的抽象方法
* @Date: 2020/11/20 9:22
*/
public abstract class Subject {
/**
* 观察者集合
*/
List<Oberserver> list = new ArrayList<Oberserver>();
/**
* @Description 增加观察者
* @Author tanp
*/
public void add(Oberserver oberserver) {
list.add(oberserver);
}
public void remove(Oberserver oberserver){
list.remove(oberserver);
}
/**
* @Description 通知观察者的方法
* @Author tanp
*/
public abstract void notifyObserver();
}
package obersver.v1;
/**
* @Package: obersver.v1
* @ClassName: ConcreteSubject
* @Author: tanp
* @Description: 具体目标类,它实现抽象目标中的通知方法,当具体主题的内部状态发生改变时,通知所有注册过的观察者对象
* @Date: 2020/11/20 9:29
*/
public class ConcreteSubject extends Subject{
@Override
public void notifyObserver() {
for(Oberserver oberserver : super.list){
//每个具体的观察类执行相对应的方法
oberserver.update();
}
}
}
package obersver.v1;
/**
* @Package: obersver.v1
* @ClassName: Oberserver
* @Author: tanp
* @Description: 抽象观察者(Observer)角色:它是一个抽象类或接口,它包含了一个更新自己的抽象方法,当接到具体主题的更改通知时被调用
* @Date: 2020/11/20 9:22
*/
public interface Oberserver {
/**
* @Description 接到具体主题的更改通知时被调用的方法
* @Author tanp
*/
void update();
}
package obersver.v1;
/**
* @Package: obersver.v1
* @ClassName: ConcreteObserver
* @Author: tanp
* @Description: 具体观察者(Concrete Observer)角色:实现抽象观察者中定义的抽象方法,以便在得到目标的更改通知时更新自身的状态
* @Date: 2020/11/20 9:33
*/
public class ConcreteObserver implements Oberserver{
@Override
public void update() {
//do something
}
}
package obersver.v1;
/**
* @Package: obersver.v1
* @ClassName: DemoClient
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 9:35
*/
public class DemoClient {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
Oberserver oberserver = new ConcreteObserver();
//将观察者添加到需要通知的观察者列表中
subject.add(oberserver);
//通知观察者
subject.notifyObserver();
}
}
六、代码案例
现在先引入一个案例,那就是老师通知交作业了,小王和小红就把作业交上去了,在这个案例里老师为目标类,小红,小王为具体观察者
package obersver.v2;
import java.util.ArrayList;
import java.util.List;
/**
* @Package: obersver.v2
* @ClassName: Teacher
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 9:45
*/
public class Teacher {
List<Student> studentList = new ArrayList<Student>();
public void add(Student student){
studentList.add(student);
}
public void notifyStuden(){
System.out.println("同学们收作业了");
for(Student student : studentList){
student.didWork();
}
}
}
package obersver.v2;
/**
* @Package: obersver.v2
* @ClassName: Student
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 9:45
*/
public interface Student {
/**
* @Description 完成作业并上交
* @Author tanp
*/
void didWork();
}
package obersver.v2;
/**
* @Package: obersver.v2
* @ClassName: XiaoHong
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 9:51
*/
public class XiaoHong implements Student {
@Override
public void didWork() {
System.out.println("小红完成并上交作业");
}
}
package obersver.v2;
/**
* @Package: obersver.v2
* @ClassName: XiaoWang
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 9:50
*/
public class XiaoWang implements Student {
@Override
public void didWork() {
System.out.println("小王完成并上交作业");
}
}
package obersver.v2;
/**
* @Package: obersver.v2
* @ClassName: DemoClient
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 9:52
*/
public class DemoClient {
public static void main(String[] args) {
//新建目标类
Teacher teacher = new Teacher();
//新建观察者
Student xiaowang = new XiaoWang();
Student xiaohong = new XiaoHong();
//添加观察者
teacher.add(xiaohong);
teacher.add(xiaowang);
teacher.notifyStuden();
}
}
七、jdk实现的观察者模式
在 Java 中,通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式,只要实现它们的子类就可以编写观察者模式实例。
1. Observable类
Observable 类是抽象目标类,它有一个 Vector 向量,用于保存所有要通知的观察者对象,下面来介绍它最重要的 3 个方法。
- void addObserver(Observer o) 方法:用于将新的观察者对象添加到向量中。
- void notifyObservers(Object arg) 方法:调用向量中的所有观察者对象的 update() 方法,通知它们数据发生改变。通常越晚加入向量的观察者越先得到通知。
- void setChange() 方法:用来设置一个 boolean 类型的内部标志位,注明目标对象发生了变化。当它为真时,notifyObservers() 才会通知观察者。
2. Observer 接口
Observer 接口是抽象观察者,它监视目标对象的变化,当目标对象发生变化时,观察者得到通知,并调用 void update(Observable o,Object arg) 方法,进行相应的工作。
3、jdk观察者模式案例
案例还是用老师,同学交作业的
package obersver.v3;
import java.util.Observable;
/**
* @Package: obersver.v3
* @ClassName: Teacher
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 10:21
*/
public class Teacher extends Observable {
/**
* @Description 老师收作业
* @Author tanp
*/
public void getWork(String type) {
System.out.println("同学们收" + type + "作业了");
//注明目标对象发生了变化
super.setChanged();
//调用向量中的所有观察者对象的 update() 方法,通知它们数据发生改变。通常越晚加入向量的观察者越先得到通知
super.notifyObservers(type);
}
}
package obersver.v3;
import java.util.Observable;
import java.util.Observer;
/**
* @Package: obersver.v3
* @ClassName: XiaoHong
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 10:33
*/
public class XiaoHong implements Observer {
@Override
public void update(Observable o, Object arg) {
System.out.println("小红交了" + arg.toString() + "作业");
}
}
package obersver.v3;
import java.util.Observable;
import java.util.Observer;
/**
* @Package: obersver.v3
* @ClassName: XiaoWang
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 10:27
*/
public class XiaoWang implements Observer {
@Override
public void update(Observable o, Object arg) {
System.out.println("小王交了" + arg.toString() + "作业");
}
}
package obersver.v3;
/**
* @Package: obersver.v3
* @ClassName: DemoClient
* @Author: tanp
* @Description: ${description}
* @Date: 2020/11/20 10:34
*/
public class DemoClient {
public static void main(String[] args) {
//定义目标类
Teacher teacher = new Teacher();
//定义观察者
XiaoHong xiaoHong = new XiaoHong();
XiaoWang xiaoWang = new XiaoWang();
//添加观察者
teacher.addObserver(xiaoHong);
teacher.addObserver(xiaoWang);
teacher.getWork("语文");
}
}
结果
从上面的代码我们可以发现,通过jdk实现的观察者模式代码,我们其实就是省略了抽象主题和抽象观察者角色,而我们只要再自己的实现类中实现自己的业务逻辑即可