Java 反射，包括给定包之外的类（Dropwizard+；Swagger）

我使用反射来获得所有具有以下代码的Api注释的类

Reflections reflections = new Reflections(ClasspathHelper.forPackage("my.package"),new TypeAnnotationsScanner());
Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Api.class);

Reflections Reflections=new Reflections（ClasspathHelper.forPackage（“my.package”）、new-typeannotationsCanner（）；
Set我终于用java类加载器解决了这个问题。一些意大利面代码！对不起

package com.glass.core.doc;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.List;

import com.wordnik.swagger.annotations.Api;

public class AnnotatedClassFinder {

    public Collection<Class> getAnnotatedClasess(Class annotation,
            String packageName) throws ClassNotFoundException, IOException {

        Collection<Class> allClasses = getClasses(packageName);
        List<Class> annotatedClass = new ArrayList<Class>();

        for (Class aClass : allClasses) {
            if (aClass.isAnnotationPresent(annotation)) {
                annotatedClass.add(aClass);
                System.out.println("!!!!!!!!!!!!!!!!!!!!!!!----------------!"
                        + aClass.getName());
            }
        }

        return annotatedClass;
    }

    /**
     * Scans all classes accessible from the context class loader which belong
     * to the given package and subpackages.
     * 
     * @param packageName
     *            The base package
     * @return The classes
     * @throws ClassNotFoundException
     * @throws IOException
     */
    private Collection<Class> getClasses(String packageName)
            throws ClassNotFoundException, IOException {

        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        String path = packageName.replace('.', '/');
        System.out.println("PATH:" + path);
        Enumeration<URL> resources = classLoader.getResources(path);
        List<File> dirs = new ArrayList<File>();
        while (resources.hasMoreElements()) {
            URL resource = resources.nextElement();
            dirs.add(new File(resource.getFile()));
        }
        List<Class> classes = new ArrayList<Class>();
        for (File directory : dirs) {
            classes.addAll(findClasses(directory, packageName));
        }

        return classes;
    }

    /**
     * Recursive method used to find all classes in a given directory and
     * subdirs.
     * 
     * @param directory
     *            The base directory
     * @param packageName
     *            The package name for classes found inside the base directory
     * @return The classes
     * @throws ClassNotFoundException
     */
    private List<Class> findClasses(File directory, String packageName)
            throws ClassNotFoundException {
        List<Class> classes = new ArrayList<Class>();
        if (!directory.exists()) {
            return classes;
        }
        File[] files = directory.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                classes.addAll(findClasses(file,
                        packageName + "." + file.getName()));
            } else if (file.getName().endsWith(".class")) {
                classes.add(Class.forName(packageName
                        + '.'
                        + file.getName().substring(0,
                                file.getName().length() - 6)));
            }
        }
        return classes;
    }
}

package com.glass.core.doc；
导入java.io.File；
导入java.io.IOException；
导入java.net.URL；
导入java.util.ArrayList；
导入java.util.Collection；
导入java.util.Enumeration；
导入java.util.List；
导入com.wordnik.swagger.annotations.Api；
公共类AnnotatedClassFinder{
公共集合GetAnnotatedClaess（类注释，
字符串packageName）抛出ClassNotFoundException、IOException{
集合allClasses=getClasses（packageName）；
List annotatedClass=new ArrayList（）；
对于（类aClass:allClasses）{
if（aClass.isAnnotationPresent（注释））{
annotatedClass.add（aClass）；
System.out.println（“
+aClass.getName（））；
}
}
返回注释类；
}
/**
*扫描可从上下文类加载器访问的所有属于
*到给定的包和子包。
* 
*@param packageName
*基本包
*@还课
*@ClassNotFoundException
*@抛出异常
*/
私有集合GetClass（字符串packageName）
抛出ClassNotFoundException，IOException{
ClassLoader ClassLoader=Thread.currentThread（）.getContextClassLoader（）；
字符串路径=packageName.replace（'.'，'/'）；
System.out.println（“路径：+PATH”）；
枚举资源=classLoader.getResources（路径）；
List dirs=new ArrayList（）；
while（resources.hasMoreElements（））{
URL resource=resources.nextElement（）；
添加（新文件（resource.getFile（））；
}
列表类=新的ArrayList（）；
for（文件目录：dirs）{
addAll（findClasses（目录，packageName））；
}
返回类；
}
/**
*递归方法，用于查找给定目录中的所有类和
*细分市场。
* 
*@param目录
*基本目录
*@param packageName
*在基目录中找到的类的包名称
*@还课
*@ClassNotFoundException
*/
私有列表FindClass（文件目录、字符串packageName）
抛出ClassNotFoundException{
列表类=新的ArrayList（）；
如果（！directory.exists（））{
返回类；
}
File[]files=目录.listFiles（）；
用于（文件：文件）{
if（file.isDirectory（））{
classes.addAll（findClasses）（文件，
packageName+“+file.getName（））；
}else if（file.getName（）.endsWith（“.class”））{
Class.add（Class.forName（packageName
+ '.'
+file.getName（）.substring（0，
file.getName（）.length（）-6））；
}
}
返回类；
}
}
我看到了完全相同的行为。它快把我逼疯了！