public interface Observer<T> {

    /**
     * 观察者接收通知
     */
    void handle(T message);
}

public interface Subject<T> extends INotify{

    /**
     * 注册观察者
     * @param observer
     */
    void register(Observer<T> observer);

    /**
     * 注销观察者
     * @param observer
     */
    void cancel(Observer<T> observer);

}

public interface INotify {

    /**
     * 通知
     */
    void sendMessage();
}

然后，定义对应实例实现观察者和被观察者

手机工厂

public class PhoneFactory implements Subject<Message> {

    private List<Observer<Message>> observers;

    /**
     * 消息体
     */
    private Message message;

    public PhoneFactory() {
        this.observers = new ArrayList<>();
    }

    /**
     * 注册观察者
     *
     * @param observer
     */
    @Override
    public void register(Observer<Message> observer) {
        observers.add(observer);
    }

    /**
     * 注销观察者
     *
     * @param observer
     */
    @Override
    public void cancel(Observer<Message> observer) {
        observers.remove(observer);
    }

    /**
     * 发送通知
     */
    @Override
    public void sendMessage() {
        observers.forEach(p->{
            p.handle(message);
        });
    }

    /**
     * 外部设置消息变更
     * @param message
     */
    public void setMessage(Message message) {
        this.message = message;
        sendMessage();
    }
}

消息体

@Data
@Builder
@AllArgsConstructor
public class Message {

    /**
     * 消息体
     */
    private String data;
}

代理商

//淘宝
public class TaobaoAgent implements Observer<Message> {
    /**
     * 观察者接收通知
     *
     * @param message
     */
    @Override
    public void handle(Message message) {
        System.out.println("Taobao receive message: " + message.getData());
    }
}
//天猫
public class TianmaoAgent implements Observer<Message> {
    /**
     * 观察者接收通知
     *
     * @param message
     */
    @Override
    public void handle(Message message) {
        System.out.println("Tianmao receive message: " + message.getData());
    }
}

最后，定义测试类，我们来看下效果

/**
 * 自定义观察者模式
 */
@Test
public void testX1() {
    //被观察者
    PhoneFactory phoneFactory = new PhoneFactory();
    //观察者
    TianmaoAgent tianmaoAgent = new TianmaoAgent();
    TaobaoAgent taobaoAgent = new TaobaoAgent();
    //注册
    phoneFactory.register(tianmaoAgent);
    phoneFactory.register(taobaoAgent);
    //发送通知
    phoneFactory.setMessage(Message.builder()
            .data("刚生产了100台Xiaomi手机")
            .build());
    //移除观察者
    phoneFactory.cancel(tianmaoAgent);
    //再次发送通知
    System.out.println("-------------------");
    phoneFactory.setMessage(Message.builder()
            .data("刚又生产了100台iPhone")
            .build());

}

打印

Tianmao receive message: 刚生产了100台Xiaomi手机
Taobao receive message: 刚生产了100台Xiaomi手机
-------------------
Taobao receive message: 刚又生产了100台iPhone

从输出可以看出，观察者和被观察者有以下几个特点：

观察者可以随时进行注册和注销行为
被观察者只会给注册过的观察者发送通知
不同代理商接收通知的顺序和自己注册的先后有关系

那么思考下这个模式有没有什么不好的地方？

每次被观察者发送消息，观察者都需要全部接收并处理。如果信息比较复杂或是观察者只关注其中一部分数据怎么处理？
这种属于被动等待被观察者推的行为，如果不是通知，而是其他一些实时数据的监控呢？如果观察者不想等待，想直接获取当前实时数据信息呢？
JDK内置了观察者模式的实现，为什么还要自己定义呢？与自定义的有什么区别呢？

带着问题，我们来看下JDK内置的观察者模式怎么实现的？并看下如何实现主动拉取被观察者信息。

JDK内置观察者模式实现

public class PhoneFactory2 extends Observable {

    /**
     * 消息体
     */
    private Message message;


    public void setMessage(Message message) {
        this.message = message;
        setChanged();
        notifyObservers(message);
    }

    /**
     * 观察者按需主动拉取自己所需要信息
     * @return
     */
    public Message getMessage() {
        return message;
    }
}

public class TaobaoAgent2 implements Observer {

    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param o   the observable object.
     * @param arg an argument passed to the <code>notifyObservers</code>
     */
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Taobao2 receive message: " + arg.toString());
    }
}

public class TianmaoAgent2 implements Observer {

    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param o   the observable object.
     * @param arg an argument passed to the <code>notifyObservers</code>
     */
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Tianmao2 receive message: " + arg.toString());
    }

}

比较下变化：

首先代码量上减少了，不需要定义接口
notifyObservers方法不用实现，直接使用父层方法
使用的是继承的方式实现观察者和被观察者
定义了getMessage方法，可以主动拉取信息
发送通知前，需要调用父层方法setChanged

定义下测试类：

/**
 * 使用JDK原生观察者模式
 */
@Test
public void testX2() {
    //被观察者
    PhoneFactory2 phoneFactory = new PhoneFactory2();
    //观察者
    TianmaoAgent2 tianmaoAgent = new TianmaoAgent2();
    TaobaoAgent2 taobaoAgent = new TaobaoAgent2();
    //注册
    phoneFactory.addObserver(tianmaoAgent);
    phoneFactory.addObserver(taobaoAgent);
    //发送通知
    phoneFactory.setMessage(Message.builder()
            .data("刚生产了100台Xiaomi手机")
            .build());
    //移除观察者
    phoneFactory.deleteObserver(tianmaoAgent);
    //再次发送通知
    System.out.println("-------------------");
    phoneFactory.setMessage(Message.builder()
            .data("刚又生产了100台iPhone")
            .build());
    //主动拉取消息
    System.out.println("pull message:" + phoneFactory.getMessage());
}

看下测试类的输出：

Taobao2 receive message: Message(data=刚生产了100台Xiaomi手机)
Tianmao2 receive message: Message(data=刚生产了100台Xiaomi手机)
-------------------
Taobao2 receive message: Message(data=刚又生产了100台iPhone)
pull message:Message(data=刚又生产了100台iPhone)

分析下两次输出的区别：

接收消息的顺序反了
被观察者开放了自身被监控属性的Getter方法

其实乍看之下，两种方式实现结果貌似没什么区别，但是仔细观察JDK内置的Observable，不是一个接口，是个类。其内部的setChanged方法也是被 protected修饰的

protected synchronized void setChanged() {
        changed = true;
}

这意味着：你除非继承自Observable，否则无法创建Observable实例，并组合到你自己的对象中来，这个设计违反了 多用组合，少用继承的设计原则。

相较于我们自己实现的观察者模式，可以结合泛型定义被通知的消息体，还可以结合我们的通知接口 INotify等方式来扩展，开发自由度更加高。但是无论是哪种方式，关键是熟悉观察者模式后，善用即可，

REFERENCES

《Head First》读书笔记

设计模式系列

[设计模式] 观察者模式

[设计模式] 观察者模式

场景分析

实战

REFERENCES

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐