本文共享自华为云社区《Java中观察者形式与托付的比照》，作者：小小张自在–张有博。

代码布景

一个班级，有两类学生，A类：不学习，玩，可是玩的东西不一样，有的是做游戏，有的是看电视

B类：放哨的学生，专门看教师的意向，假如教师进班了就立即告知我们。

如此就形成了一个需求，放哨的学生要告知一切玩的学生：教师来了，而不同的学生有不同的反响，有的立刻把电视封闭，有的中止玩游戏。

观察者形式

介绍

观察者形式：界说了一种一对多的依靠联系，让多个观察者目标同时监听某一个主题目标。这个主题目标在状况产生变化时，会告知一切的观察者目标，使他们能够自动更新自己。

**首要处理：**一个目标状况改动给其他目标告知的问题，并且要考虑到易用和低耦合，保证高度的协作。

**何时运用：**一个目标（目标目标）的状况产生改动，一切的依靠目标（观察者目标）都将得到告知，进行播送告知。

**如何处理：**运用面向目标技能，能够将这种依靠联系弱化。

**要害代码：**在笼统类里有一个 ArrayList 存放观察者们。

完成

观察者（学生）

/**
 * 笼统的观察者
 *
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/10 - 15:32
 */
public interface Observer {
    public abstract void updateState();
}
/**
 * 详细的观察者
 *
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/10 - 15:39
 */
public class ConcreteObserver implements Observer{
    //观察者的名字
    private String name;
    //观察者的状况
    private String observerState;
    //清晰详细的告知者
    private ConcreteSubject subject;
   //get set办法省略
    public ConcreteObserver(String name, ConcreteSubject subject) {
        this.name = name;
        this.subject = subject;
    }
    @Override
    public void updateState() {
        observerState=subject.getSubjectState();
        System.out.println(name+"在打游戏");
        String str=String.format("观察者%s的：新状况是%s", name,observerState);
        System.out.println(str);
    }
}
/**
 * 详细的观察者
 *
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/10 - 15:39
 */
public class ConcreteObserver2 implements Observer{
    //观察者的名字
    private String name;
    //观察者的状况
    private String observerState;
    //清晰详细的告知者
    private ConcreteSubject subject;
   //get set办法省略
    public ConcreteObserver2(String name, ConcreteSubject subject) {
        this.name = name;
        this.subject = subject;
    }
    @Override
    public void updateState() {
        observerState=subject.getSubjectState();
        System.out.println(name+"在看电视");
        String str=String.format("观察者%s：新状况是%s", name,observerState);
        System.out.println(str);
    }
}

告知者（教师）

/**
 * 笼统的告知者
 *
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/10 - 15:30
 */
public abstract class Subject {
    //管理观察者的调集
    private List<Observer> observers=new ArrayList<>();
    //添加观察者
    public void add(Observer observer){
        observers.add(observer);
    }
    //减少观察者
    public void detach(Observer observer){
        observers.remove(observer);
    }
    /**
     * 告知一切的观察者
     */
    public void notifyMsg(){
        for (Observer observer : observers) {
            observer.updateState();
        }
    }
}
/**
 * 详细的告知者
 *
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/10 - 15:38
 */
public class ConcreteSubject extends Subject {
    //告知者的状况
    private String subjectState;
    //get set办法
    public String getSubjectState() {
        return subjectState;
    }
    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }
}

Main办法

/**
 * 控制台Main办法
 *
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/10 - 15:48
 */
public class MainTest {
    public static void main(String[] args) {
        //创立一个主题/告知者
        ConcreteSubject subject=new ConcreteSubject();
        //new出观察者（学生）
        ConcreteObserver studentZhang = new ConcreteObserver("小张", subject);
        ConcreteObserver studentLiu = new ConcreteObserver("小刘", subject);
        ConcreteObserver studentWang = new ConcreteObserver("小王", subject);
        //将观察者添加到告知行列里
        subject.add(studentZhang);
        subject.add(studentLiu);
        subject.add(studentWang);
        //告知者（教师）状况修改，告知每个学生
        subject.setSubjectState("教师回来了，我要好好学习");
        subject.notifyMsg();
        System.out.println("-----------");
    }
}

托付

介绍

托付能够看做是函数的笼统，是函数的“类”。托付的实例将代表一个详细的函数

一个托付能够搭载多个办法，一切的办法被顺次唤起。能够使托付目标所搭载的办法并不需求属于同一类。

托付事情模型能够由三个组件界说：事情、事情源和事情侦听器。

托付的完成简单来讲便是用反射来完成的。

完成

观察者

/**
 * 监听器/观察者 玩游戏
 * 事情监听器
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/8 - 11:17
 */
public class PlayingGameListener {
    public PlayingGameListener(){
        System.out.println("我正在玩游戏 开始时刻"+new Date());
    }
    public void stopPlayingGame(Date date){
        System.out.println("教师来了，快回到座位上，结束时刻"+date);
    }
}
/**
 * 监听器/观察者 看电视
 * 事情监听器
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/8 - 11:17
 */
public class WatchingTVListener {
    public WatchingTVListener(){
        System.out.println("我正在看电视 "+new Date());
    }
    public void stopWatchingTV(Date date){
        System.out.println("教师来了，快封闭电视 。 结束时刻"+date);
    }
}

告知者

/**
 * 告知者的笼统类
 * 事情源
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/8 - 11:15
 */
public abstract class Notifier {
    //每个告知者都有一个需求告知的行列（告知：目标、办法、参数）
    private EventHandler eventHandler=new EventHandler();
    public EventHandler getEventHandler() {
        return eventHandler;
    }
    public void setEventHandler(EventHandler eventHandler) {
        this.eventHandler = eventHandler;
    }
    //添加需求帮助放哨的学生
    public abstract void addListener(Object object,String methodName,Object...args);
    //告知一切要帮助放哨的学生：教师来了
    public abstract void notifyX();
}
/**
 * 告知者的子类，放哨人
 * 事情源
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/8 - 11:15
 */
public class GoodNotifier extends Notifier {
    @Override
    public void addListener(Object object, String methodName, Object...args) {
        System.out.println("有新的同学托付尽职尽责的放哨人!");
        this.getEventHandler().addEvent(object, methodName, args);
    }
    @Override
    public void notifyX() {
        System.out.println("尽职尽责的放哨人告知一切需求帮助的同学：教师来了");
        try{
            //优化：异步告知
            this.getEventHandler().notifyX();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

事情

/**
 * 笼统出的事情类，也能够称为办法类
 * 事情
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/8 - 11:03
 */
public class Event {
    //要履行办法的目标
    private Object object;
    //要履行的办法称号
    private String methodName;
    //要履行办法的参数
    private Object[] params;
    //要履行办法的参数类型
    private Class[] paramTypes;
    //若干setter getter
    public Object getObject() {
        return 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[] getParamTypes() {
        return paramTypes;
    }
    public void setParamTypes(Class[] paramTypes) {
        this.paramTypes = paramTypes;
    }
    public Event(){
    }
    public Event(Object object,String methodName,Object...args){
        this.object=object;
        this.methodName=methodName;
        this.params=args;
        contractParamTypes(this.params);
    }
    //依据参数数组生成参数类型数组
    private void contractParamTypes(Object[] params){
        this.paramTypes=new Class[params.length];
        for(int i=0;i<params.length;i++){
            this.paramTypes[i]=params[i].getClass();
        }
    }
    //履行该 目标的该办法
    public void invoke() throws Exception{
        //经过class,method,paramTypes 确认履行哪个类的哪个办法
        Method method=object.getClass().getMethod(this.getMethodName(), this.getParamTypes());
        if(null==method){
            return;
        }
        //办法履行
        method.invoke(this.getObject(), this.getParams());
    }
}

事情处理

/**
 * 管理哪些事情需求履行
 * 管理事情
 *
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/8 - 11:03
 */
public class EventHandler {
    //是用一个List
    private List<Event> objects;
    //添加某个目标要履行的事情，及需求的参数
    public void addEvent(Object object,String methodName,Object...args){
        objects.add(new Event(object,methodName,args));
    }
    public EventHandler(){
        objects=new ArrayList<Event>();
    }
    //告知一切的目标履行指定的事情
    public void notifyX() throws Exception{
        for(Event e : objects){
            e.invoke();
        }
    }
}

Main办法

/**
 * 发动类
 *
 * @author Promsing(张有博)
 * @version 1.0.0
 * @since 2022/5/8 - 11:19
 */
public class EventMain {
    public static void main(String[] args) {
        //创立一个尽职尽责的放哨者
        Notifier goodNotifier = new GoodNotifier();
        //创立一个玩游戏的同学，开始玩游戏
        PlayingGameListener playingGameListener = new PlayingGameListener();
        //创立一个看电视的同学，开始看电视
        WatchingTVListener watchingTVListener = new WatchingTVListener();
        //玩游戏的同学告知放哨的同学，教师来了告知一下
        goodNotifier.addListener(playingGameListener, "stopPlayingGame", new Date());
        //看电视的同学告知放哨的同学，教师来了告知一下
        goodNotifier.addListener(watchingTVListener, "stopWatchingTV", new Date());
        try {
            //一点时刻后
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //教师出现，放哨的人告知一切要帮助的同学:教师来了
        goodNotifier.notifyX();
    }
}

总结

1.先有观察者形式后有托付事情技能

2.观察者形式只能告知继承 Observer类的子类，也能够将Observer改成接口

for (Observer observer : observers) {
        observer.updateState();
}

3.托付能够告知任何类的任何办法。反射、everone

    Method method=object.getClass().getMethod(this.getMethodName(), this.getParamTypes());
    if(null==method){
        return;
    }
    method.invoke(this.getObject(), this.getParams());

4.托付与观察者比多了一个事情履行者，解除观察者与告知者的耦合，能够做到告知任何目标的任何办法。让A类学生和B类学生彻底解耦，即A类彻底不知道B类的学生，却能够告知B类的学生

6.树立一套触发机制，能够运用异步告知

7.观察者/托付挺像MQ里面的订阅发布。生产者、行列、顾客。

点击关注，第一时刻了解华为云新鲜技能~

Java中观察者模式与委托，还在傻傻分不清

代码布景

观察者形式

介绍

完成

观察者（学生）

告知者（教师）

Main办法

托付

介绍

完成

观察者

告知者

事情

事情处理

Main办法

总结

作者信息

Java中观察者模式与委托，还在傻傻分不清

代码布景

观察者形式

介绍

完成

观察者（学生）

告知者（教师）

Main办法

托付

介绍

完成

观察者

告知者

事情

事情处理

Main办法

总结

相关文章

如何使用Next.js创建全栈应用程序

正式确定，奥特曼重回 OpenAI 担任 CEO

2021ICCV行人重识别文章精读之09.Learning by Aligning: Visible-Infrared Person Re-identifica

HashMap 源码解析二、put 相关函数

作者信息