|
25 | 25 | import java.util.*; |
26 | 26 |
|
27 | 27 | public class RecordEventsRegistry implements RecordEvents { |
28 | | - private final List<BeforeRecordCreateListener> beforeCreateListeners = new ArrayList<>(); |
| 28 | + private final List<BeforeRecordCreateListener> beforeCreateListeners = new ArrayList<>(); |
29 | 29 | private final List<BeforeRecordUpdateListener> beforeUpdateListeners = new ArrayList<>(); |
30 | 30 | private final List<BeforeRecordDeleteListener> beforeDeleteListeners = new ArrayList<>(); |
31 | 31 | private final List<AfterRecordCreateListener> afterCreateListeners = new ArrayList<>(); |
32 | | - private final List<AfterRecordUpdateListener> afterUpdateListeners = new ArrayList<>(); |
33 | | - private final List<AfterRecordDeleteListener> afterDeleteListeners = new ArrayList<>(); |
| 32 | + private final List<AfterRecordUpdateListener> afterUpdateListeners = new ArrayList<>(); |
| 33 | + private final List<AfterRecordDeleteListener> afterDeleteListeners = new ArrayList<>(); |
34 | 34 |
|
35 | 35 | @Override |
36 | | - public synchronized RecordEventsRegistry registerListener(final BeforeRecordCreateListener listener) { |
37 | | - if (!beforeCreateListeners.contains(listener)) |
38 | | - beforeCreateListeners.add(listener); |
| 36 | + public RecordEventsRegistry registerListener(final BeforeRecordCreateListener listener) { |
| 37 | + synchronized (beforeCreateListeners) { |
| 38 | + if (!beforeCreateListeners.contains(listener)) |
| 39 | + beforeCreateListeners.add(listener); |
| 40 | + } |
39 | 41 | return this; |
40 | 42 | } |
41 | 43 |
|
42 | 44 | @Override |
43 | | - public synchronized RecordEventsRegistry registerListener(final BeforeRecordUpdateListener listener) { |
44 | | - if (!beforeUpdateListeners.contains(listener)) |
45 | | - beforeUpdateListeners.add(listener); |
| 45 | + public RecordEventsRegistry registerListener(final BeforeRecordUpdateListener listener) { |
| 46 | + synchronized (beforeUpdateListeners) { |
| 47 | + if (!beforeUpdateListeners.contains(listener)) |
| 48 | + beforeUpdateListeners.add(listener); |
| 49 | + } |
46 | 50 | return this; |
47 | 51 | } |
48 | 52 |
|
49 | 53 | @Override |
50 | | - public synchronized RecordEventsRegistry registerListener(final BeforeRecordDeleteListener listener) { |
51 | | - if (!beforeDeleteListeners.contains(listener)) |
52 | | - beforeDeleteListeners.add(listener); |
| 54 | + public RecordEventsRegistry registerListener(final BeforeRecordDeleteListener listener) { |
| 55 | + synchronized (beforeDeleteListeners) { |
| 56 | + if (!beforeDeleteListeners.contains(listener)) |
| 57 | + beforeDeleteListeners.add(listener); |
| 58 | + } |
53 | 59 | return this; |
54 | 60 | } |
55 | 61 |
|
56 | 62 | @Override |
57 | | - public synchronized RecordEventsRegistry registerListener(final AfterRecordCreateListener listener) { |
58 | | - if (!afterCreateListeners.contains(listener)) |
59 | | - afterCreateListeners.add(listener); |
| 63 | + public RecordEventsRegistry registerListener(final AfterRecordCreateListener listener) { |
| 64 | + synchronized (afterCreateListeners) { |
| 65 | + if (!afterCreateListeners.contains(listener)) |
| 66 | + afterCreateListeners.add(listener); |
| 67 | + } |
60 | 68 | return this; |
61 | 69 | } |
62 | 70 |
|
63 | 71 | @Override |
64 | | - public synchronized RecordEventsRegistry registerListener(final AfterRecordUpdateListener listener) { |
65 | | - if (!afterUpdateListeners.contains(listener)) |
66 | | - afterUpdateListeners.add(listener); |
| 72 | + public RecordEventsRegistry registerListener(final AfterRecordUpdateListener listener) { |
| 73 | + synchronized (afterUpdateListeners) { |
| 74 | + if (!afterUpdateListeners.contains(listener)) |
| 75 | + afterUpdateListeners.add(listener); |
| 76 | + } |
67 | 77 | return this; |
68 | 78 | } |
69 | 79 |
|
70 | 80 | @Override |
71 | | - public synchronized RecordEventsRegistry registerListener(final AfterRecordDeleteListener listener) { |
72 | | - if (!afterDeleteListeners.contains(listener)) |
73 | | - afterDeleteListeners.add(listener); |
| 81 | + public RecordEventsRegistry registerListener(final AfterRecordDeleteListener listener) { |
| 82 | + synchronized (afterDeleteListeners) { |
| 83 | + if (!afterDeleteListeners.contains(listener)) |
| 84 | + afterDeleteListeners.add(listener); |
| 85 | + } |
74 | 86 | return this; |
75 | 87 | } |
76 | 88 |
|
77 | 89 | @Override |
78 | | - public synchronized RecordEventsRegistry unregisterListener(final BeforeRecordCreateListener listener) { |
79 | | - beforeCreateListeners.remove(listener); |
| 90 | + public RecordEventsRegistry unregisterListener(final BeforeRecordCreateListener listener) { |
| 91 | + synchronized (beforeCreateListeners) { |
| 92 | + beforeCreateListeners.remove(listener); |
| 93 | + } |
80 | 94 | return this; |
81 | 95 | } |
82 | 96 |
|
83 | 97 | @Override |
84 | | - public synchronized RecordEventsRegistry unregisterListener(final BeforeRecordUpdateListener listener) { |
85 | | - beforeUpdateListeners.remove(listener); |
| 98 | + public RecordEventsRegistry unregisterListener(final BeforeRecordUpdateListener listener) { |
| 99 | + synchronized (beforeUpdateListeners) { |
| 100 | + beforeUpdateListeners.remove(listener); |
| 101 | + } |
86 | 102 | return this; |
87 | 103 | } |
88 | 104 |
|
89 | 105 | @Override |
90 | | - public synchronized RecordEventsRegistry unregisterListener(final BeforeRecordDeleteListener listener) { |
91 | | - beforeDeleteListeners.remove(listener); |
| 106 | + public RecordEventsRegistry unregisterListener(final BeforeRecordDeleteListener listener) { |
| 107 | + synchronized (beforeDeleteListeners) { |
| 108 | + beforeDeleteListeners.remove(listener); |
| 109 | + } |
92 | 110 | return this; |
93 | 111 | } |
94 | 112 |
|
95 | 113 | @Override |
96 | 114 | public synchronized RecordEventsRegistry unregisterListener(final AfterRecordCreateListener listener) { |
97 | | - afterCreateListeners.remove(listener); |
| 115 | + synchronized (afterCreateListeners) { |
| 116 | + afterCreateListeners.remove(listener); |
| 117 | + } |
98 | 118 | return this; |
99 | 119 | } |
100 | 120 |
|
101 | 121 | @Override |
102 | 122 | public synchronized RecordEventsRegistry unregisterListener(final AfterRecordUpdateListener listener) { |
103 | | - afterUpdateListeners.remove(listener); |
| 123 | + synchronized (afterUpdateListeners) { |
| 124 | + afterUpdateListeners.remove(listener); |
| 125 | + } |
104 | 126 | return this; |
105 | 127 | } |
106 | 128 |
|
107 | 129 | @Override |
108 | | - public synchronized RecordEventsRegistry unregisterListener(final AfterRecordDeleteListener listener) { |
109 | | - afterDeleteListeners.remove(listener); |
| 130 | + public RecordEventsRegistry unregisterListener(final AfterRecordDeleteListener listener) { |
| 131 | + synchronized (afterDeleteListeners) { |
| 132 | + afterDeleteListeners.remove(listener); |
| 133 | + } |
110 | 134 | return this; |
111 | 135 | } |
112 | 136 |
|
113 | 137 | public boolean onBeforeCreate(final Record record) { |
114 | | - if (beforeCreateListeners.isEmpty()) |
115 | | - return true; |
116 | | - |
117 | | - for (int i = 0; i < beforeCreateListeners.size(); i++) { |
118 | | - if (!beforeCreateListeners.get(i).onBeforeCreate(record)) |
119 | | - return false; |
| 138 | + synchronized (beforeCreateListeners) { |
| 139 | + if (beforeCreateListeners.isEmpty()) |
| 140 | + return true; |
| 141 | + |
| 142 | + for (int i = 0; i < beforeCreateListeners.size(); i++) { |
| 143 | + if (!beforeCreateListeners.get(i).onBeforeCreate(record)) |
| 144 | + return false; |
| 145 | + } |
120 | 146 | } |
121 | 147 | return true; |
122 | 148 | } |
123 | 149 |
|
124 | 150 | public boolean onBeforeUpdate(final Record record) { |
125 | | - if (beforeUpdateListeners.isEmpty()) |
126 | | - return true; |
127 | | - |
128 | | - for (int i = 0; i < beforeUpdateListeners.size(); i++) { |
129 | | - if (!beforeUpdateListeners.get(i).onBeforeUpdate(record)) |
130 | | - return false; |
| 151 | + synchronized (beforeUpdateListeners) { |
| 152 | + if (beforeUpdateListeners.isEmpty()) |
| 153 | + return true; |
| 154 | + |
| 155 | + for (int i = 0; i < beforeUpdateListeners.size(); i++) { |
| 156 | + if (!beforeUpdateListeners.get(i).onBeforeUpdate(record)) |
| 157 | + return false; |
| 158 | + } |
131 | 159 | } |
132 | 160 | return true; |
133 | 161 | } |
134 | 162 |
|
135 | 163 | public boolean onBeforeDelete(final Record record) { |
136 | | - if (beforeDeleteListeners.isEmpty()) |
137 | | - return true; |
138 | | - |
139 | | - for (int i = 0; i < beforeDeleteListeners.size(); i++) { |
140 | | - if (!beforeDeleteListeners.get(i).onBeforeDelete(record)) |
141 | | - return false; |
| 164 | + synchronized (beforeDeleteListeners) { |
| 165 | + if (beforeDeleteListeners.isEmpty()) |
| 166 | + return true; |
| 167 | + |
| 168 | + for (int i = 0; i < beforeDeleteListeners.size(); i++) { |
| 169 | + if (!beforeDeleteListeners.get(i).onBeforeDelete(record)) |
| 170 | + return false; |
| 171 | + } |
142 | 172 | } |
143 | 173 | return true; |
144 | 174 | } |
145 | 175 |
|
146 | 176 | public void onAfterCreate(final Record record) { |
147 | | - if (afterCreateListeners.isEmpty()) |
148 | | - return; |
| 177 | + synchronized (afterCreateListeners) { |
| 178 | + if (afterCreateListeners.isEmpty()) |
| 179 | + return; |
149 | 180 |
|
150 | | - for (int i = 0; i < afterCreateListeners.size(); i++) |
151 | | - afterCreateListeners.get(i).onAfterCreate(record); |
| 181 | + for (int i = 0; i < afterCreateListeners.size(); i++) |
| 182 | + afterCreateListeners.get(i).onAfterCreate(record); |
| 183 | + } |
152 | 184 | } |
153 | 185 |
|
154 | 186 | public void onAfterUpdate(final Record record) { |
155 | | - if (afterUpdateListeners.isEmpty()) |
156 | | - return; |
| 187 | + synchronized (afterUpdateListeners) { |
| 188 | + if (afterUpdateListeners.isEmpty()) |
| 189 | + return; |
157 | 190 |
|
158 | | - for (int i = 0; i < afterUpdateListeners.size(); i++) |
159 | | - afterUpdateListeners.get(i).onAfterUpdate(record); |
| 191 | + for (int i = 0; i < afterUpdateListeners.size(); i++) |
| 192 | + afterUpdateListeners.get(i).onAfterUpdate(record); |
| 193 | + } |
160 | 194 | } |
161 | 195 |
|
162 | 196 | public void onAfterDelete(final Record record) { |
163 | | - if (afterDeleteListeners.isEmpty()) |
164 | | - return; |
| 197 | + synchronized (afterDeleteListeners) { |
| 198 | + if (afterDeleteListeners.isEmpty()) |
| 199 | + return; |
165 | 200 |
|
166 | | - for (int i = 0; i < afterDeleteListeners.size(); i++) |
167 | | - afterDeleteListeners.get(i).onAfterDelete(record); |
| 201 | + for (int i = 0; i < afterDeleteListeners.size(); i++) |
| 202 | + afterDeleteListeners.get(i).onAfterDelete(record); |
| 203 | + } |
168 | 204 | } |
169 | 205 | } |
0 commit comments