14 观察者模式

参考
https://blog.csdn.net/caoxiaohong1005/article/details/79019706

1 准确定义

定义了一种一对多的依赖关系，让多个观察者对象同事监听某一个主题的对象。这个主题对象在状态在发生变化时，会通知所有的观察者对象，让它们能够自动更新自己。

2 使用的意义

讲一个系统分割成一系列相互协作的类有一个不好的副作用，那就是需要维护相关对象的一致性。我们不希望为了维持一致性而使得各类紧密耦合，这样会给维护、扩展、重用带来不便。而观察者模式的关键对象是主题Subject和观察者Observer，一个Subject可以有多个依赖它的Observer，一旦Subject发生变化，所有的Observer都可以得到通知。
3、适用场景
3.1、当一个对象的改变需要同时改变其它对象。
3.2、这个对象并不知道它需要同时改变多少个依赖它的对象。
4、UML图

5、例子
5.1UML图

5.2、code

Client

package designmodel.fourteenthchapter;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/10 09:08
 * @ProjectName: JavaBaseTest
 */
public class Client {
    public static void main(String[] args) {
        Boss boss=new Boss();
        NBAObserver nbaObserver=new NBAObserver("李明浩",boss);
        TVObserver tvObserver=new TVObserver("李沁",boss);
        //add
        boss.add(nbaObserver);
        boss.add(tvObserver);
        //delete
 
        //boss状态转变,通知观察者
        boss.setSubjetctState("领导回来了");
        boss.notifyObservers();
    }
}

Subject

package designmodel.fourteenthchapter;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/9 23:29
 * @ProjectName: JavaBaseTest
 */
public abstract class Subject {
    abstract void add(Observer observer);
    abstract void delete(Observer observer);
    abstract void notifyObservers();
    private String subjetctState;
 
    //获取主题状态
    public String getSubjetctState() {
        return subjetctState;
    }
    //设置主题状态
    public void setSubjetctState(String subjetctState) {
        this.subjetctState = subjetctState;
    }
}

Boss

package designmodel.fourteenthchapter;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/10 09:11
 * @ProjectName: JavaBaseTest
 */
public class Boss extends Subject{
    private List<Observer> list=new ArrayList<>();
 
    //增加观察者
    public void add(Observer observer){
        list.add(observer);
    }
    //删除观察者
    public void delete(Observer observer){
        list.remove(observer);
    }
    //通知
    public void notifyObservers(){
        for(Observer s:list)
            s.update();
    }
}

Observer

package designmodel.fourteenthchapter;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/9 23:17
 * @ProjectName: JavaBaseTest
 */
public interface Observer {
    void update();
}

NBAObserver

package designmodel.fourteenthchapter;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/9 23:28
 * @ProjectName: JavaBaseTest
 */
public class NBAObserver implements Observer {
    private Subject subject;//关注主题
    private String name;//观察者名字
    public NBAObserver(String name,Subject subject){//参数Subject体现了:具体依赖抽象原则
        this.name=name;
        this.subject=subject;
    }
 
    @Override
    public void update() {
        System.out.println(subject.getSubjetctState()+","+name+","+"快继续工作~");
    }
}

TVObserver

package designmodel.fourteenthchapter;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/9 23:45
 * @ProjectName: JavaBaseTest
 */
public class TVObserver implements Observer {
    private String name;//看电视的人名字
    private Boss subject;//主题
    public TVObserver(String name,Boss subject){
        this.name=name;
        this.subject=subject;
    }
 
    @Override
    public void update() {
        System.out.println(subject.getSubjetctState()+","+name+","+"快继续工作~");
    }
}

输出：

领导回来了,李明浩,快继续工作~
领导回来了,李沁,快继续工作~
 
Process finished with exit code 0

6 观察者模式不足

• 抽象通知者仍然依赖抽象观察者
• 每个具体观察者被通知时，通知方法名必须一样，而实际中很难一样

7 优化观察者模式：事件委托实现

• 事件委托解决的问题：一个委托可以搭载多个方法，所有方法被一次唤起。更重要的是委托可以使得委托对象所搭载的方法并不属于同一个类，从而实现通知者和抽象观察者解耦。
• 委托是什么：是一种引用方法的类型。一旦为委托分配了方法，则委托和该方法拥有完全相同的行为。委托方法的使用可以和其它任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象 ，是函数的“类”，委托的实例将代表一个具体的函数。
• 委托实质：用反射来实现。
• 委托事件的前提：委托对象所搭载的所有方法必须具有相同的原形和形式，也就是拥有相同的参数列表和返回值类型。

8 委托代码实现观察者模式

8.1 应用场景

办公室里面有两类同事：
(1) 看NBA赛事直播的男人们 & 看电视剧的女人们。
(2) 通知忙里偷闲的同事，即：领导回来消息的岗哨。
通过使用委托，实现观察者中岗哨和观察者之间解耦。

8.2 code

Client

package designmodel.delegate;
 
import java.util.Date;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/12 16:40
 * @ProjectName: JavaBaseTest
 */
public class Client {
    public static void main(String[] args) {
        //观察者.  创建时起,开始做自己的事情
        NBAObserver nbaObserver=new NBAObserver();
        TVObserver tvObserver=new TVObserver();
        //主题(通知者)
        NotifierA notifierA=new NotifierA();
 
        //为主题添加观察者
        notifierA.addListener(nbaObserver,"stopWatchingNBA",new Date());
        notifierA.addListener(tvObserver,"stopWatchingTV",new Date());
 
        //主题状态改变,通知观察者
        notifierA.notifyX();
    }
}

Event

package designmodel.delegate;
 
import java.lang.reflect.Method;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/10 23:29
 * @ProjectName: JavaBaseTest
 */
public class Event{
    //要执行方法的对象
    private Object object;
    //要执行的方法名称
    private String methodName;
    //要执行方法的参数
    private Object[] params;
    //要执行方法的参数类型
    private Class[] paramType;
 
    //两个构造函数
    public Event(){}
    public Event(Object object,String methodName,Object... args){
        this.object=object;
        this.methodName=methodName;
        this.params=args;
        //获取参数类型
        getParaTypes(args);
    }
    private void getParaTypes(Object[] params){
        int size=params.length;
        this.paramType=new Class[size];//4个私有变量,只有这个变量实现了深拷贝
        for(int i=0;i<size;i++)
            paramType[i]=params[i].getClass();
    }
 
    //执行该对象的方法
    public void invoke() throws Exception{
        Method method=object.getClass().getMethod(getMethodName(),getParamType());
        if(null==method)
            return;
        method.invoke(getObject(),getParams());
    }
 
    //get,set方法
    public Object getObject() {
        return object;
    }
 
    public void setObject(Object object) {
        this.object = object;
    }
 
    public String getMethodName() {
        return methodName;
    }
 
    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
 
    public Object[] getParams() {
        return params;
    }
 
    public void setParams(Object[] params) {
        this.params = params;
    }
 
    public Class[] getParamType() {
        return paramType;
    }
 
    public void setParamType(Class[] paramType) {
        this.paramType = paramType;
    }
}

EventHandler

package designmodel.delegate;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/12 11:23
 * @ProjectName: JavaBaseTest
 */
public class EventHandler {
    //保存了很多event的引用
    private List<Event> objects;
    public EventHandler(){
        objects=new ArrayList<>();
    }
 
    //添加某个event
    public void addEvent(Object object,String name,Object... args){
        objects.add(new Event(object,name,args));
    }
    //触发所有引用的event
    public void notifyEvents() throws Exception{
        for(Event e:objects)
            e.invoke();
    }
}

NBAObserver

package designmodel.delegate;
 
import java.util.Date;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/12 16:30
 * @ProjectName: JavaBaseTest
 */
public class NBAObserver{
    public NBAObserver(){
        System.out.println("正在观看NBA比赛!当前时间为:"+new Date());
    }
    public void stopWatchingNBA(Date date){
        System.out.println("领导回来了,快关闭NBA赛事直播!当前时间为:"+date);
    }
}

TVObserver

package designmodel.delegate;
 
import java.util.Date;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/12 16:37
 * @ProjectName: JavaBaseTest
 */
public class TVObserver {
    public TVObserver(){
        System.out.println("正在观看电视剧<<甄嬛传>>,当前时间为:"+new Date());
    }
    public void stopWatchingTV(Date date){
        System.out.println("领导回来了,快关闭电视剧播放.当前时间为:"+date);
    }
}

Notifier

package designmodel.delegate;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/12 11:36
 * @ProjectName: JavaBaseTest
 */
public abstract class Notifier {
    private EventHandler eventHandler=new EventHandler();
    //增加需要帮忙放哨的同事
    public abstract void addListener(Object object,String name,Object... args);
    //告诉所有需要帮忙放哨的同事:领导回来啦
    public abstract void notifyX();
 
    //get,set
    public EventHandler getEventHandler() {
        return eventHandler;
    }
 
    public void setEventHandler(EventHandler eventHandler) {
        this.eventHandler = eventHandler;
    }
}

NotifierA

package designmodel.delegate;
 
/**
 * @Author: cxh
 * @CreateTime: 18/1/12 16:13
 * @ProjectName: JavaBaseTest
 */
public class NotifierA extends Notifier{
 
    @Override
    public void addListener(Object object, String name, Object... args) {
        getEventHandler().addEvent(object,name,args);
    }
 
    @Override
    public void notifyX(){
        try{
            getEventHandler().notifyEvents();
        }catch (Exception e){
            System.out.println("通知同事时出错!!!");
        }
    }
}