public List<Annotated<Class<?>>> findMetaAnnotatedClasses(Class<? extends Annotation> annotation) { List<Class<?>> classes = findAnnotatedClasses(annotation); List<Annotated<Class<?>>> list = new ArrayList<Annotated<Class<?>>>(); for (final Class<?> clazz : classes) { list.add(new MetaAnnotatedClass(clazz)); } return list; }
public List<Annotated<Method>> findMetaAnnotatedMethods(Class<? extends Annotation> annotation) { List<Method> methods = findAnnotatedMethods(annotation); List<Annotated<Method>> list = new ArrayList<Annotated<Method>>(); for (final Method method : methods) { list.add(new MetaAnnotatedMethod(method)); } return list; }
public List<Annotated<Field>> findMetaAnnotatedFields(Class<? extends Annotation> annotation) { List<Field> fields = findAnnotatedFields(annotation); List<Annotated<Field>> list = new ArrayList<Annotated<Field>>(); for (final Field field : fields) { list.add(new MetaAnnotatedField(field)); } return list; }
private void linkParent(ClassInfo classInfo) throws IOException { if (classInfo.superType == null) return; if (classInfo.superType.equals("java.lang.Object")) return; ClassInfo parentInfo = classInfo.superclassInfo; if (parentInfo == null) { parentInfo = classInfos.get(classInfo.superType); if (parentInfo == null) { if (classInfo.clazz != null) { readClassDef(((Class<?>) classInfo.clazz).getSuperclass()); } else { readClassDef(classInfo.superType); } parentInfo = classInfos.get(classInfo.superType); if (parentInfo == null) return; linkParent(parentInfo); } classInfo.superclassInfo = parentInfo; } if (!parentInfo.subclassInfos.contains(classInfo)) { parentInfo.subclassInfos.add(classInfo); } }
/** * The link() method must be called to successfully use the findSubclasses and findImplementations methods * @return * @throws IOException */ public AbstractFinder link() throws IOException { // already linked? if (originalInfos.size() > 0) return this; // keep track of what was originally from the archives originalInfos.putAll(classInfos); for (ClassInfo classInfo : classInfos.values().toArray(new ClassInfo[classInfos.size()])) { linkParent(classInfo); } for (ClassInfo classInfo : classInfos.values().toArray(new ClassInfo[classInfos.size()])) { linkInterfaces(classInfo); } return this; }
private void linkInterfaces(ClassInfo classInfo) throws IOException { final List<ClassInfo> infos = new ArrayList<ClassInfo>(); if (classInfo.clazz != null){ final Class<?>[] interfaces = classInfo.clazz.getInterfaces(); for (Class<?> clazz : interfaces) { ClassInfo interfaceInfo = classInfos.get(clazz.getName()); if (interfaceInfo == null){ readClassDef(clazz); } interfaceInfo = classInfos.get(clazz.getName()); if (interfaceInfo != null) { infos.add(interfaceInfo); } } } else { for (String className : classInfo.interfaces) { ClassInfo interfaceInfo = classInfos.get(className); if (interfaceInfo == null){ readClassDef(className); } interfaceInfo = classInfos.get(className); if (interfaceInfo != null) { infos.add(interfaceInfo); } } } for (ClassInfo info : infos) { linkInterfaces(info); } }
log.debug("processPersistenceUnit(): Entry: AnnotatedApp: " + annotatedApp.toString()); List<Class<?>> classeswithPersistenceUnit = classFinder.findAnnotatedClasses(PersistenceUnit.class); List<Method> methodswithPersistenceUnit = classFinder.findAnnotatedMethods(PersistenceUnit.class); List<Field> fieldswithPersistenceUnit = classFinder.findAnnotatedFields(PersistenceUnit.class);
public List<Class<?>> findAnnotatedClasses(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<Class<?>> classes = new ArrayList<Class<?>>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof ClassInfo) { ClassInfo classInfo = (ClassInfo) info; try { Class clazz = classInfo.get(); // double check via proper reflection if (clazz.isAnnotationPresent(annotation)) { classes.add(clazz); } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return classes; }
log.debug("processHandlerChain(): Entry: AnnotatedApp: " + annotatedApp.toString()); List<Method> methodswithHandlerChain = classFinder.findAnnotatedMethods(HandlerChain.class); List<Field> fieldswithHandlerChain = classFinder.findAnnotatedFields(HandlerChain.class);
public <T> List<Class<? extends T>> findImplementations(Class<T> clazz) { if (clazz == null) throw new NullPointerException("class cannot be null"); if (!clazz.isInterface()) new IllegalArgumentException("class must be an interface"); classesNotLoaded.clear(); final String interfaceName = clazz.getName(); // Collect all interfaces extending the main interface (recursively) // Collect all implementations of interfaces // i.e. all *directly* implementing classes List<ClassInfo> infos = collectImplementations(interfaceName); // Collect all subclasses of implementations List<Class<? extends T>> classes = new ArrayList<Class<? extends T>>(); for (ClassInfo info : infos) { try { final Class<? extends T> impl = (Class<? extends T>) info.get(); if (clazz.isAssignableFrom(impl)) { classes.add(impl); // Optimization: Don't need to call this method if parent class was already searched classes.addAll(_findSubclasses(impl)); } } catch (ClassNotFoundException e) { classesNotLoaded.add(info.getName()); } } return classes; }
protected void readClassDef(String className) { int pos = className.indexOf("<"); if (pos > -1) { className = className.substring(0, pos); } pos = className.indexOf(">"); if (pos > -1) { className = className.substring(0, pos); } if (!className.endsWith(".class")) { className = className.replace('.', '/') + ".class"; } try { // TODO: check out META-INF/versions/<version>/className URL resource = getResource(className); if (resource != null) { InputStream in = resource.openStream(); try { readClassDef(in); } finally { in.close(); } } else { classesNotLoaded.add(className + " (no resource found for class)"); } } catch (IOException e) { classesNotLoaded.add(className + e.getMessage()); } }
public <T> List<Class<? extends T>> findSubclasses(Class<T> clazz) { if (clazz == null) throw new NullPointerException("class cannot be null"); classesNotLoaded.clear(); final ClassInfo classInfo = classInfos.get(clazz.getName()); List<Class<? extends T>> found = new ArrayList<Class<? extends T>>(); if (classInfo == null) return found; findSubclasses(classInfo, found, clazz); return found; }
private List<ClassInfo> collectImplementations(String interfaceName) { final List<ClassInfo> infos = new ArrayList<ClassInfo>(); for (ClassInfo classInfo : classInfos.values()) { if (classInfo.interfaces.contains(interfaceName)) { infos.add(classInfo); try { final Class clazz = classInfo.get(); if (clazz.isInterface() && !clazz.isAnnotation()) { infos.addAll(collectImplementations(classInfo.name)); } } catch (ClassNotFoundException ignore) { // we'll deal with this later } } } return infos; }
private <T> List<Class<? extends T>> _findSubclasses(Class<T> clazz) { if (clazz == null) throw new NullPointerException("class cannot be null"); List<Class<? extends T>> classes = new ArrayList<Class<? extends T>>(); for (ClassInfo classInfo : classInfos.values()) { try { if (clazz.getName().equals(classInfo.superType)) { if (clazz.isAssignableFrom(classInfo.get())) { classes.add(classInfo.get().asSubclass(clazz)); classes.addAll(_findSubclasses(classInfo.get().asSubclass(clazz))); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } return classes; }
log.debug("processEJB(): Entry: AnnotatedApp: " + annotatedApp.toString()); List<Class<?>> classesWithEJB = classFinder.findAnnotatedClasses(EJB.class); List<Method> methodsWithEJB = classFinder.findAnnotatedMethods(EJB.class); List<Field> fieldsWithEJB = classFinder.findAnnotatedFields(EJB.class);
public List<Class<?>> findAnnotatedClasses(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<Class<?>> classes = new ArrayList<Class<?>>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof ClassInfo) { ClassInfo classInfo = (ClassInfo) info; try { Class clazz = classInfo.get(); // double check via proper reflection if (clazz.isAnnotationPresent(annotation)) { classes.add(clazz); } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return classes; }
/** * The link() method must be called to successfully use the findSubclasses and findImplementations methods * @return * @throws IOException */ public AbstractFinder link() throws IOException { // already linked? if (originalInfos.size() > 0) return this; // keep track of what was originally from the archives originalInfos.putAll(classInfos); for (ClassInfo classInfo : classInfos.values().toArray(new ClassInfo[classInfos.size()])) { linkParent(classInfo); } for (ClassInfo classInfo : classInfos.values().toArray(new ClassInfo[classInfos.size()])) { linkInterfaces(classInfo); } return this; }
private void linkParent(ClassInfo classInfo) throws IOException { if (classInfo.superType == null) return; if (classInfo.superType.equals("java.lang.Object")) return; ClassInfo parentInfo = classInfo.superclassInfo; if (parentInfo == null) { parentInfo = classInfos.get(classInfo.superType); if (parentInfo == null) { if (classInfo.clazz != null) { readClassDef(((Class<?>) classInfo.clazz).getSuperclass()); } else { readClassDef(classInfo.superType); } parentInfo = classInfos.get(classInfo.superType); if (parentInfo == null) return; linkParent(parentInfo); } classInfo.superclassInfo = parentInfo; } if (!parentInfo.subclassInfos.contains(classInfo)) { parentInfo.subclassInfos.add(classInfo); } }
public <T> List<Class<? extends T>> findImplementations(Class<T> clazz) { if (clazz == null) throw new NullPointerException("class cannot be null"); if (!clazz.isInterface()) new IllegalArgumentException("class must be an interface"); classesNotLoaded.clear(); final String interfaceName = clazz.getName(); // Collect all interfaces extending the main interface (recursively) // Collect all implementations of interfaces // i.e. all *directly* implementing classes List<ClassInfo> infos = collectImplementations(interfaceName); // Collect all subclasses of implementations List<Class<? extends T>> classes = new ArrayList<Class<? extends T>>(); for (ClassInfo info : infos) { try { final Class<? extends T> impl = (Class<? extends T>) info.get(); if (clazz.isAssignableFrom(impl)) { classes.add(impl); // Optimization: Don't need to call this method if parent class was already searched classes.addAll(_findSubclasses(impl)); } } catch (ClassNotFoundException e) { classesNotLoaded.add(info.getName()); } } return classes; }
protected void readClassDef(String className) { int pos = className.indexOf("<"); if (pos > -1) { className = className.substring(0, pos); } pos = className.indexOf(">"); if (pos > -1) { className = className.substring(0, pos); } if (!className.endsWith(".class")) { className = className.replace('.', '/') + ".class"; } try { URL resource = getResource(className); if (resource != null) { InputStream in = resource.openStream(); try { readClassDef(in); } finally { in.close(); } } else { classesNotLoaded.add(className + " (no resource found for class)"); } } catch (IOException e) { classesNotLoaded.add(className + e.getMessage()); } }