1，什么是觀察者模式
觀察者模式又叫做發布-訂閱模式，它定義了一種一對多的依賴關系
讓多個觀察者對象同時監聽一個主題對象。這個主題對象發生變化時，會通知所有觀察者對象，讓觀察者響應主題對象的變化。
2，觀察者模式的好處
在日常開發中，業務層通常需要業務數據發生改變的時候，讓界面層也做出相應的改變，在這里，界面層就是觀察者，業務層是被觀察者，通常有個做法就是在往業務層注入一個界面層實例，業務層數據發生改變就調用該實例對應的方法進行界面的刷新。但是這樣缺點很明顯，層與層之間緊密的耦合了起來，觀察者和被觀察者都依賴于具體實現，從根本上違反面向對象的設計的原則，而使用觀察者模式，就是來解決這種耦合的。
3，應用場景
當一個對象的改變需要同時改變其他對象，并且他不知道具體有多少對象有待改變時，可以使用觀察者模式來實現
緊密耦合的代碼
根據老師通知家長的場景模擬一下~
* 老師，被監聽者
* @author caizepeng
*
*/
public class Teacher {
private List<Parsents> parsentsList = new ArrayList<>();
public void attach(Parsents parsents){
parsentsList.add(parsents);
}
public void sendNotice(){
for(Parsents p :parsentsList){
p.notice("你孩子沒有來上課啊");
}
}
}
/**
* 家長，監聽者
* @author caizepeng
*
*/
public class Parsents {
private String name;
public Parsents(String name){
this.name = name;
}
public void notice(String msg){
System.out.println(name +" 接收到了 "+msg);
}
}
Parsents parsents = new Parsents("某家長");
Teacher teacher = new Teacher();
teacher.attach(parsents);
teacher.sendNotice();
缺點很明顯，觀察者和被觀察緊密的聯系在了一起，雙向耦合
我們應該將觀察者和被觀察者抽象出來
/**
* 被觀察者
* @author caizepeng
*
*/
public abstract class Subject {
private List<Observer> observers = new ArrayList<>();
public void attach(Observer observer){
observers.add(observer);
}
public void detach(Observer observer){
observers.remove(observer);
}
/**
* 發送通知，通知所有觀察者
*/
public void sendNotice(){
for(Observer observer : observers){
observer.notice();
}
}
}
/**
* 觀察者
* @author caizepeng
*
*/
public abstract class Observer {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void notice();
}
具體實現
/**
* 家長類
* @author caizepeng
*
*/
public class Parsents extends Observer {
@Override
public void notice() {
// TODO Auto-generated method stub
System.out.println(getName()+" 家長接受到了通知");
}
}
public class Student extends Observer{
@Override
public void notice() {
// TODO Auto-generated method stub
System.out.println(getName() +" 學生接收到了通知！");
}
}
教師類。。沒特殊需求的話，就是醬紫·
/**
* 老師
* @author caizepeng
*
*/
public class Teacher extends Subject {
}
test
Teacher teacher = new Teacher();
Student student = new Student();
student.setName("李四");
Parsents parsents = new Parsents();
parsents.setName("張三");
teacher.attach(student);
teacher.attach(parsents);
teacher.sendNotice();
李四 學生接收到了通知！
張三 家長接受到了通知
好像就是這樣，觀察者和被觀察者不依賴于具體，而是依賴于抽象，從而使得各自的變化都不會影響另一邊的變化
3，觀察者模式的缺點
1，抽象被觀察者依舊依賴于抽象觀察者
2，具體的觀察者，通知方法被固定了，例如上面的notice通知，我們有沒有可能學生是口頭通知，家長是短信通知呢？
4，事件委托
使用事件委托的方式可以解決上面說到的缺點。
4.1 事件委托是啥？
通俗的理解就是
將一個本來是由委托者做的事，交給一個被委托者去做。
以我們上面的例子為例，本來“學生”的notice應該就是自己要執行了，但是現在，我們不能讓“學生“類來執行，而是讓委托來幫我們執行這個方法，
那么怎么做呢？
/**
* 被委托類
* @author caizepeng
*
*/
public class Event {
private String methodName;//委托的方法名稱
private Object targetObj;//委托者
private Class[] paramsType;//方法參數
private Object[] params;//參數類型
public Event(String methodName,Object targetObj,Object[] params){
this.methodName = methodName;
this.targetObj = targetObj;
this.params = params;
if(null!=params)
createParamsByClass();
}
/**
* 獲取方法參數的類型
*/
public void createParamsByClass(){
this.paramsType = new Class[this.params.length];
for(int i = 0; i < this.params.length; i++){
this.paramsType[i] = this.params[i].getClass();
}
}
/**
* 執行方法
* @throws Exception
* @throws SecurityException
*/
public void invoke() throws Exception, SecurityException{
Method method = targetObj.getClass().getMethod(this.methodName, this.paramsType);
if(method!=null)
method.invoke(targetObj, this.params);
}
}
將委托方法和委托者封裝起來，利用反射來執行委托方法
/**
* 被監聽者
* @author caizepeng
*
*/
public class Subject {
private List<Event> observers = new ArrayList();
public void addObserver(String method,Object obj,Object[] params){
this.observers.add(new Event(method,obj,params));
}
//通知
public void notifyObserver(){
for(Event event : observers){
try {
event.invoke();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}```
老師類
```java
public class Teacher extends Subject{
private String name;
public Teacher(String name){
this.name = name;
}
}
學生·~
public class Student {
private String name;
//分數
private double score;
public Student(String name, double score) {
super();
this.name = name;
this.score = score;
}
public void speak(){
System.out.println(name+"考試分數 == "+score);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
}```
```java
public class Parents {
public void phoneNotice(Student s){
System.out.println(s.getName()+"考試分數 == "+s.getScore());
}
}
Teacher teacher = new Teacher("老老師");
Student liq = new Student("李青",28.1);
Student dem = new Student("德瑪",66.1);
Parents parents = new Parents();
teacher.addObserver("speak", liq, null);
teacher.addObserver("speak", dem, null);
teacher.addObserver("phoneNotice", parents, new Object[]{liq});
teacher.notifyObserver();
老師和學生家長完全解耦。不需要知道對方的存在
一次通知可以執行不同類的不同方法
