java监听器原理理解与实现

监听器模型涉及以下三个对象，模型图如下：

（1）事件：用户对组件的一个操作，称之为一个事件
（2）事件源：发生事件的组件就是事件源
（3）事件监听器（处理器）：监听并负责处理事件的方法

执行顺序如下：

1、给事件源注册监听器
2、组件接受外部作用，也就是事件被触发
3、组件产生一个相应的事件对象，并把此对象传递给与之关联的事件处理器
4、事件处理器启动，并执行相关的代码来处理该事件。

监听器模式：事件源注册监听器之后，当事件源触发事件，监听器就可以回调事件对象的方法；更形象地说，监听者模式是基于：注册-回调的事件/消息通知处理模式，就是被监控者将消息通知给所有监控者。

1、注册监听器：事件源.setListener；
2、回调：事件源实现onListener。

下面，来看两个demo。

一、简化了上图所示的模型，仅仅包含事件源与监听器

1. /*
2. * 事件源：事件发生的地点
3. */
4. public class EventSource {
5. private IEventListener mEventListener;
6. // 注册监听器
7. public void setEventListener(IEventListener arg) {
8. mEventListener = arg;
9. }
10. // 触发事件
11. public void EventHappened() {
12. mEventListener.onclickButton();
13. }
14. }

/*
 * 事件源：事件发生的地点
 */
public class EventSource {
    private IEventListener mEventListener;

    // 注册监听器
    public void setEventListener(IEventListener arg) {
        mEventListener = arg;
    }

    // 触发事件
    public void EventHappened() {
        mEventListener.onclickButton();
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

1. /*
2. * 事件监听器，事件处理器
3. */
4. public interface IEventListener {
5. void onclickButton();
6. }

/*
 * 事件监听器，事件处理器
 */
public interface IEventListener {
    void onclickButton();
}

• 1
• 2
• 3
• 4
• 5
• 6

1. public class Test {
2. public static void main(String[] args) {
3. // 事件源（被监听的对象）
4. EventSource m1 = new EventSource();
5. // 监听器
6. IEventListener mEventListener = new IEventListener() {
7. @Override
8. public void onclickButton() {
9. // TODO Auto-generated method stub
10. System.out.println(”你点击了按钮”);
11. }
12. };
13. // 注册监听器到事件源
14. m1.setEventListener(mEventListener);
15. m1.EventHappened();
16. }
17. }

public class Test {
    public static void main(String[] args) {

        // 事件源（被监听的对象）
        EventSource m1 = new EventSource();

        // 监听器
        IEventListener mEventListener = new IEventListener() {

            @Override
            public void onclickButton() {
                // TODO Auto-generated method stub
                System.out.println("你点击了按钮");
            }
        };

        // 注册监听器到事件源
        m1.setEventListener(mEventListener);
        m1.EventHappened();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

【实验结果】
你点击了按钮

二、完整模型的demo

1. /*
2. * 事件
3. */
4. public interface IEvent {
5. void setEventListener(IEventListener arg);
6. boolean ClickButton();
7. boolean MoveMouse();
8. }

/*
 * 事件
 */
public interface IEvent {

    void setEventListener(IEventListener arg);

    boolean ClickButton();

    boolean MoveMouse();

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

1. /*
2. * 事件监听器，调用事件处理器
3. */
4. public interface IEventListener {
5. void doEvent(IEvent arg);
6. }

/*
 * 事件监听器，调用事件处理器
 */
public interface IEventListener {

    void doEvent(IEvent arg);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7

1. /*
2. * 事件源：事件发生的地点
3. */
4. public class EventSource implements IEvent{
5. private IEventListener mEventListener;
6. boolean button;
7. boolean mouse;
8. //注册监听器
9. @Override
10. public void setEventListener(IEventListener arg){
11. mEventListener = arg;
12. }
13. //触发事件
14. public void mouseEventHappened(){
15. mouse = true;
16. mEventListener.doEvent(this);
17. }
18. @Override
19. public boolean ClickButton() {
20. return button;
21. // TODO Auto-generated method stub
22. }
23. @Override
24. public boolean MoveMouse() {
25. // TODO Auto-generated method stub
26. return mouse;
27. }
28. }

/*
 * 事件源：事件发生的地点
 */
public class EventSource implements IEvent{
    private IEventListener mEventListener;
    boolean button;
    boolean mouse;

    //注册监听器
    @Override
    public void setEventListener(IEventListener arg){
        mEventListener = arg;
    }

    //触发事件
    public void mouseEventHappened(){
        mouse = true;
        mEventListener.doEvent(this);
    }

    @Override
    public boolean ClickButton() {
        return button;
        // TODO Auto-generated method stub

    }

    @Override
    public boolean MoveMouse() {
        // TODO Auto-generated method stub
        return mouse;
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

1. public class EventSource2 implements IEvent {
2. private IEventListener ml;
3. boolean button;
4. boolean mouse;
5. @Override
6. public void setEventListener(IEventListener arg) {
7. ml = arg;
8. }
9. @Override
10. public boolean ClickButton() {
11. // TODO Auto-generated method stub
12. return button;
13. }
14. @Override
15. public boolean MoveMouse() {
16. // TODO Auto-generated method stub
17. return mouse;
18. }
19. // 触发事件
20. public void buttonEventHappened() {
21. button = true;
22. ml.doEvent(this);
23. }
24. }

public class EventSource2 implements IEvent {
    private IEventListener ml;
    boolean button;
    boolean mouse;

    @Override
    public void setEventListener(IEventListener arg) {
        ml = arg;
    }

    @Override
    public boolean ClickButton() {
        // TODO Auto-generated method stub
        return button;
    }

    @Override
    public boolean MoveMouse() {
        // TODO Auto-generated method stub
        return mouse;
    }

    // 触发事件
    public void buttonEventHappened() {
        button = true;
        ml.doEvent(this);
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

1. public class Test {
2. public static void main(String[] args) {
3. // 事件源（被监听的对象）
4. EventSource m1 = new EventSource();
5. EventSource2 m2 = new EventSource2();
6. // 监听器
7. IEventListener mEventListener = new IEventListener() {
8. @Override
9. public void doEvent(IEvent arg) {
10. if (true == arg.ClickButton()) {
11. System.out.println(”你点击了按钮”);
12. }else if(true == arg.MoveMouse()){
13. System.out.println(”你移动了鼠标”);
14. }
15. }
16. };
17. // 注册监听器到事件源
18. m1.setEventListener(mEventListener);
19. m1.mouseEventHappened();
20. // 注册监听器到事件源
21. m2.setEventListener(mEventListener);
22. m2.buttonEventHappened();
23. }
24. }

public class Test {
    public static void main(String[] args) {

        // 事件源（被监听的对象）
        EventSource m1 = new EventSource();
        EventSource2 m2 = new EventSource2();
        // 监听器
        IEventListener mEventListener = new IEventListener() {

            @Override
            public void doEvent(IEvent arg) {
                if (true == arg.ClickButton()) {
                    System.out.println("你点击了按钮");
                }else if(true == arg.MoveMouse()){
                    System.out.println("你移动了鼠标");
                }
            }
        };

        // 注册监听器到事件源
        m1.setEventListener(mEventListener);
        m1.mouseEventHappened();

        // 注册监听器到事件源
        m2.setEventListener(mEventListener);
        m2.buttonEventHappened();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

【实验结果】
你移动了鼠标
你点击了按钮