Sie finden alle Klassen in einem Paket mit der spiegelung?

Sollten Sie vielleicht einen Blick auf die open-source -Reflexionen Bibliothek. Mit ihm können Sie leicht erreichen, was Sie wollen.

Erste, den setup der Reflexionen index (es ist ein bisschen chaotisch, da die Suche für alle Klassen, die standardmäßig deaktiviert ist):

List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
classLoadersList.add(ClasspathHelper.contextClassLoader());
classLoadersList.add(ClasspathHelper.staticClassLoader());

Reflections reflections = new Reflections(new ConfigurationBuilder()
    .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())
    .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
    .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("org.your.package"))));

Dann können Sie die Abfrage für alle Gegenstände in einem Paket:

Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);

InformationsquelleAutor Aleksander Blomskøld

Könnten Sie diese Methode¹ verwendet, die ClassLoader.

/**
 * 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 static Class[] getClasses(String packageName)
        throws ClassNotFoundException, IOException {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    assert classLoader != null;
    String path = packageName.replace('.', '/');
    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()));
    }
    ArrayList<Class> classes = new ArrayList<Class>();
    for (File directory : dirs) {
        classes.addAll(findClasses(directory, packageName));
    }
    return classes.toArray(new Class[classes.size()]);
}

/**
 * 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 static 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()) {
            assert !file.getName().contains(".");
            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;
}

__________

_{¹ Diese Methode wurde schon ursprünglich von http://snippets.dzone.com/posts/show/4831, das war archiviert durch das Internet-Archiv, als mit nun. Das snippet ist auch in https://dzone.com/articles/get-all-classes-within-package.}

InformationsquelleAutor

Hallo. Ich habe immer einige Probleme hatte mit den oben genannten Lösungen (und auf anderen Seiten).

Ich, als Entwickler, Programmierung bin ein addon für eine API. Die API verhindert die Verwendung einer externen Bibliotheken oder 3rd-party-tools. Das setup besteht auch aus einer Mischung von code in jar-oder zip-Dateien und class-Dateien direkt in einige Verzeichnisse. Also mein code musste in der Lage sein zu arbeiten, um jedem setup. Nach viel Forschung, die ich habe kommen mit einer Methode, die die Arbeit in mindestens 95% aller möglichen setups.

Folgende code ist im Grunde der overkill-Methode, die immer funktioniert.

Code:

Dieser code durchsucht ein bestimmtes package für alle Klassen, die in Ihr enthalten sind. Es wird nur funktionieren für alle Klassen in der aktuellen ClassLoader.

/**
 * Private helper method
 * 
 * @param directory
 *            The directory to start with
 * @param pckgname
 *            The package name to search for. Will be needed for getting the
 *            Class object.
 * @param classes
 *            if a file isn't loaded but still is in the directory
 * @throws ClassNotFoundException
 */
private static void checkDirectory(File directory, String pckgname,
        ArrayList<Class<?>> classes) throws ClassNotFoundException {
    File tmpDirectory;

    if (directory.exists() && directory.isDirectory()) {
        final String[] files = directory.list();

        for (final String file : files) {
            if (file.endsWith(".class")) {
                try {
                    classes.add(Class.forName(pckgname + '.'
                            + file.substring(0, file.length() - 6)));
                } catch (final NoClassDefFoundError e) {
                    //do nothing. this class hasn't been found by the
                    //loader, and we don't care.
                }
            } else if ((tmpDirectory = new File(directory, file))
                    .isDirectory()) {
                checkDirectory(tmpDirectory, pckgname + "." + file, classes);
            }
        }
    }
}

/**
 * Private helper method.
 * 
 * @param connection
 *            the connection to the jar
 * @param pckgname
 *            the package name to search for
 * @param classes
 *            the current ArrayList of all classes. This method will simply
 *            add new classes.
 * @throws ClassNotFoundException
 *             if a file isn't loaded but still is in the jar file
 * @throws IOException
 *             if it can't correctly read from the jar file.
 */
private static void checkJarFile(JarURLConnection connection,
        String pckgname, ArrayList<Class<?>> classes)
        throws ClassNotFoundException, IOException {
    final JarFile jarFile = connection.getJarFile();
    final Enumeration<JarEntry> entries = jarFile.entries();
    String name;

    for (JarEntry jarEntry = null; entries.hasMoreElements()
            && ((jarEntry = entries.nextElement()) != null);) {
        name = jarEntry.getName();

        if (name.contains(".class")) {
            name = name.substring(0, name.length() - 6).replace('/', '.');

            if (name.contains(pckgname)) {
                classes.add(Class.forName(name));
            }
        }
    }
}

/**
 * Attempts to list all the classes in the specified package as determined
 * by the context class loader
 * 
 * @param pckgname
 *            the package name to search
 * @return a list of classes that exist within that package
 * @throws ClassNotFoundException
 *             if something went wrong
 */
public static ArrayList<Class<?>> getClassesForPackage(String pckgname)
        throws ClassNotFoundException {
    final ArrayList<Class<?>> classes = new ArrayList<Class<?>>();

    try {
        final ClassLoader cld = Thread.currentThread()
                .getContextClassLoader();

        if (cld == null)
            throw new ClassNotFoundException("Can't get class loader.");

        final Enumeration<URL> resources = cld.getResources(pckgname
                .replace('.', '/'));
        URLConnection connection;

        for (URL url = null; resources.hasMoreElements()
                && ((url = resources.nextElement()) != null);) {
            try {
                connection = url.openConnection();

                if (connection instanceof JarURLConnection) {
                    checkJarFile((JarURLConnection) connection, pckgname,
                            classes);
                } else if (connection instanceof FileURLConnection) {
                    try {
                        checkDirectory(
                                new File(URLDecoder.decode(url.getPath(),
                                        "UTF-8")), pckgname, classes);
                    } catch (final UnsupportedEncodingException ex) {
                        throw new ClassNotFoundException(
                                pckgname
                                        + " does not appear to be a valid package (Unsupported encoding)",
                                ex);
                    }
                } else
                    throw new ClassNotFoundException(pckgname + " ("
                            + url.getPath()
                            + ") does not appear to be a valid package");
            } catch (final IOException ioex) {
                throw new ClassNotFoundException(
                        "IOException was thrown when trying to get all resources for "
                                + pckgname, ioex);
            }
        }
    } catch (final NullPointerException ex) {
        throw new ClassNotFoundException(
                pckgname
                        + " does not appear to be a valid package (Null pointer exception)",
                ex);
    } catch (final IOException ioex) {
        throw new ClassNotFoundException(
                "IOException was thrown when trying to get all resources for "
                        + pckgname, ioex);
    }

    return classes;
}

Diese drei Methoden bieten Ihnen die Möglichkeit zu finden, alle Klassen in einem Paket.

Verwenden Sie es wie folgt:

getClassesForPackage("package.your.classes.are.in");

Die Erklärung:

Die Methode ruft zuerst die aktuelle ClassLoader. Anschließend ruft alle Ressourcen, die enthalten Sprach-Paket und iteriert diese URLs. Es erstellt dann eine URLConnection und bestimmt, welche Art von URl, die wir haben. Es kann entweder ein Verzeichnis (FileURLConnection) oder ein Verzeichnis innerhalb einer jar-oder zip-Datei (JarURLConnection). Je nachdem, welche Art der Verbindung, die wir haben zwei verschiedene Methoden aufgerufen werden.

Ersten mal sehen, was passiert, wenn es eine FileURLConnection.

Es wird zunächst geprüft, ob die übergebene Datei existiert und ist ein Verzeichnis. Wenn das der Fall ist, prüft es, ob es eine class-Datei. Wenn das so ein Class - Objekt wird erstellt und in den ArrayList. Wenn es nicht eine Klasse-Datei, sondern ein Verzeichnis ist, können wir einfach Durchlaufen in Sie und das gleiche tun. Alle anderen Fälle/Dateien werden ignoriert.

Wenn die URLConnection ist ein JarURLConnection die andere private Helfer-Methode aufgerufen werden. Diese Methode iteriert über alle Einträge in der zip - /jar-Archiv. Wenn ein Eintrag einer Klasse-Datei, und ist in dem Paket eine Class - Objekt erstellt und gespeichert in der ArrayList.

Nachdem alle Ressourcen wurden analysiert (die main-Methode) zurück, die ArrayList containig alle Klassen in das Paket gegeben, dass die aktuelle ClassLoader kennt.

Bricht der Prozess an jedem Punkt eine ClassNotFoundException geworfen werden, die detaillierte Informationen über die genaue Ursache.

InformationsquelleAutor BrainStone

In der Allgemeinen Klasse Lader nicht zulassen und Scannen, die durch alle Klassen im classpath. Aber in der Regel nur verwendet class-loader ist UrlClassLoader aus, die wir abrufen können, die Liste von Verzeichnissen und jar-Dateien (siehe getURLs) und öffnen Sie Sie eins nach dem anderen, um eine Liste der verfügbaren Klassen. Dieser Ansatz, genannt class-path Scannen, ist implementiert in Scannotation und Reflexionen.

Reflections reflections = new Reflections("my.package");
Set<Class<? extends Object>> classes = reflections.getSubTypesOf(Object.class);

Ein weiterer Ansatz ist die Verwendung Java Pluggable Annotation Processing API zu schreiben annotation-Prozessor sammelt alle annotierten Klassen zur compile-Zeit und erstellen Sie die index-Datei zur Laufzeit zu verwenden. Dieser Mechanismus wird umgesetzt in ClassIndex Bibliothek:

//package-info.java
@IndexSubclasses
package my.package;

//your code
Iterable<Class> classes = ClassIndex.getPackageClasses("my.package");

Beachten Sie, dass kein zusätzliches setup notwendig ist, da das Scannen ist voll automatisiert, Dank der Java-compiler automatisch entdecken Sie alle Prozessoren auf dem classpath.

InformationsquelleAutor Sławek

Hier ist, wie ich es mache. Ich scanne alle Unterordner (sub-packages) und ich versuche nicht, zu laden, anonyme Klassen:

   /**
   * Attempts to list all the classes in the specified package as determined
   * by the context class loader, recursively, avoiding anonymous classes
   * 
   * @param pckgname
   *            the package name to search
   * @return a list of classes that exist within that package
   * @throws ClassNotFoundException
   *             if something went wrong
   */
  private static List<Class> getClassesForPackage(String pckgname) throws ClassNotFoundException {
      //This will hold a list of directories matching the pckgname. There may be more than one if a package is split over multiple jars/paths
      ArrayList<File> directories = new ArrayList<File>();
      String packageToPath = pckgname.replace('.', '/');
      try {
          ClassLoader cld = Thread.currentThread().getContextClassLoader();
          if (cld == null) {
              throw new ClassNotFoundException("Can't get class loader.");
          }

          //Ask for all resources for the packageToPath
          Enumeration<URL> resources = cld.getResources(packageToPath);
          while (resources.hasMoreElements()) {
              directories.add(new File(URLDecoder.decode(resources.nextElement().getPath(), "UTF-8")));
          }
      } catch (NullPointerException x) {
          throw new ClassNotFoundException(pckgname + " does not appear to be a valid package (Null pointer exception)");
      } catch (UnsupportedEncodingException encex) {
          throw new ClassNotFoundException(pckgname + " does not appear to be a valid package (Unsupported encoding)");
      } catch (IOException ioex) {
          throw new ClassNotFoundException("IOException was thrown when trying to get all resources for " + pckgname);
      }

      ArrayList<Class> classes = new ArrayList<Class>();
      //For every directoryFile identified capture all the .class files
      while (!directories.isEmpty()){
          File directoryFile  = directories.remove(0);             
          if (directoryFile.exists()) {
              //Get the list of the files contained in the package
              File[] files = directoryFile.listFiles();

              for (File file : files) {
                  //we are only interested in .class files
                  if ((file.getName().endsWith(".class")) && (!file.getName().contains("$"))) {
                      //removes the .class extension
                      int index = directoryFile.getPath().indexOf(packageToPath);
                      String packagePrefix = directoryFile.getPath().substring(index).replace('/', '.');;                          
                    try {                  
                      String className = packagePrefix + '.' + file.getName().substring(0, file.getName().length() - 6);                            
                      classes.add(Class.forName(className));                                
                    } catch (NoClassDefFoundError e)
                    {
                      //do nothing. this class hasn't been found by the loader, and we don't care.
                    }
                  } else if (file.isDirectory()){ //If we got to a subdirectory
                      directories.add(new File(file.getPath()));                          
                  }
              }
          } else {
              throw new ClassNotFoundException(pckgname + " (" + directoryFile.getPath() + ") does not appear to be a valid package");
          }
      }
      return classes;
  }  

InformationsquelleAutor Nadav B

Ja mit paar API ' s können Sie, hier ist, wie ich mag, es zu tun, konfrontiert mit diesem problem, die ich mit hibernate core & hatte, zu finden, welche Klassen wo kommentiert mit einer bestimmten annotation.

Machen diese eine benutzerdefinierte Anmerkung mit denen Sie Kennzeichnen, welche Klassen Sie abgeholt werden möchten.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EntityToBeScanned {

}

Dann markieren Sie Ihre Klasse mit es wie

@EntityToBeScanned 
public MyClass{

}

Machen diese utility-Klasse die folgende Methode

public class ClassScanner {

    public static Set<Class<?>> allFoundClassesAnnotatedWithEntityToBeScanned(){
        Reflections reflections = new Reflections(".*");
        Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(EntityToBeScanned.class);
        return annotated;
    }

}

Rufen Sie die allFoundClassesAnnotatedWithEntitytobescanned() Methode, um einen Set von Klassen gefunden.

Sie benötigen libs, die unten gegeben

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>21.0</version>
    </dependency>
<!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
<dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.22.0-CR1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.reflections/reflections -->
<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.9.10</version>
</dependency>

InformationsquelleAutor Sujal Mandal

Ich versucht habe zu verwenden, die Reflexionen, die Bibliothek, hatte aber einige Probleme, es zu benutzen, und es waren zu viele Gläser sollte ich auch nur einfach erhalten die Klassen in einem Paket.

Werde ich nach einer Lösung, die ich gefunden habe in dieser doppelten Frage: Wie alle Klassen-Namen in einem Paket?

Den Antwort wurde geschrieben von sp00m; ich habe Hinzugefügt, einige Korrekturen zu machen, damit es funktioniert:

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

public final class ClassFinder {

    private final static char DOT = '.';
    private final static char SLASH = '/';
    private final static String CLASS_SUFFIX = ".class";
    private final static String BAD_PACKAGE_ERROR = "Unable to get resources from path '%s'. Are you sure the given '%s' package exists?";

    public final static List<Class<?>> find(final String scannedPackage) {
        final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        final String scannedPath = scannedPackage.replace(DOT, SLASH);
        final Enumeration<URL> resources;
        try {
            resources = classLoader.getResources(scannedPath);
        } catch (IOException e) {
            throw new IllegalArgumentException(String.format(BAD_PACKAGE_ERROR, scannedPath, scannedPackage), e);
        }
        final List<Class<?>> classes = new LinkedList<Class<?>>();
        while (resources.hasMoreElements()) {
            final File file = new File(resources.nextElement().getFile());
            classes.addAll(find(file, scannedPackage));
        }
        return classes;
    }

    private final static List<Class<?>> find(final File file, final String scannedPackage) {
        final List<Class<?>> classes = new LinkedList<Class<?>>();
        if (file.isDirectory()) {
            for (File nestedFile : file.listFiles()) {
                classes.addAll(find(nestedFile, scannedPackage));
            }
        //File names with the $1, $2 holds the anonymous inner classes, we are not interested on them. 
        } else if (file.getName().endsWith(CLASS_SUFFIX) && !file.getName().contains("$")) {

            final int beginIndex = 0;
            final int endIndex = file.getName().length() - CLASS_SUFFIX.length();
            final String className = file.getName().substring(beginIndex, endIndex);
            try {
                final String resource = scannedPackage + DOT + className;
                classes.add(Class.forName(resource));
            } catch (ClassNotFoundException ignore) {
            }
        }
        return classes;
    }

}

Es nur verwenden, rufen Sie die Methode finden, wie sp00n erwähnt in diesem Beispiel:
Ich habe das erstellen von Instanzen der Klassen, wenn nötig.

List<Class<?>> classes = ClassFinder.find("com.package");

ExcelReporting excelReporting;
for (Class<?> aClass : classes) {
    Constructor constructor = aClass.getConstructor();
    //Create an object of the class type
    constructor.newInstance();
    //...
}

InformationsquelleAutor Martín C

Fast alle Antworten, die entweder verwendet Reflections oder liest die class-Dateien aus dem Datei-system. Wenn Sie versuchen, Lesen die Klassen von Datei-system, erhalten Sie möglicherweise Fehler beim Verpacken der Anwendung als JAR-oder anderen. Auch können Sie nicht wollen, verwenden Sie eine separate Bibliothek für diesen Zweck.

Hier ist ein anderer Ansatz, das ist reines java und nicht hängt davon ab, Datei-system.

import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

public class PackageUtil {

    public static Collection<Class> getClasses(final String pack) throws Exception {
        final StandardJavaFileManager fileManager = ToolProvider.getSystemJavaCompiler().getStandardFileManager(null, null, null);
        return StreamSupport.stream(fileManager.list(StandardLocation.CLASS_PATH, pack, Collections.singleton(JavaFileObject.Kind.CLASS), false).spliterator(), false)
                .map(javaFileObject -> {
                    try {
                        final String[] split = javaFileObject.getName()
                                .replace(".class", "")
                                .replace(")", "")
                                .split(Pattern.quote(File.separator));

                        final String fullClassName = pack + "." + split[split.length - 1];
                        return Class.forName(fullClassName);
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                    }

                })
                .collect(Collectors.toCollection(ArrayList::new));
    }
}

Java 8 ist kein muss. Sie können for-Schleifen anstelle des streams.
Und Sie können testen, wie diese

public static void main(String[] args) throws Exception {
    final String pack = "java.nio.file"; //Or any other package
    PackageUtil.getClasses(pack).stream().forEach(System.out::println);
}

InformationsquelleAutor bhdrkn

Vorausgesetzt, Sie sind nicht mit jedem dynamischer class loader können Sie die Suche im classpath und für jeden Eintrag durchsuchen Sie das Verzeichnis oder die JAR-Datei.

InformationsquelleAutor Lawrence Dol

Es ist sehr gut möglich, aber ohne zusätzliche Bibliotheken, wie Reflections es ist schwer...

Es ist schwer, weil du noch nicht das volle instrument bekommen, Klasse name.

Und, ich nehme den code von meinem ClassFinder Klasse:

package play.util;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * Created by LINKOR on 26.05.2017 in 15:12.
 * Date: 2017.05.26
 */
public class FileClassFinder {
private JarFile file;
private boolean trouble;
public FileClassFinder(String filePath) {
    try {
        file = new JarFile(filePath);
    } catch (IOException e) {
        trouble = true;
    }
}

public List<String> findClasses(String pkg) {
    ArrayList<String> classes = new ArrayList<>();
    Enumeration<JarEntry> entries = file.entries();
    while (entries.hasMoreElements()) {
        JarEntry cls = entries.nextElement();
        if (!cls.isDirectory()) {
            String fileName = cls.getName();
            String className = fileName.replaceAll("/",         ".").replaceAll(File.pathSeparator, ".").substring(0, fileName.lastIndexOf('.'));
            if (className.startsWith(pkg)) classes.add(className.substring(pkg.length() + 1));
        }
    }
    return classes;
}
}

InformationsquelleAutor Muskovets

Wenn Sie nur suchen, um laden Sie eine Gruppe von verbundenen Klassen, dann die Feder kann Ihnen helfen.

Frühjahr instanziieren können eine Liste oder Karte aller Klassen, die die Implementierung eines bestimmten interface in einer Zeile code. Die Liste oder eine Karte enthalten, die Instanzen aller Klassen, implementieren diese Schnittstelle.

Dass gesagt wird, die als alternative zu dem laden der Liste der Klassen außerhalb der Datei-system, statt nur implementieren die gleiche Schnittstelle in allen Klassen, die Sie laden möchten, unabhängig von Paket und nutzen Spring, bieten Sie Instanzen aller von Ihnen. Auf diese Weise können Sie das laden (instanziieren) alle Klassen, die Sie wünschen, unabhängig davon, zu welchem Paket Sie sich befinden.

Auf der anderen Seite, wenn Sie alle in einem Paket ist, was Sie wollen, dann müssen einfach alle Klassen in diesem Paket implementieren eine bestimmte Schnittstelle.

InformationsquelleAutor Rodney P. Barbati

Es ist nicht möglich, da alle Klassen im Paket kann nicht geladen werden, während Sie immer weiß, Paket einer Klasse.

InformationsquelleAutor Marko