JAVA 自定义 EventListenerManager解耦

大家好哇，我是梦辛工作室的灵，在最近的项目中发现各个模块之间的耦合比较严重，相互依赖，这容易导致后期的维护成本增加，且不能轻易修改，为此呢，自己为了方便就写了一个用于解耦的事件管理内，和JavaScript的EventListener差不多，下面来看下怎么使用的（支持多线程使用哦，里面做了线程保护的）
使用方法如下：

public static void main(String[] args) {
        EventListenerManager eventListenerManager = EventListenerManager.getInstance();
        EventRunnable runnable1 = new EventRunnable() {
            @Override
            public void run(JSONObject data) {
                if (data != null) System.out.println("1:" + data.toString());
            }
        }; 
        eventListenerManager.addEventListener("test",runnable1); //添加监听
        JSONObject data = new JSONObject();
        data.put("ceshi","你好啊"); 
        eventListenerManager.emit("test",data); //提交事件
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

这样子就方便很多了吧，在需要的地方去emit 对应额事件和数据就可以了，事件的消费就可以在其他地方去 addEventListener 就可以，这样就可以减少 模块之间的耦合，从而使得代码更加的清晰，也可以减少工作之间的相互等待，不用等其他人员完成该模块工作，项目可以继续下去，下面来看下EventListenerManager 的源码，其实很简单：

package com.example.demo;


import net.sf.json.JSONObject;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class EventListenerManager {
    private static EventListenerManager instance = null;
    private ExecutorService threadPool = null;
    private final int THREAD_COUNT = 3;

    private EventListenerManager() {
        threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
        managerMap = new ConcurrentHashMap<>();
    }

    private Map<String, EventRunableManager> managerMap = null;

    public static EventListenerManager getInstance() {
        if (null == instance) {
            synchronized (EventListenerManager.class) {
                if (null == instance) {
                    instance = new EventListenerManager();
                }
            }
        }
        return instance;
    }

    public boolean addEventListener(String event,EventRunnable runnable){
        EventRunableManager runableManager = managerMap.get(event);
        if(runableManager == null){
            runableManager = new EventRunableManager();
        }
        boolean addResult = runableManager.add(runnable);
        if (addResult)
        managerMap.put(event,runableManager);
        return addResult;
    }

    public boolean removeEventListener(String event,EventRunnable runnable){
        EventRunableManager runableManager = managerMap.get(event);
        if(runableManager == null){
            return false;
        }
        boolean removeResult = runableManager.remove(runnable);
        if(runableManager.size() == 0){
            managerMap.remove(event);
        }
        return removeResult;
    }

    public void emit(String event){
        final EventRunableManager runableManager = managerMap.get(event);
        if(runableManager == null){
            return;
        }
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                runableManager.run(null);
            }
        });
    }

    public void emit(String event, JSONObject data){
        final EventRunableManager runableManager = managerMap.get(event);
        if(runableManager == null){
            return;
        }
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                runableManager.run(data);
            }
        });
    }

    interface EventRunnable{
        void run(JSONObject data);
    }

    private class EventRunableManager {
        private List<EventRunnable> runnableList = null;
        private boolean run = false;

        private final int MAX_WAIT_TIME = 15 * 1000; // 最长等待时间

        EventRunableManager() {
            runnableList = new ArrayList<>();
        }

        public synchronized boolean add(EventRunnable run) {
            if(isRun()) {
                try {
                    wait(MAX_WAIT_TIME);
                } catch (InterruptedException e) {
                    return  false;
                }
            }
            runnableList.add(run);
            return true;
        }

        public synchronized boolean remove(EventRunnable run) {
            if(isRun()) {
                try {
                    wait(MAX_WAIT_TIME);
                } catch (InterruptedException e) {
                    return  false;
                }
            }
            runnableList.remove(run);
            return true;
        }

        private  boolean isRun() {
            return run;
        }

        private void setRun(boolean run) {
            this.run = run;
        }

        public int size(){
            return runnableList.size();
        }

        public synchronized boolean run(JSONObject data) {
            if(isRun()) {
                try {
                    wait(MAX_WAIT_TIME);
                } catch (InterruptedException e) {
                    return false;
                }
            }
            try {
                setRun(true);
                for (EventRunnable itemRun:runnableList){
                    itemRun.run(data);
                }
                setRun(false);
            } catch (Exception e){
                return false;
            } finally {
                notify();
            }
            return true;
        }
    }
}

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

好了，今天的分享就到这里了，收工=-=