利用单例+观察者设计一个简易的分发/订阅消息机制_实现一个简易版的消息分发程序-CSDN博客

项目地址

GitHub: https://github.com/AlionSSS/MyNotifier

你可能需要知道

单例设计模式
观察者设计模式
熟悉HashMap、HashSet、Interface

使用示例

按value注册观察者

MyNotify.getNotifier().registerObserver("Chinese", new EventObserver() {
            @Override
            public void onEvent(Object info) {
                System.out.println("info = " + info);
            }
        });
   
   1
2
3
4
5
6

按value分发消息

MyNotify.getNotifier().notify("Chinese", "你好");
   
   1

源代码

Event 发生接口

/**
 * Event 发生接口
 *
 * @author ALion
 * @version 2017/7/13 1:30
 */
public interface EventObserver {

    void onEvent(Object info);

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

Notifier 功能接口

/**
 * Notifier 功能接口
 *
 * @author ALion
 * @version 2017/7/13 1:29
 */
public interface MyNotifier {

    /**
     * 注册观察者
     *
     * @param key    用于标识observer，不能为null
     * @param observer 注册对应的observer接口，不能为null
     */
    void registerObserver(String key, EventObserver observer);

    /**
     * 注销观察者
     *
     * @param observer 注销对应的observer接口，不能为null
     */
    void unRegisterObserver(EventObserver observer);

    /**
     * 注销观察者
     *
     * @param key 按key值注销，不能为null
     */
    void unRegisterObserver(String key);

    /**
     * 注销所有观察者
     */
    void unRegisterAll();

    /**
     * 按key通知发生变化
     *
     * @param key 按key值通知对应的observer，不能为null
     * @param info  传递的信息
     */
    void notify(String key, Object info);

    /**
     * 通知所有observer
     *
     * @param info 传递的信息
     */
    void notifyAll(Object info);

}
   
   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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

消息分发具体实现类

/**
 * 消息分发 具体实现类
 *
 * @author ALion
 * @version 2017/6/21 18:29
 */
public class MyNotify implements MyNotifier {

    private static class Inner {
        private static MyNotifier instance = new MyNotify();
    }

    public static MyNotifier getNotifier() {
        return Inner.instance;
    }

    private MyNotify() {
        mObservers = new HashMap<>();
    }

    /**
     * 观察者集合
     * 注: key的String类型可以根据个人喜好修改为Integer
     */
    private static HashMap<String, HashSet<EventObserver>> mObservers;

    @Override
    public void registerObserver(String key, EventObserver observer) {
        checkObserver(observer);
        checkKey(key);

        HashSet<EventObserver> set = mObservers.get(key);
        if (set == null) {
            set = new HashSet<>();
        }
        set.add(observer);
        mObservers.put(key, set);
    }

    @Override
    public void unRegisterObserver(EventObserver observer) {
        checkObserver(observer);

        for (Map.Entry<String, HashSet<EventObserver>> entry : mObservers.entrySet()) {
            HashSet<EventObserver> set = entry.getValue();
            if (set.contains(observer)) {
                set.remove(observer);
                break;
            }
        }
    }

    @Override
    public void unRegisterObserver(String key) {
        checkKey(key);

        mObservers.remove(key);
    }

    @Override
    public void unRegisterAll() {
        mObservers.clear();
    }

    @Override
    public void notify(String key, Object info) {
        checkKey(key);

        if (mObservers.containsKey(key)) {
            HashSet<EventObserver> set = mObservers.get(key);
            for (EventObserver observer : set) {
                observer.onEvent(info);
            }
        }
    }

    @Override
    public void notifyAll(Object info) {
        for (Map.Entry<String, HashSet<EventObserver>> entry : mObservers.entrySet()) {
            for (EventObserver observer : entry.getValue()) {
                observer.onEvent(info);
            }
        }
    }

    private void checkObserver(EventObserver observer) {
        if (observer == null) {
            throw new IllegalArgumentException("observer should not be null!");
        }
    }

    private void checkKey(String key) {
        if (key == null) {
            throw new IllegalArgumentException("key should not be null!");
        }
    }
}
   
   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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

测试一下

public class Main {

    public static void main(String[] args) {
        MyNotifier notifier = MyNotify.getNotifier();
        notifier.registerObserver("China", new EventObserver() {
            @Override
            public void onEvent(Object info) {
                System.out.println("info = " + info);
            }
        });
        notifier.registerObserver("China", new EventObserver() {
            @Override
            public void onEvent(Object info) {
                System.out.println("info = " + info);
            }
        });
        notifier.registerObserver("American", new EventObserver() {
            @Override
            public void onEvent(Object info) {
                System.out.println("info = " + info);
            }
        });

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                    MyNotifier notifier = MyNotify.getNotifier();
                    notifier.notify("China", "你好1");

                    Thread.sleep(3000);
                    notifier.notify("American", "hello");

                    Thread.sleep(10000);
                    notifier.notify("China", "你好2");
                    notifier.notify("American", "hello2");

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

            }
        }).start();

        for (int i = 0; i < 99; i++) {
            try {
                Thread.sleep(500);
                System.out.println("MainThread ---> " + i);

                if (i == 20) {
                    System.out.println("注销掉China");
                    MyNotify.getNotifier().unRegisterObserver("China");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
   
   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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60