本文共享自华为云社区《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里面的订阅发布。生产者、行列、顾客。

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