Java – find out which classes use a given API
In my java project, I want to find out which classes use the given API from the program Is there any way to do this? Can it be parsed through source code or bytecode? Because reflection won't be of any use, I'm afraid
To make things easier: there is no wildcard import (import com. Mycompany. API. *;) anywhere in my project, There is no fully qualified field or variable definition (private com. Mycompany. API. Mythingy;) There is no class forName(...) Structure Given these limitations, it boils down to parsing import statements, I guess Is there a preferred method?
Solution
You can use ASM's remapper course (believe it or not) to discover courses This class is actually used to replace all class names that appear in bytecode However, for your purposes, it does not need to replace anything
This may not be very meaningful, so here is an example
First, you create a remapper subclass whose sole purpose is to intercept all calls to the maptype (string) method and record its parameters for later use
public class ClassNameRecordingRemapper extends Remapper {
private final Set<? super String> classNames;
public ClassNameRecordingRemapper(Set<? super String> classNames) {
this.classNames = classNames;
}
@Override
public String mapType(String type) {
classNames.add(type);
return type;
}
}
Now you can write a method like this:
public Set<String> findClassNames(byte[] bytecode) {
Set<String> classNames = new HashSet<String>();
ClassReader classReader = new ClassReader(bytecode);
ClassWriter classWriter = new ClassWriter(classReader,0);
ClassNameRecordingRemapper remapper = new ClassNameRecordingRemapper(classNames);
classReader.accept(remapper,0);
return classNames;
}
It is your responsibility to actually get the bytecode of all classes
Seanizer edit (OP)
I accept this answer, but because the above code is not correct, I will insert the way I use:
public static class Collector extends Remapper{
private final Set<Class<?>> classNames;
private final String prefix;
public Collector(final Set<Class<?>> classNames,final String prefix){
this.classNames = classNames;
this.prefix = prefix;
}
/**
* {@inheritDoc}
*/
@Override
public String mapDesc(final String desc){
if(desc.startsWith("L")){
this.addType(desc.substring(1,desc.length() - 1));
}
return super.mapDesc(desc);
}
/**
* {@inheritDoc}
*/
@Override
public String[] mapTypes(final String[] types){
for(final String type : types){
this.addType(type);
}
return super.mapTypes(types);
}
private void addType(final String type){
final String className = type.replace('/','.');
if(className.startsWith(this.prefix)){
try{
this.classNames.add(Class.forName(className));
} catch(final ClassNotFoundException e){
throw new IllegalStateException(e);
}
}
}
@Override
public String mapType(final String type){
this.addType(type);
return type;
}
}
public static Set<Class<?>> getClassesUsedBy(
final String name,// class name
final String prefix // common prefix for all classes
// that will be retrieved
) throws IOException{
final ClassReader reader = new ClassReader(name);
final Set<Class<?>> classes =
new TreeSet<Class<?>>(new Comparator<Class<?>>(){
@Override
public int compare(final Class<?> o1,final Class<?> o2){
return o1.getName().compareTo(o2.getName());
}
});
final Remapper remapper = new Collector(classes,prefix);
final ClassVisitor inner = new EmptyVisitor();
final RemappingClassAdapter visitor =
new RemappingClassAdapter(inner,remapper);
reader.accept(visitor,0);
return classes;
}
This is a main class that tests it in the following ways:
public static void main(final String[] args) throws Exception{
final Collection<Class<?>> classes =
getClassesUsedBy(Collections.class.getName(),"java.util");
System.out.println("Used classes:");
for(final Class<?> cls : classes){
System.out.println(" - " + cls.getName());
}
}
Here is the output:
Used classes: - java.util.ArrayList - java.util.Arrays - java.util.Collection - java.util.Collections - java.util.Collections$1 - java.util.Collections$AsLIFOQueue - java.util.Collections$CheckedCollection - java.util.Collections$CheckedList - java.util.Collections$CheckedMap - java.util.Collections$CheckedRandomAccessList - java.util.Collections$CheckedSet - java.util.Collections$CheckedSortedMap - java.util.Collections$CheckedSortedSet - java.util.Collections$CopiesList - java.util.Collections$EmptyList - java.util.Collections$EmptyMap - java.util.Collections$EmptySet - java.util.Collections$ReverseComparator - java.util.Collections$ReverseComparator2 - java.util.Collections$SelfComparable - java.util.Collections$SetFromMap - java.util.Collections$SingletonList - java.util.Collections$SingletonMap - java.util.Collections$SingletonSet - java.util.Collections$SynchronizedCollection - java.util.Collections$SynchronizedList - java.util.Collections$SynchronizedMap - java.util.Collections$SynchronizedRandomAccessList - java.util.Collections$SynchronizedSet - java.util.Collections$SynchronizedSortedMap - java.util.Collections$SynchronizedSortedSet - java.util.Collections$UnmodifiableCollection - java.util.Collections$UnmodifiableList - java.util.Collections$UnmodifiableMap - java.util.Collections$UnmodifiableRandomAccessList - java.util.Collections$UnmodifiableSet - java.util.Collections$UnmodifiableSortedMap - java.util.Collections$UnmodifiableSortedSet - java.util.Comparator - java.util.Deque - java.util.Enumeration - java.util.Iterator - java.util.List - java.util.ListIterator - java.util.Map - java.util.Queue - java.util.Random - java.util.RandomAccess - java.util.Set - java.util.sortedMap - java.util.sortedSet