观察者模式
在处理类之间的多对一的依赖关系时,观察者设计模式应运而生了,它的出现实现了代码的瘦身,类之间的解耦,本文分三部分:
- 非观察者模式的多对一的依赖处理
- 观察者模式对多对一依赖处理的优化
- Java内置的观察者
假设场景: 前端用户向后端服务器发送不同的请求，后端的Selector区的分不同的请求，回调不同的Handler处理请求, 下面的示例代码
非观察者
当Selector发现数据改变时,想要回调Handler的方法的前提是它要维护一个Handler的引用, 我们在构造函数中传递进去
@Data
public class Selector {
private String username;
private String password;
private Handler1 currentConditions;
public Selector(Handler1 currentConditions) {
this.currentConditions = new Handler1();
}
public void datachange() {
currentConditions.update(getUsername(),getPassword());
}
// 添加假数据
public void setData(String username,String password){
this.username=username;
this.password=password;
datachange();
}
}
Handkler 的成员变量和Selector一样, 同时真正干活的人是handler, 它里面只有干活的方法以及承载数据的字段, 干活的方法会被回调, 字段由Selector负责初始化
public class Handler1 {
private String username;
private String password;
public void update( String username, String password){
this.username=username;
this.password=password;
display();
}
public void display(){
System.out.println("Handler1 : username"+ username);
System.out.println("Handler1 : password"+username);
}
}
测试:
public class text {
public static void main(String[] args) {
Handler1 currentConditions = new Handler1();
Selector Data = new Selector(currentConditions);
Data.setData("张三","123");
}
}
上面的设计方法实现了,当Selector发现新的数据改变时,回调指定的handler的需求,但是缺点很快就暴露出来, Handler引用以构造方法的形式在Selector维护,如果有100个handler, 是不是意味着Selector的构造函数重载100份?
观察者模式
观察者解决了上面的问题,在观察者模式中有两个角色的划分,1.SubJect 2.Observer, 其中 SubJect负责回调Observer提供的方法处理数据, Observer就是观察者,伺机而动, 它之所以能够实现两者的解耦,实现代码的瘦身,精华就是在Subject的构造函数不再维护单一的某一个Observer的引用,而是一个泛型是为Observer类型的集合, 为了防止把非观察者的对象添加到集合中, 故 在原有的基础上,向上进行了一层抽象,把Subject和Observer设计成接口,Subject提供了注册/移除/通知观察者的方法,通知哪个方法呢? 于是Observer接口中提供了需要被回调的抽象方法, 做完这层封装之后,就有了这个观察者体系, 所有的观察者必须实现Observer接口,重写它的方法,任何回调观察者的类,也必须实现Subject,重写它的方法
实例代码:
public interface Subject {
public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObserver();
}
public interface Observer {
public void update(String m,String p);
}
Subject的实现类:
@Data
public class Selector implements Subject {
private String username;
private String password;
private ArrayList<Observer> list;
public Selector() {
this.list = new ArrayList<Observer>();
}
// 添加假数据
public void setData( String username, String password){
this.username=username;
this.password=password;
}
@Override
public void registerObserver(Observer o) {
list.add(o);
}
@Override
public void removeObserver(Observer o) {
list.remove(o);
}
@Override
public void notifyObserver() {
list.forEach(s->s.update(getPassword(),getUsername()));
}
}
Observer的实现:
public class Handler1 implements Observer {
private String username;
private String password;
@Override
public void update( String username,String password){
this.username=username;
this.password=password;
display();
}
public void display(){
System.out.println(" Handler1 "+ username);
System.out.println(" Handler1 "+password);
}
}
测试:
public class text {
public static void main(String[] args) {
Handler1 secondConditions = new Handler1();
Selector Data = new Selector();
// 注册观察者
Data.registerObserver(secondConditions);
Data.setData("张三","123");
Data.notifyObserver();
}
}
我们自己实现的观察者函数回调的特性: : 虽然实现我们一开始的需求，但是可以看到，数据是在Subject端进行初始化的, 并没有传递到观察端,由观察者自主分配数据
java内置的观察者
java内置的观察中同样分为两种角色,1.Obserable 2.Observer 其中Observer是观察者,同样不变的是,他是个接口
但是: Obserable是一个抽象类, java为我们实现了 注册/移除,通知的方法, 在不允许多继承的java中,抽象类是有缺点的,这使得当前类不能再继承其他类
此外: 相对于我们自定义的观察者, 它做到了把数据传递到 观察者客户端,任由观察者自主的分配这些数据
如何使用:
对于Obserable来说, 继承他
- 由于java实现了主要的方法, 我们只关注如何使用这几个方法就行了
- 1: 在回调之前 , 必须先使用
this.setChanged();否则信息不会通知到观察者 - 2: 通知的方法
this.notifyObservers(Object obj));
@Data
public class Selector extends Observable {
private String username;
private String password;
// 添加假数据
public void setData( String username, String password) {
this.username = username;
this.password = password;
datachange();
}
// 当信息更改, 就推送
public void datachange() {
// todo 加上这一条,当有信息改变时, 就执行
this.setChanged();
// 通知时,把信息同步推送给观察者
this.notifyObservers(new Data(getUsername(),getPassword()));
}
@lombok.Data
public class Data {
private String username;
private String password;
public Data( String username, String password) {
this.username = username;
this.password = password;
}
}
}
观察者: 继承Observer, 重写它被回调的方法
public class Handler1 implements Observer {
private String username;
private String password;
@Override
public void update(Observable observable, Object arg0) {
this.password = ((Selector.Data) (arg0)).getPassword();
this.username = ((Selector.Data) (arg0)).getUsername();
display();
}
public void display() {
System.out.println("Handler1 : " + username);
System.out.println("Handler1 : " + password);
}
}
测试
public class text {
public static void main(String[] args) {
Handler1 handler1 = new Handler1();
Selector weatherData = new Selector();
// 先注册的观察者,后执行
weatherData.addObserver(handler1);
weatherData.setData("张三","123");
}
}
