[图片] 定义 观察者模式是对象的行为模式,又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。 观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象 ..

CRUD 很无聊?一起学设计模式吧!— 观察者模式

定义

观察者模式是对象的行为模式,又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。

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

一个软件系统常常要求在某一个对象的状态发生变化的时候,某些其他的对象做出相应的改变。做到这一点的设计方案有很多,但是为了使系统能够易于复用,应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用,但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致,保证高度的协作。观察者模式是满足这一要求的各种设计方案中最重要的一种。

顾名思义,观察者主要是分为两个大的对象角色,观察者和主题(也叫被观察者)。他们是如何做到松耦合的呢?

关于观察者的一切,主题只需要知道观察者实现了某个接口,主题不需要知道观察者的具体类是谁,做了什么或其他任何细节。当有新的观察者出现时,主题的代码不需要做任何修改。如果有个新的对象需要成为观察者并接收主题的变化通知,我们只需要让这个对象实现此观察者接口,然后注册成为观察者即可。主题不在乎别的,它只会发送通知给所有实现了观察者接口的对象。

改变主题或观察者其中一方,并不影响另外一方。两者之间是松耦合的,所以只要他们之间的接口仍被遵守,我们就可以自由的改变他们。

UML

image.png

角色定义

观察者模式涉及四个角色

场景实战

平时我们都喜欢关注一些微信公众号看一些大佬吹牛皮,当公众号发布消息后,作为粉丝的我们就可以收到消息。而对于公众号作者而言,他们主要是管理粉丝还有吹牛皮,这个场景我们可以套用观察者模式来实现。

代码示例

抽象观察者

首先我们定义一个抽象观察者,这个类很简单,只要定义一个所有观察者公有的方法。在我们的场景中,当公众号发布消息后我们就能得到通知,我们这里使用一个 String 类型的参数用来接收公众号的消息。

/**
 * Description:
 * 抽象观察者,所有实现该接口的类都可以成为观察者
 * @author jam
 * @date 2019/4/19下午11:25
 */
public interface Observer {
    public void recive(String message);
}

具体观察者

关注公众号的读者称之为粉丝,这里我们简单的打印一下公众号发布的消息

/**
 * <p>
 * <code>User</code>
 * </p>
 * Description:
 * 具体观察者 -- 粉丝类
 * @author jam
 * @date 2019/4/19下午11:26
 */
public class Fans implements Observer {
    private String name;

    public Fans(String name) {
        this.name = name;
    }

    @Override
    public void recive(String message) {
        System.out.println("粉丝 " + this.name + " 收到消息: "+message);
    }
}

抽象主题(抽象被观察者)

抽象主题主要是定义一些接口用于管理观察者,公众号有权利来管理所有的粉丝并在发布消息后通知所有的粉丝。

/**
 * <p>
 * <code>Subject</code>
 * </p>
 * Description:
 *  定义抽象主题,主题需要实现添加、删除、通知观察者
 * @author jam
 * @date 2019/4/19下午11:20
 */
public interface Subject {
    /**
     * 注册成为观察者
     * @param observer
     */
    public void attach(Observer observer);

    /**
     * 删除观察者
     * @param observer
     */
    public void detach(Observer observer);

    /**
     * 通知所有观察者
     */
    public void notifyObservers();
}

具体主题(具体被观察者)

具体主题除了必须要实现抽象主题定义的方法外,还需要有个额外的方法 change(),当主题发生变化时才会告诉观察者。在本场景中公众号发布消息,我们使用 publish(String message)方法替代 change()方法。

/**
 * <p>
 * <code>WechatServer</code>
 * </p>
 * Description:
 * 具体主题
 * @author jam
 * @date 2019/4/19下午11:24
 */
public class WechatServer implements Subject {
    private ArrayList<Observer> observers;
    private String message;

    public WechatServer() {
        observers = new ArrayList<>();
    }

    /**
     * 让一个用户注册成为观察者即粉丝
     * @param observer
     */
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    /**
     * 不喜欢这个观察者,删除掉
     * @param observer
     */
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    /**
     * 通知所有的观察者
     */
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.recive(message);
        }
    }

    /**
     * 当主题发生变化时通知观察者
     * @param message
     */
    public void publish(String message){
        this.message = message;
        System.out.println("webchat publish message:" + message);
        notifyObservers();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        WechatServer wechatServer = new WechatServer();
        Fans fans1 = new Fans("张三");
        Fans fans2 = new Fans("李四");
        Fans fans3 = new Fans("杨五");

        wechatServer.attach(fans1);
        wechatServer.attach(fans2);
        wechatServer.attach(fans3);
        wechatServer.publish("CRUD很无聊?跟我一起学命令模式吧!");

        System.out.println("--------");
				//删除其中一个粉丝
        wechatServer.detach(fans1);
        wechatServer.publish("CRUD很无聊?跟我一起学观察者模式吧!");

    }
}

执行结果

image.png

通过执行结果我们可以发现,在公众号发布消息后所有的粉丝都可以收到消息,而取消关注或者被剔除粉丝队伍以后就收不到消息了。

推模式与拉模式

我们上面的场景是观察者模式中的推模式,这种场景是主题主动向观察者推送数据,不管观察者需要不需要。推模式的前提是主题对象知道观察者需要的数据,观察中的 update()方法里的参数是按照需要定义的方法,但是随着业务的发展会出现考虑不到的情形。

比如我们上述场景中粉丝只需要知道公众号发布的内容,所以我们先约定 String 类型的参数,但是有些粉丝却想知道这个消息的真实作者是谁(是否转载?),这个时候就需要提供新的方法,比如 update(String message,String author),或者干脆重新实现观察者,不管如何都得作相应的改动。

观察者模式还有另外一个模式拉模式,这个模式不需要知道观察者需要什么数据,他把主题自身都传递给观察者,update(Subject subject),然后对外提供一些 getter 方法,让观察者按需来取,这样基本上可以适用各种情况的需要。

接下来我们用拉模式来实现上面的场景。

抽象观察者

这里我们不再适用约定参数处理 recive 方法,而是使用主题直接作为参数。

public interface Observer {
    /**
     * 使用主题作为参数
     * @param subject
     */
    public void recive(Subject subject);
}

具体观察者

收到通知后,我们按需从主题对象中获取相应的数据。

public class Fans implements Observer {
    private String name;

    public Fans(String name) {
        this.name = name;
    }

    @Override
    public void recive(Subject subject) {
        //观察者可以同时观察多个主题
        //所以我们需要确保被观察者属于我们需要的WechatServer类型
        //如果是其他类型可能需要作其他方式处理
        if(subject instanceof WechatServer){
            WechatServer wechatServer = (WechatServer) subject;
            System.out.println("粉丝 " + this.name + " 收到消息: "
                    + wechatServer.getMessage() + " 作者是:"
                    + wechatServer.getAuthor());
        }
    }
}

抽象主题

未发生变化

public interface Subject {
    /**
     * 注册成为观察者
     * @param observer
     */
    public void attach(Observer observer);

    /**
     * 删除观察者
     * @param observer
     */
    public void detach(Observer observer);

    /**
     * 通知所有观察者
     */
    public void notifyObservers();
}

具体主题

重点关注notifyObservers()方法,直接将 this 即当前主题作为参数传递给观察者,并对外提供getMessage()getAuthor()方法,好让观察者对象可以方便取走想要的数据。

public class WechatServer implements Subject {
    private ArrayList<Observer> observers;
    private String message;
    private String author;

    /**
     * 对外提供获取内容的方法
     * @return
     */
    public String getMessage() {
        return message;
    }

    /**
     * 对外提供获取作者的方法
     * @return
     */
    public String getAuthor() {
        return author;
    }

    public WechatServer() {
        observers = new ArrayList<>();
    }

    /**
     * 让一个用户注册成为观察者即粉丝
     * @param observer
     */
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    /**
     * 不喜欢这个观察者,删除掉
     * @param observer
     */
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    /**
     * 通知所有的观察者
     */
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            //这里不再是具体的参数,而是把主题自身给通知给观察者
            observer.recive(this);
        }
    }

    /**
     * 当主题发生变化时通知观察者
     * @param message
     */
    public void publish(String message,String author){
        this.message = message;
        this.author = author;
        System.out.println("webchat publish message:" + message);
        notifyObservers();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        WechatServer wechatServer = new WechatServer();
        Fans fans1 = new Fans("张三");
        Fans fans2 = new Fans("李四");
        Fans fans3 = new Fans("杨五");

        wechatServer.attach(fans1);
        wechatServer.attach(fans2);
        wechatServer.attach(fans3);
        wechatServer.publish("CRUD很无聊?跟我一起学命令模式吧!","JAVA日知录");

        System.out.println("--------");

        wechatServer.detach(fans1);
        wechatServer.publish("CRUD很无聊?跟我一起学观察者模式吧!","JAVA日知录");

    }
}

执行结果

image.png

使用拉模式后只要主题提供了对应的 get 方法,基本可以满足各种需求的场景。

再深入一点

观察者模式在 Java 中已经有相应的实现,抽象观察者角色由java.util.Observer充当,抽象主题角色由java.util.Observable充当。

我们可以利用 Java 内置的观察者模式很容易实现上面的推模式和拉模式的场景代码,这里就不再演示了。

最后提醒大家一下,主题角色 Observable 是一个类,我们要想要实现具体的主题必须要继承它,如果某类想同时具有 Observable 和其他一个超类的行为,就会陷入两难,毕竟 Java 不支持多重继承。

如果你的应用场景中不需要考虑如上情形,那么 Observable 可能会符合你的需求,否则还是需要使用自定义观察者模式来实现你的需求,反正这也很简单,不是吗?

  • 设计模式

    设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

    150 引用 • 109 回帖
回帖
请输入回帖内容...