1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.rribbit.creation;
17
18 import org.rribbit.Listener;
19 import org.rribbit.ListenerObject;
20 import org.slf4j.Logger;
21 import org.slf4j.LoggerFactory;
22
23 import java.io.File;
24 import java.io.IOException;
25 import java.lang.reflect.Method;
26 import java.net.URL;
27 import java.net.URLDecoder;
28 import java.nio.charset.StandardCharsets;
29 import java.util.ArrayList;
30 import java.util.Collection;
31 import java.util.Enumeration;
32 import java.util.concurrent.CopyOnWriteArrayList;
33 import java.util.regex.Matcher;
34 import java.util.regex.Pattern;
35 import java.util.zip.ZipEntry;
36 import java.util.zip.ZipFile;
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52 public abstract class AbstractClassBasedListenerObjectCreator extends ObjectBasedListenerObjectCreator {
53
54 private static final Logger log = LoggerFactory.getLogger(AbstractClassBasedListenerObjectCreator.class);
55
56 protected Collection<Class<?>> excludedClasses;
57
58
59
60
61
62
63 public AbstractClassBasedListenerObjectCreator(Class<?>... classes) {
64
65 excludedClasses = new CopyOnWriteArrayList<>();
66 for(Class<?> clazz : classes) {
67 this.addClass(clazz);
68 }
69 }
70
71
72
73
74
75
76
77
78 public AbstractClassBasedListenerObjectCreator(Collection<Class<?>> excludedClasses, boolean scanSubPackages, String... packageNames) {
79
80 this.excludedClasses = new CopyOnWriteArrayList<>();
81 if(excludedClasses != null) {
82 this.excludedClasses.addAll(excludedClasses);
83 }
84
85 for(String packageName : packageNames) {
86 this.addPackage(packageName, scanSubPackages);
87 }
88 }
89
90
91
92
93
94
95
96 public void excludeClass(Class<?> excludedClass) {
97 excludedClasses.add(excludedClass);
98 }
99
100
101
102
103
104
105
106
107 public void addClass(Class<?> clazz) {
108
109 log.debug("Processing class '{}'", clazz.getName());
110 Object targetObject = this.getTargetObjectForClass(clazz);
111 if(targetObject != null) {
112 log.debug("Found target object for class '{}', getting Listener methods", clazz.getName());
113 Collection<ListenerObject> incompleteListenerObjects = this.getIncompleteListenerObjectsFromClass(clazz);
114 for(ListenerObject listenerObject : incompleteListenerObjects) {
115 listenerObject.setTarget(targetObject);
116 }
117 listenerObjects.addAll(incompleteListenerObjects);
118 this.notifyObserversOnClassAdded(clazz);
119 }
120 }
121
122
123
124
125
126
127
128 public void addPackage(String packageName, boolean scanSubPackages) {
129
130 log.debug("Scanning package '{}' for classes", packageName);
131 Collection<Class<?>> classes;
132 try {
133 classes = this.getClasses(packageName, scanSubPackages);
134 } catch(Exception e) {
135 throw new RuntimeException("Error during reading of package '" + packageName + "'", e);
136 }
137 for(Class<?> clazz : classes) {
138 if(!excludedClasses.contains(clazz)) {
139 this.addClass(clazz);
140 }
141 }
142 }
143
144
145
146
147
148 protected ClassLoader getClassLoader() {
149 return Thread.currentThread().getContextClassLoader();
150 }
151
152
153
154
155
156
157
158
159
160
161 protected Collection<Class<?>> getClasses(String packageName, boolean scanSubPackages) throws ClassNotFoundException, IOException {
162
163 String path = packageName.replace('.', '/');
164 Enumeration<URL> resources = this.getClassLoader().getResources(path);
165
166 Collection<Class<?>> classes = new ArrayList<>();
167 while(resources.hasMoreElements()) {
168 URL resource = resources.nextElement();
169 String filename = URLDecoder.decode(resource.getFile(), StandardCharsets.UTF_8);
170 log.debug("Processing resource '{}' with filename '{}'", resource, filename);
171
172 if(resource.getProtocol().equals("jar") || resource.getProtocol().equals("zip")) {
173 String zipFilename = filename.substring(5, filename.indexOf("!"));
174 try (ZipFile zipFile = new ZipFile(zipFilename)) {
175 classes.addAll(this.findClassesInZipFile(zipFile, path, scanSubPackages));
176 }
177 } else {
178 File directory = new File(filename);
179 classes.addAll(this.findClassesInDirectory(directory, packageName, scanSubPackages));
180 }
181 }
182 return classes;
183 }
184
185
186
187
188
189
190
191
192
193
194 protected Collection<Class<?>> findClassesInZipFile(ZipFile zipFile, String path, boolean scanSubPackages) throws ClassNotFoundException {
195
196 log.debug("Scanning zipFile '{}' for classes in package '{}'", zipFile.getName(), path);
197 Collection<Class<?>> classes = new ArrayList<>();
198 Enumeration<ZipEntry> zipEntries = (Enumeration<ZipEntry>) zipFile.entries();
199 while(zipEntries.hasMoreElements()) {
200 String entryName = zipEntries.nextElement().getName();
201 log.debug("Entry name: '{}'", entryName);
202 Pattern p;
203 if(scanSubPackages) {
204 p = Pattern.compile("(" + path + "/[\\w/]+)\\.class");
205 } else {
206 p = Pattern.compile("(" + path + "/\\w+)\\.class");
207 }
208 Matcher m = p.matcher(entryName);
209 if(m.matches()) {
210 String className = m.group(1).replaceAll("/", ".");
211 log.debug("Adding Class {}", className);
212 classes.add(Class.forName(className));
213 }
214 }
215 return classes;
216 }
217
218
219
220
221
222
223
224
225
226
227 protected Collection<Class<?>> findClassesInDirectory(File directory, String packageName, boolean scanSubPackages) throws ClassNotFoundException {
228
229 log.debug("Scanning directory '{}' for classes in package '{}'", directory, packageName);
230 Collection<Class<?>> classes = new ArrayList<>();
231 if(!directory.exists()) {
232 return classes;
233 }
234 File[] files = directory.listFiles();
235 if (files != null) {
236 for(File file : files) {
237 if(file.isFile() && file.getName().endsWith(".class")) {
238 classes.add(Class.forName(packageName + '.' + file.getName().substring(0, file.getName().length() - 6)));
239 } else if(file.isDirectory() && scanSubPackages) {
240 classes.addAll(this.findClassesInDirectory(file, packageName + "." + file.getName(), true));
241 }
242 }
243 }
244 return classes;
245 }
246
247
248
249
250
251
252
253 protected abstract Object getTargetObjectForClass(Class<?> clazz);
254 }