23种设计模式之观察者模式代码demo

定义：观察者模式定义了对象之间一对多的依赖，让多个观察者对象同时监听

，一个主体对象，当主体对象发生变化时，它的所有依赖者（观察者）都会受到通知并更新，属于行为型模式。

观察者模式有时也叫做发布订阅模式。观察者模式主要用于在关联行为之间建立一套触发机制的场景。

懒人源码：

扫描下面二维码关注公众号： 程序员修炼宝典 ，回复：观察者模式  获取源码

 

java源码模拟朋友圈动态通知：

public class GPer extends Observable {

    private String name = "新野酒会";
    private static GPer gPer = null;

    private GPer() {}

    public String getName() {
        return name;
    }
    public static GPer getInstance() {
        if (gPer == null) {
            gPer = new GPer();
        }
        return gPer;
    }

    public void  publishQuestion(Question question) {
        System.out.println(question.getUserName() + "在" + this.name + "上提交了一个问题。");
        setChanged();
        notifyObservers(question);
    }
}

public class Question {

    private String userName;
    private String content;

    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}


public class Teacher implements Observer {

    private String name;

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

    public void update(Observable o, Object arg) {
        GPer gPer = (GPer) o;

        Question question = (Question) arg;

        System.out.println("==========================");
        System.out.println(name + "老师，您好！\n" +
                "您收到了一份来自“" + gPer.getName() + "”的提问，希望您解答，问题内容如下：\n"
        + question.getContent() + "\n" +
                "提问者：" + question.getUserName());
    }
}

public class MainTest {

    public static void main(String[] args) {
        GPer gPer = GPer.getInstance();
        Teacher lone = new Teacher("卧龙");
        Teacher bird = new Teacher("凤雏");

        gPer.addObserver(lone);
        gPer.addObserver(bird);

        //业务逻辑代码
        Question question = new Question();
        question.setContent("卧龙凤雏得一可得天下?");
        question.setUserName("刘备");
        gPer.publishQuestion(question);
    }
}

2.使用观察者模式设置一套鼠标事件监听器

/**
 * 监听器的一种包装，标准事件源格式的定义
 *
 * 事件源管理
 * @Author: 
 * @Date: 2020/12/15 16:06
 */
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 Event setSource(Object source) {
        this.source = source;
        return this;
    }
    public Object getTarget() {
        return target;
    }
    public Event setTarget(Object target) {
        this.target = target;
        return this;
    }
    public Method getCallback() {
        return callback;
    }
   /* public Event setCallback(Method callback) {
        this.callback = callback;
        return this;
    }*/
    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 + '}';
    }
}

监听器

public class EventLisenter {

    //jdk底层的lisenter通常也是这种设计
    protected Map<String, Event> events = new HashMap<>();

    //通过事件名称和一个目标对象来触发事件
    public void addLisenter(String eventType, Object target) {
        try {
            String upperEventType = "on" + toUpperFirstCase(eventType);
            this.addLisenter(eventType, target, target.getClass().getMethod(upperEventType, Event.class));
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void addLisenter(String eventType, Object target, Method callBack) {
        //注册事件
        events.put(eventType, new Event(target, callBack));
    }

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

        try {
            //发起回调
            if (event.getCallback() != null) {
                //用反射调用它的回调函数
                event.getCallback().invoke(event.getTarget(), event);
                //也可以优化为策略模式组合，设置为不同的事件监听内执行各种回调函数
            }
        }
        catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    protected void trigger(String trigger) {
        if (!this.events.containsKey(trigger)) {
            System.out.println("事件" + trigger + "未注册");
            return;
        }
        trigger(this.events.get(trigger).setTrigger(trigger));
    }


    private String toUpperFirstCase(String eventType) {

        char[] chars = eventType.toCharArray();
        chars[0] -= 32;
        return String.valueOf(chars);
    }
}

事件管理：

/**
 * 事件
 * @Author: Zhangdongdong
 * @Date: 2020/12/15 16:32
 */
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);
    }
}

 

回调函数：

/**
 * 监听后执行事件
 * @Author: Zhangdongdong
 * @Date: 2020/12/15 16:37
 */
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);
    }
}

 

事件类型统一定义：

/**
 * 事件类型定义
 * @Author: Zhangdongdong
 * @Date: 2020/12/15 16:27
 */
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_WHEEL = "wheel";
//    悬停
    String ON_OVER = "over";
//    失焦
    String ON_BLUR = "blur";
//    获焦
    String ON_FOCUS = "focus";
}

测试：

public class EventMainTest {



    public static void main(String[] args) {
        MouseEventCallback callback = new MouseEventCallback();

        try {
            //注册事件
            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.click();
            mouse.blur();
        }
        catch (Exception e) {
            e.printStackTrace();
        }

    }

}

结果为：