How do you find all subclasses of a given class in Java?
This is not possible to do using only the built-in Java Reflections API.
A project exists that does the necessary scanning and indexing of your classpath so you can get access this information.
Reflections
- get all subtypes of some type
- get all types annotated with some annotation
- get all types annotated with some annotation, including annotation parameters matching
- get all methods annotated with some
(disclaimer: I have not used it, but the project’s description seems to be an exact fit for your needs.)
Try ClassGraph. (Disclaimer, I am the author). ClassGraph supports scanning for subclasses of a given class, either at runtime or at build time, but also much more. ClassGraph can build an abstract representation of the entire class graph (all classes, annotations, methods, method parameters, and fields) in memory, for all classes on the classpath, or for classes in selected packages, and you can query this class graph however you want. ClassGraph supports more classpath specification mechanisms and classloaders than any other scanner, and also works seamlessly with the new JPMS module system, so if you base your code on ClassGraph, your code will be maximally portable. See the API here.
There is no other way to do it other than what you described. Think about it — how can anyone know what classes extend ClassX without scanning each class on the classpath?
Eclipse can only tell you about the super and subclasses in what seems to be an «efficient» amount of time because it already has all of the type data loaded at the point where you press the «Display in Type Hierarchy» button (since it is constantly compiling your classes, knows about everything on the classpath, etc).
Scanning for classes is not easy with pure Java.
The spring framework offers a class called ClassPathScanningCandidateComponentProvider that can do what you need. The following example would find all subclasses of MyClass in the package org.example.package
ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false); provider.addIncludeFilter(new AssignableTypeFilter(MyClass.class)); // scan in org.example.package Set components = provider.findCandidateComponents("org/example/package"); for (BeanDefinition component : components) < Class cls = Class.forName(component.getBeanClassName()); // use class cls found >This method has the additional benefit of using a bytecode analyzer to find the candidates which means it will not load all classes it scans.
Scan the classpath in Java: how to find all classes that extend a base class
In order to find all classes that extend a base class by using the ClassHunter, we must add to our pom.xml the following dependency:
org.burningwave core 12.62.7
… And to use Burningwave Core as a Java module, add the following to your module-info.java :
requires org.burningwave.core;
So let’s look for all classes that extend java.util.AbstractList:
import java.util.AbstractList; import java.util.Collection; import org.burningwave.core.assembler.ComponentContainer; import org.burningwave.core.assembler.ComponentSupplier; import org.burningwave.core.classes.ClassCriteria; import org.burningwave.core.classes.ClassHunter; import org.burningwave.core.classes.SearchConfig; import org.burningwave.core.io.PathHelper; public class Finder < public Collection> find() < ComponentSupplier componentSupplier = ComponentContainer.getInstance(); PathHelper pathHelper = componentSupplier.getPathHelper(); ClassHunter classHunter = componentSupplier.getClassHunter(); SearchConfig searchConfig = SearchConfig.forPaths( //Here you can add all absolute path you want: //both folders, zip and jar will be recursively scanned. //For example you can add: "C:\\Users\\user\\.m2" //With the row below the search will be executed on runtime Classpaths //(see https://github.com/burningwave/core/wiki/In-depth-look-to-ClassHunter-and-configuration-guide) pathHelper.getMainClassPaths() ).by( ClassCriteria.create().byClassesThatMatch((uploadedClasses, currentScannedClass) ->//[1]here you recall the uploaded class by "useClasses" method. In this case we find all class who extends java.util.AbstractList uploadedClasses.get(AbstractList.class).isAssignableFrom(currentScannedClass) ).useClasses( //With this directive we ask the library to load one or more classes to be used for comparisons: //it serves to eliminate the problem that a class, loaded by different class loaders, //turns out to be different for the comparison operators (eg. The isAssignableFrom method). //If you call this method, you must retrieve the uploaded class in all methods that support this feature like in the point[1] AbstractList.class ) ); try (ClassHunter.SearchResult searchResult = classHunter.findBy(searchConfig)) < return searchResult.getClasses(); >> >
How do you find all subclasses of a given class in Java?
This is not possible to do using only the built-in Java Reflections API.
A project exists that does the necessary scanning and indexing of your classpath so you can get access this information.
Reflections
- get all subtypes of some type
- get all types annotated with some annotation
- get all types annotated with some annotation, including annotation parameters matching
- get all methods annotated with some
(disclaimer: I have not used it, but the project’s description seems to be an exact fit for your needs.)
Try ClassGraph. (Disclaimer, I am the author). ClassGraph supports scanning for subclasses of a given class, either at runtime or at build time, but also much more. ClassGraph can build an abstract representation of the entire class graph (all classes, annotations, methods, method parameters, and fields) in memory, for all classes on the classpath, or for classes in selected packages, and you can query this class graph however you want. ClassGraph supports more classpath specification mechanisms and classloaders than any other scanner, and also works seamlessly with the new JPMS module system, so if you base your code on ClassGraph, your code will be maximally portable. See the API here.
There is no other way to do it other than what you described. Think about it — how can anyone know what classes extend ClassX without scanning each class on the classpath?
Eclipse can only tell you about the super and subclasses in what seems to be an «efficient» amount of time because it already has all of the type data loaded at the point where you press the «Display in Type Hierarchy» button (since it is constantly compiling your classes, knows about everything on the classpath, etc).
Scanning for classes is not easy with pure Java.
The spring framework offers a class called ClassPathScanningCandidateComponentProvider that can do what you need. The following example would find all subclasses of MyClass in the package org.example.package
ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false); provider.addIncludeFilter(new AssignableTypeFilter(MyClass.class)); // scan in org.example.package Set components = provider.findCandidateComponents("org/example/package"); for (BeanDefinition component : components) < Class cls = Class.forName(component.getBeanClassName()); // use class cls found >This method has the additional benefit of using a bytecode analyzer to find the candidates which means it will not load all classes it scans.