Skip to content

Latest commit

 

History

History
371 lines (284 loc) · 9.53 KB

11-观察者模式.md

File metadata and controls

371 lines (284 loc) · 9.53 KB

观察者模式

观察者模式的应用场景

​ **观察者模式（observer Pattern）定义了对象之间的一对多依赖，让多个观察者对象同时监听一个主体对象，当主体对象发生变化时，它的所有依赖者（观察者）都会受到通知并更新，属于行为模式。观察者模式有时也叫做发布订阅模式。**观察者模式主要用于在关联行为之间建立一套触发机制的场景。观察者模式在现实生活应用也非常广泛，比如：微信朋友圈动态通知、消息通知、邮件通知、广播通知、桌面程序的事件响应。

下面我们设计一个鼠标操作的响应的业务场景，熟悉桌面编程的同学应该不陌生。例如：java.awt.Event就是观察者模式的一种，只不过Java很少被用来写桌面程序。我们自己用代码来实现以下，让我们更深刻的了解观察者模式的实现原理。首先，创建Event类：

package com.wenbin.design.pattern.observer.event;

import java.lang.reflect.Method;

/**
 * 监听的一种包装，标准时间源格式的定义
 */
public class Event {
    // 事件源，事件是由谁发起的保存起来
    private Object source;
    // 事件触发，要通知谁
    private Object target;
    // 事件触发，要做什么动作，回调
    private Method callback;
    // 事件的名称，触发的是什么事件
    private String trigger;
    // 事件触发的事件
    private long time;

    public Event(Object target, Method callback) {
        this.target = target;
        this.callback = callback;
    }

    public Object getSource() {
        return source;
    }

    public void setSource(Object source) {
        this.source = source;
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Method getCallback() {
        return callback;
    }

    public void setCallback(Method callback) {
        this.callback = callback;
    }

    public String getTrigger() {
        return trigger;
    }

    public Event setTrigger(String trigger) {
        this.trigger = trigger;
        return this;
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    @Override
    public String toString() {
        return "Event{" +
                "source=" + source +
                ", target=" + target +
                ", callback=" + callback +
                ", trigger='" + trigger + '\'' +
                ", time=" + time +
                '}';
    }
}

创建 EventLisenter 类:

package com.wenbin.design.pattern.observer.event;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class EventLisenter {
    protected Map<String, Event> events = new HashMap<String, Event>();

    // 事件名称和一个目标对象来触发事件
    public void addLisenter(String eventType, Object target) {
        try {
            this.addLisenter(eventType, target
                    , target.getClass().getMethod("on" + toUpperFirstCase(eventType), Event.class));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void addLisenter(String eventType, Object target, Method callback) {
        // 注册事件
        events.put(eventType, new Event(target, callback));
    }

    // 触发，只要有动作就触发
    private void trigger(Event event) {
        event.setSource(this);
        event.setTime(System.currentTimeMillis());

        try {
            // 发起回调
            if (event.getCallback() != null) {
                // 用反射调用它的回调函数
                event.getCallback().invoke(event.getTarget(), event);
            }
        } catch (Exception e) {
            e.printStackTrace();

        }
    }

    // 事件名触发
    protected void trigger(String trigger) {
        if (!this.events.containsKey(trigger)) {
            return;
        }
        trigger(this.events.get(trigger).setTrigger(trigger));
    }

    private String toUpperFirstCase(String str) {
        char[] chars = str.toCharArray();
        chars[0] -= 32;
        return String.valueOf(chars);
    }
}

​ 创建 MouseEventType 接口:

package com.wenbin.design.pattern.observer.event;

public interface MouseEventType {
    // 单击
    String ON_CLICK = "click";

    // 双击
    String ON_DOUBLE_CLICK = "doubleClick";

    // 按下
    String ON_DOWN = "down";

    // 弹起
    String ON_UP = "up";

    // 移动
    String ON_MOVE = "move";

    // 滚动
    String ON_WHEEL = "wheel";

    // 悬停
    String ON_OVER = "over";

    // 失焦
    String ON_BLUR = "blur";

    // 获焦
    String ON_FOCUS = "focus";
}

创建 Mouse 类:

package com.wenbin.design.pattern.observer.event;

public class Mouse extends EventLisenter {

    public void click() {
        System.out.println("调用单击方法");
        this.trigger(MouseEventType.ON_CLICK);
    }

    public void doubleClick() {
        System.out.println("调用双击方法");
        this.trigger(MouseEventType.ON_DOUBLE_CLICK);
    }

    public void up() {
        System.out.println("调用弹起方法");
        this.trigger(MouseEventType.ON_UP);
    }

    public void down() {
        System.out.println("调用按下方法");
        this.trigger(MouseEventType.ON_DOWN);
    }

    public void move() {
        System.out.println("调用移动方法");
        this.trigger(MouseEventType.ON_MOVE);
    }

    public void wheel() {
        System.out.println("调用滚动方法");
        this.trigger(MouseEventType.ON_WHEEL);
    }

    public void over() {
        System.out.println("调用悬停方法");
        this.trigger(MouseEventType.ON_OVER);
    }

    public void blur() {
        System.out.println("调用获焦方法");
        this.trigger(MouseEventType.ON_BLUR);
    }

    public void focus() {
        System.out.println("调用失焦方法");
        this.trigger(MouseEventType.ON_FOCUS);
    }
}

创建回调方法 MouseEventCallback 类:

package com.wenbin.design.pattern.observer.event;

public class MouseEventCallback {
    public void onClick(Event e) {
        System.out.println("===========触发鼠标单击事件==========" + "\n" + e);
    }

    public void onDoubleClick(Event e) {
        System.out.println("===========触发鼠标双击事件==========" + "\n" + e);
    }

    public void onUp(Event e) {
        System.out.println("===========触发鼠标弹起事件==========" + "\n" + e);
    }

    public void onDown(Event e) {
        System.out.println("===========触发鼠标按下事件==========" + "\n" + e);
    }

    public void onMove(Event e) {
        System.out.println("===========触发鼠标移动事件==========" + "\n" + e);
    }

    public void onWheel(Event e) {
        System.out.println("===========触发鼠标滚动事件==========" + "\n" + e);
    }

    public void onOver(Event e) {
        System.out.println("===========触发鼠标悬停事件==========" + "\n" + e);
    }

    public void onBlur(Event e) {
        System.out.println("===========触发鼠标失焦事件==========" + "\n" + e);
    }

    public void onFocus(Event e) {
        System.out.println("===========触发鼠标获焦事件==========" + "\n" + e);
    }
}

客户端测试代码:

package com.wenbin.design.pattern.observer.event;

public class MouseEventTest {
    public static void main(String[] args) {
        try {
            MouseEventCallback callback = new MouseEventCallback();
            //注册事件
            Mouse mouse = new Mouse();
            mouse.addLisenter(MouseEventType.ON_CLICK, callback);
            mouse.addLisenter(MouseEventType.ON_MOVE, callback);
            mouse.addLisenter(MouseEventType.ON_WHEEL, callback);
            mouse.addLisenter(MouseEventType.ON_OVER, callback);
//            mouse.addLisenter(MouseEventType.ON_BLUR, callback);

            // 调用方法
            mouse.click();
            System.out.println("-------------------------");
            // 获焦事件
            mouse.blur();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

基于Guava API轻松逻辑观察者模式

​ 推荐给大家一个实现观察者模式非常好用的框架。API 使用也非常简单，举 个例子，先引入 maven 依赖包:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>20.0</version>
</dependency>

创建侦听事件 GuavaEvent:

package com.wenbin.design.pattern.observer.guava;

import com.google.common.eventbus.Subscribe;

public class GuavaEvent {

    @Subscribe
    public void subscribe(String str) {
        // 业务逻辑
        System.out.println("执行subscribe方法，传入参数是：" + str);
    }
}

客户端测试代码：

package com.wenbin.design.pattern.observer.guava;

import com.google.common.eventbus.EventBus;

public class GuavaEventTest {
    public static void main(String[] args) {
        EventBus eventBus = new EventBus();
        GuavaEvent guavaEvent = new GuavaEvent();

        // 注册
        eventBus.register(guavaEvent);

        // 触发
        eventBus.post("wenbin");
    }
}

观察者模式的优缺点

优点：

  1. 观察者和被观察者之间建立了一个抽象的耦合。
  2. 观察者模式支持广播通信。

缺点：

  1. 观察者之间有过多的细节依赖、提高时间消耗及程序的复杂度。
  2. 使用要得当，要避免循环调用。