观察者模式实现原理

Posted 2022-02-06 前进道路上的程序猿

前言

观察者模式定义了对象之间的一对多依赖，让多个观察者对象同时监听一个主题对象，当主题对象发生变化时，它的所有观察者都会收到通知并作出相应的动作。
观察者模式又叫发布订阅模式，需要观察者对被观察者发布的的动作进行订阅。

实现

主要类

我们新建的这几个类中，Event是事件类，用于包装触发事件的相关信息；MouseEventType接口中定义了各种事件类型；EventLisenter是监听器类，它是观察者的桥梁；Mouse是被观察者类，当它作出动作时，观察者就会反应并作出相应动作。MouseEventCallback是观察者类
接下来我们就来实现一下

创建Event和MouseEventType

Event：

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 Event setSource(Object source) 
        this.source = source;
        return this;
    
    public Event setTime(long time) 
        this.time = time;
        return this;
    
    public Object getSource() 
        return source;
    
    public Event setTrigger(String trigger) 
        this.trigger = trigger;
        return this;
    
    public long getTime() 
        return time;
    
    public Object getTarget() 
        return target;
    
    public Method getCallback() 
        return callback;
    
    @Override
    public String toString() 
        return "Event" +
                "source=" + source +
                ", target=" + target +
                ", callback=" + callback +
                ", trigger='" + trigger + '\\'' +
                ", time=" + time +
                '';
    
 

MouseEventType：

public interface MouseEventType 
    String ON_CLICK = "click";
    String ON_DOUBLE_CLICK = "doubleClick";
    String ON_UP = "up";
    String ON_DOWN = "down";
    String ON_MOVE = "move";
    String ON_WHEEEL = "wheel";
    String ON_OVER ="over";
    String ON_BLUR = "blur";
    String ON_FOCUS = "focus";

Event为事件类，里面属性包含source事件源、target事件通知目标、callback事件回调、trigger事件名称
MouseEventType用于定义各种事件名称;

创建监听器类EventLisenter

这个类时观察者的桥梁
EventLisenter ：

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);
    

这个类中，用于事件订阅，里面将相应的事件存放到Map中，然后trigger是用于触发，通过传递进来的事件名称触发相应的事件

创建被观察者

Mouse ：

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_WHEEEL);
    
    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);
    

这个类继承EventLisenter类，其相应的方法被调用会触发trigger方法

定义观察者类

MouseEventCallback

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);
    

测试

Test

public class Test 
    public static void main(String[] args) 
        try
            MouseEventCallback callback = new MouseEventCallback();
            Mouse mouse = new Mouse();
            mouse.addLisenter(MouseEventType.ON_CLICK,callback);
            mouse.click();
         catch (Exception e) 
            e.printStackTrace();
        
    

测试中，我们可以看到，被观察者mouse 使用addLisenter添加了一个监听事件，当其触发对应的方方时，会引起观察者相应的动作
我们测试看看

总结来说，这个观察者模式中，被观察者有一个注册表，初始化时，我们进行订阅，将相应的事件存放到注册表中，一旦被观察者作出某个动作，就会从注册表中拿到相应的事件并执行