1. Overview
In this tutorial, we’ll learn different techniques to list all classes loaded in the JVM. For example, we can load the JVM’s heap dump or connect the running applications to various tools and list all the classes loaded in that tool. Also, there are various libraries to accomplish this programmatically.
We’ll explore both the non-programmatic well as programmatic approaches.
2. Non-Programmatic Approach
2.1. Using VM Argument
The most straightforward approach for listing all classes loaded would be to log that in a console output or file.
We’ll run the Java Application with the below JVM Argument:
java <app_name> --verbose:class
[Opened /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Object from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.io.Serializable from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Comparable from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.CharSequence from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.String from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.reflect.AnnotatedElement from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.reflect.GenericDeclaration from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.reflect.Type from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Class from /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/jre/lib/rt.jar]
...............................
For Java 9, we’ll use the -Xlog JVM Argument to log the classes loaded onto file:
java <app_name> -Xlog:class+load=info:classloaded.txt
2.2. Using Heap Dump
We’ll see how different tools use the JVM heap dump to extract class-loaded information. But, first, we’ll generate the heap dump using the command below:
jmap -dump:format=b,file=/opt/tmp/heapdump.bin <app_pid>
The above heap dump can be opened in various tools to get different metrics.
In Eclipse, we’ll load the heap dump file heapdump.bin in the Eclipse Memory Analyzer and use the Histogram Interface:
We’ll now open the heap dump file heapdump.bin in the Java VisualVM interface and use the classes by instances or size option:
2.3. JProfiler
JProfiler is one of the top Java Application Profilers with a rich set of features to view different metrics.
In JProfiler, we can attach to running JVM or load the heap dump file and get all the JVM-related metrics, including names of all classes loaded.
We’ll use the attach process feature to let JProfiler connect to the running application ListLoadedClass:
Then, we’ll take the snapshot of the application and use that to get all classes loaded:
Below, we can see the names of the loaded classes instance counts using Heap Walker functionality:
3. Programmatic Approach
3.1. Instrumentation API
Java provides Instrumentation API, which helps in getting valuable metrics on the application. First, we’ll have to create and load a Java Agent to acquire an instance of the Instrumentation interface into the application. A Java agent is a tool to instrument programs running on the JVM.
Then, we’ll need to invoke the Instrumentation method getInitiatedClasses(Classloader loader) to get all the classes loaded by a particular class loader type.
3.2. Google Guava
We’ll see how the Guava Library can get a list of all classes loaded into JVM using a current class loader.
Let’s start by adding the Guava dependency to our Maven project:
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>31.0.1-jre</version>
</dependency>
We’ll initialize the ClassPath object with the current class loader instance:
ClassPath classPath = ClassPath.from(ListLoadedClass.class.getClassLoader());
Set<ClassInfo> classes = classPath.getAllClasses();
Assertions.assertTrue(4 < classes.size());
3.3. Reflections API
We’ll use the Reflections library that scans the current classpath and allows us to query it at runtime.
Let’s start by adding the reflections dependency to our Maven project:
<dependency>
<groupId>org.reflections</groupId>
<artifactId>reflections</artifactId>
<version>0.10.2</version>
</dependency>
Now, we’ll look into the sample code, which returns a set of classes under a package:
Reflections reflections = new Reflections(packageName, new SubTypesScanner(false));
Set<Class> classes = reflections.getSubTypesOf(Object.class)
.stream()
.collect(Collectors.toSet());
Assertions.assertEquals(4, classes.size());
4. Conclusion
In this article, we’ve learned various ways of listing all the classes loaded in the JVM. First, we’ve seen how using a VM Argument can log the list of loaded classes.
Then, we’ve explored how various tools can load the heap dump or connect to the JVM to show various metrics, including classes loaded. Lastly, we’ve covered some of the Java libraries.
As always, all the code is available over on GitHub.
