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();
老师和学生家长完全解耦。不需要知道对方的存在
一次通知可以执行不同类的不同方法
