public List<Field> findAnnotatedFields(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Field> fields = new ArrayList<Field>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof FieldInfo) { FieldInfo fieldInfo = (FieldInfo) info; ClassInfo classInfo = fieldInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Field field : clazz.getDeclaredFields()) { if (field.isAnnotationPresent(annotation)) { fields.add(field); } } } catch (Throwable e) { if (LOG.isErrorEnabled()) LOG.error("Error loading class [#0]", e, classInfo.getName()); classesNotLoaded.add(classInfo.getName()); } } } return fields; }
public DefaultClassFinder(List<Class> classes){ this.classLoaderInterface = null; List<Info> infos = new ArrayList<Info>(); List<Package> packages = new ArrayList<Package>(); for (Class clazz : classes) { Package aPackage = clazz.getPackage(); if (aPackage != null && !packages.contains(aPackage)){ infos.add(new PackageInfo(aPackage)); packages.add(aPackage); } ClassInfo classInfo = new ClassInfo(clazz, this); infos.add(classInfo); classInfos.put(classInfo.getName(), classInfo); for (Method method : clazz.getDeclaredMethods()) { infos.add(new MethodInfo(classInfo, method)); } for (Constructor constructor : clazz.getConstructors()) { infos.add(new MethodInfo(classInfo, constructor)); } for (Field field : clazz.getDeclaredFields()) { infos.add(new FieldInfo(classInfo, field)); } } for (Info info : infos) { for (AnnotationInfo annotation : info.getAnnotations()) { List<Info> annotationInfos = getAnnotationInfos(annotation.getName()); annotationInfos.add(info); } } }
private void extractSuperInterfaces(ClassInfo classInfo) { String superType = classInfo.getSuperType(); if (superType != null) { ClassInfo base = classInfos.get(superType); if (base == null) { //try to load base String resource = superType.replace('.', '/') + ".class"; readClassDef(resource); base = classInfos.get(superType); } if (base != null) { List<String> interfaces = classInfo.getSuperInterfaces(); interfaces.addAll(base.getSuperInterfaces()); interfaces.addAll(base.getInterfaces()); } } }
public List<Method> findAnnotatedMethods(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Method> methods = new ArrayList<Method>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && !"<init>".equals(info.getName())) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Method method : clazz.getDeclaredMethods()) { if (method.isAnnotationPresent(annotation)) { methods.add(method); } } } catch (Throwable e) { if (LOG.isErrorEnabled()) LOG.error("Error loading class [#0]", e, classInfo.getName()); classesNotLoaded.add(classInfo.getName()); } } } return methods; }
public List<Constructor> findAnnotatedConstructors(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<>(); List<Constructor> constructors = new ArrayList<>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && "<init>".equals(info.getName())) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Constructor constructor : clazz.getConstructors()) { if (constructor.isAnnotationPresent(annotation)) { constructors.add(constructor); } } } catch (Throwable e) { LOG.error("Error loading class [{}]", classInfo.getName(), e); classesNotLoaded.add(classInfo.getName()); } } } return constructors; }
public boolean test(ClassFinder.ClassInfo classInfo) { // Why do we call includeClassNameInActionScan here, when it's // already been called to in the initial call to ClassFinder? // When some action class passes our package filter in that // step, // ClassFinder automatically includes parent classes of that // action, // such as com.opensymphony.xwork2.ActionSupport. We repeat the // package filter here to filter out such results. boolean inPackage = includeClassNameInActionScan(classInfo .getName()); boolean nameMatches = classInfo.getName() .endsWith(actionSuffix) || !requireFollowsConvention; try { return inPackage && (nameMatches || (checkImplementsAction && com.opensymphony.xwork2.Action.class .isAssignableFrom(classInfo.get()))); } catch (ClassNotFoundException ex) { if (LOG.isErrorEnabled()) LOG.error("Unable to load class [#0]", ex, classInfo.getName()); return false; } } };
public List<Method> findAnnotatedMethods(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<>(); List<Method> methods = new ArrayList<>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && !"<init>".equals(info.getName())) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Method method : clazz.getDeclaredMethods()) { if (method.isAnnotationPresent(annotation)) { methods.add(method); } } } catch (Throwable e) { LOG.error("Error loading class [{}]", classInfo.getName(), e); classesNotLoaded.add(classInfo.getName()); } } } return methods; }
public List<Field> findAnnotatedFields(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<>(); List<Field> fields = new ArrayList<>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof FieldInfo) { FieldInfo fieldInfo = (FieldInfo) info; ClassInfo classInfo = fieldInfo.getDeclaringClass(); if (seen.contains(classInfo)) { continue; } seen.add(classInfo); try { Class clazz = classInfo.get(); for (Field field : clazz.getDeclaredFields()) { if (field.isAnnotationPresent(annotation)) { fields.add(field); } } } catch (Throwable e) { LOG.error("Error loading class [{}]", classInfo.getName(), e); classesNotLoaded.add(classInfo.getName()); } } } return fields; }
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 (Throwable e) { if (LOG.isErrorEnabled()) LOG.error("Error loading class [#0]", e, classInfo.getName()); classesNotLoaded.add(classInfo.getName()); } } } return classes; }
public DefaultClassFinder(List<Class> classes){ this.classLoaderInterface = null; List<Info> infos = new ArrayList<>(); List<Package> packages = new ArrayList<>(); for (Class clazz : classes) { Package aPackage = clazz.getPackage(); if (aPackage != null && !packages.contains(aPackage)){ infos.add(new PackageInfo(aPackage)); packages.add(aPackage); } ClassInfo classInfo = new ClassInfo(clazz, this); infos.add(classInfo); classInfos.put(classInfo.getName(), classInfo); for (Method method : clazz.getDeclaredMethods()) { infos.add(new MethodInfo(classInfo, method)); } for (Constructor constructor : clazz.getConstructors()) { infos.add(new MethodInfo(classInfo, constructor)); } for (Field field : clazz.getDeclaredFields()) { infos.add(new FieldInfo(classInfo, field)); } } for (Info info : infos) { for (AnnotationInfo annotation : info.getAnnotations()) { List<Info> annotationInfos = getAnnotationInfos(annotation.getName()); annotationInfos.add(info); } } }
public List<Constructor> findAnnotatedConstructors(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Constructor> constructors = new ArrayList<Constructor>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && "<init>".equals(info.getName())) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Constructor constructor : clazz.getConstructors()) { if (constructor.isAnnotationPresent(annotation)) { constructors.add(constructor); } } } catch (Throwable e) { if (LOG.isErrorEnabled()) LOG.error("Error loading class [#0]", e, classInfo.getName()); classesNotLoaded.add(classInfo.getName()); } } } return constructors; }
public List<Class> findAnnotatedClasses(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<Class> classes = new ArrayList<>(); 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 (Throwable e) { LOG.error("Error loading class [{}]", classInfo.getName(), e); classesNotLoaded.add(classInfo.getName()); } } } return classes; }
public List<Class> findClassesInPackage(String packageName, boolean recursive) { classesNotLoaded.clear(); List<Class> classes = new ArrayList<Class>(); for (ClassInfo classInfo : classInfos.values()) { try { if (recursive && classInfo.getPackageName().startsWith(packageName)){ classes.add(classInfo.get()); } else if (classInfo.getPackageName().equals(packageName)){ classes.add(classInfo.get()); } } catch (Throwable e) { if (LOG.isErrorEnabled()) LOG.error("Error loading class [#0]", e, classInfo.getName()); classesNotLoaded.add(classInfo.getName()); } } return classes; }
public List<Class> findClasses(Test<ClassInfo> test) { classesNotLoaded.clear(); List<Class> classes = new ArrayList<Class>(); for (ClassInfo classInfo : classInfos.values()) { try { if (test.test(classInfo)) { classes.add(classInfo.get()); } } catch (Throwable e) { if (LOG.isErrorEnabled()) LOG.error("Error loading class [#0]", e, classInfo.getName()); classesNotLoaded.add(classInfo.getName()); } } return classes; }
public List<Class> findClassesInPackage(String packageName, boolean recursive) { classesNotLoaded.clear(); List<Class> classes = new ArrayList<>(); for (ClassInfo classInfo : classInfos.values()) { try { if (recursive && classInfo.getPackageName().startsWith(packageName)){ classes.add(classInfo.get()); } else if (classInfo.getPackageName().equals(packageName)){ classes.add(classInfo.get()); } } catch (Throwable e) { LOG.error("Error loading class [{}]", classInfo.getName(), e); classesNotLoaded.add(classInfo.getName()); } } return classes; }
public boolean test(ClassFinder.ClassInfo classInfo) { // Why do we call includeClassNameInActionScan here, when it's // already been called to in the initial call to ClassFinder? // When some action class passes our package filter in that step, // ClassFinder automatically includes parent classes of that action, // such as com.opensymphony.xwork2.ActionSupport. We repeat the // package filter here to filter out such results. boolean inPackage = includeClassNameInActionScan(classInfo.getName()); boolean nameMatches = matchesSuffix(classInfo.getName()); try { return inPackage && (nameMatches || (checkImplementsAction && com.opensymphony.xwork2.Action.class.isAssignableFrom(classInfo.get()))); } catch (ClassNotFoundException ex) { LOG.error("Unable to load class [{}]", classInfo.getName(), ex); return false; } }
public List<Class> findClasses(Test<ClassInfo> test) { classesNotLoaded.clear(); List<Class> classes = new ArrayList<>(); for (ClassInfo classInfo : classInfos.values()) { try { if (test.test(classInfo)) { classes.add(classInfo.get()); } } catch (Throwable e) { LOG.error("Error loading class [{}]", classInfo.getName(), e); classesNotLoaded.add(classInfo.getName()); } } return classes; }
@Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { if (name.endsWith("package-info")) { info = new PackageInfo(javaName(name), classFinder); } else { ClassInfo classInfo = new ClassInfo(javaName(name), javaName(superName), classFinder); for (String interfce : interfaces) { classInfo.getInterfaces().add(javaName(interfce)); } info = classInfo; classInfos.put(classInfo.getName(), classInfo); if (extractBaseInterfaces) extractSuperInterfaces(classInfo); } }
public List<Class> findClasses() { classesNotLoaded.clear(); List<Class> classes = new ArrayList<Class>(); for (ClassInfo classInfo : classInfos.values()) { try { classes.add(classInfo.get()); } catch (Throwable e) { if (LOG.isErrorEnabled()) LOG.error("Error loading class [#0]", e, classInfo.getName()); classesNotLoaded.add(classInfo.getName()); } } return classes; }
private void extractSuperInterfaces(ClassInfo classInfo) { String superType = classInfo.getSuperType(); if (superType != null) { ClassInfo base = classInfos.get(superType); if (base == null) { //try to load base String resource = superType.replace('.', '/') + ".class"; readClassDef(resource); base = classInfos.get(superType); } if (base != null) { List<String> interfaces = classInfo.getSuperInterfaces(); interfaces.addAll(base.getSuperInterfaces()); interfaces.addAll(base.getInterfaces()); } } }