如何检测jar文件中的类是否正在扩展其他类,或者是否创建了对其他类对象或其他类对象的方法调用? 然后系统输出哪个类扩展哪个类以及哪个类调用哪个类的方法。
我使用Classparser解析jar。这是我的代码的一部分:
String jarfile = "C:\\Users\\OOOO\\Desktop\\Sample.Jar";
jar = new JarFile(jarfile);
Enumeration<JarEntry> entries = jar.entries();
while (entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
if (!entry.getName().endsWith(".class")) {
continue;
}
ClassParser parser = new ClassParser(jarfile, entry.getName());
JavaClass javaClass = parser.parse();
答案 0 :(得分:2)
有人投票决定关闭这个问题&#34;太宽泛&#34;。我不确定这是否是适当的接近原因,但可能是因为人们可以考虑这个问题(这是your previous question的后续行动),只是要求其他人为你做一些工作子>
但是,要回答基本问题如何检测具有BCEL的单个JAR文件中的类之间的引用:
您可以从JavaClass
获取JarFile
个对象的列表。对于这些JavaClass
个对象中的每一个,您都可以检查Method
个对象及其InstructionList
。在这些指令中,您可以选择InvokeInstruction
对象并进一步检查它们,以找出实际调用哪个类的方法。
以下程序打开一个JAR文件(出于显而易见的原因,它是bcel-5.2.jar
- 您无论如何都需要它......)并以上述方式处理它。对于JAR文件的每个JavaClass
,它会创建一个从所有引用的JavaClass
对象到这些类上调用的Method
列表的映射,并相应地打印信息:< / p>
import java.io.IOException;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import org.apache.bcel.classfile.ClassFormatException;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.ConstantPool;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.generic.ConstantPoolGen;
import org.apache.bcel.generic.Instruction;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.InvokeInstruction;
import org.apache.bcel.generic.MethodGen;
import org.apache.bcel.generic.ObjectType;
import org.apache.bcel.generic.ReferenceType;
import org.apache.bcel.generic.Type;
public class BCELRelationships
{
public static void main(String[] args) throws Exception
{
JarFile jarFile = null;
try
{
String jarName = "bcel-5.2.jar";
jarFile = new JarFile(jarName);
findReferences(jarName, jarFile);
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (jarFile != null)
{
try
{
jarFile.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}
private static void findReferences(String jarName, JarFile jarFile)
throws ClassFormatException, IOException, ClassNotFoundException
{
Map<String, JavaClass> javaClasses =
collectJavaClasses(jarName, jarFile);
for (JavaClass javaClass : javaClasses.values())
{
System.out.println("Class "+javaClass.getClassName());
Map<JavaClass, Set<Method>> references =
computeReferences(javaClass, javaClasses);
for (Entry<JavaClass, Set<Method>> entry : references.entrySet())
{
JavaClass referencedJavaClass = entry.getKey();
Set<Method> methods = entry.getValue();
System.out.println(
" is referencing class "+
referencedJavaClass.getClassName()+" by calling");
for (Method method : methods)
{
System.out.println(
" "+method.getName()+" with arguments "+
Arrays.toString(method.getArgumentTypes()));
}
}
}
}
private static Map<String, JavaClass> collectJavaClasses(
String jarName, JarFile jarFile)
throws ClassFormatException, IOException
{
Map<String, JavaClass> javaClasses =
new LinkedHashMap<String, JavaClass>();
Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements())
{
JarEntry entry = entries.nextElement();
if (!entry.getName().endsWith(".class"))
{
continue;
}
ClassParser parser =
new ClassParser(jarName, entry.getName());
JavaClass javaClass = parser.parse();
javaClasses.put(javaClass.getClassName(), javaClass);
}
return javaClasses;
}
public static Map<JavaClass, Set<Method>> computeReferences(
JavaClass javaClass, Map<String, JavaClass> knownJavaClasses)
throws ClassNotFoundException
{
Map<JavaClass, Set<Method>> references =
new LinkedHashMap<JavaClass, Set<Method>>();
ConstantPool cp = javaClass.getConstantPool();
ConstantPoolGen cpg = new ConstantPoolGen(cp);
for (Method m : javaClass.getMethods())
{
String fullClassName = javaClass.getClassName();
String className =
fullClassName.substring(0, fullClassName.length()-6);
MethodGen mg = new MethodGen(m, className, cpg);
InstructionList il = mg.getInstructionList();
if (il == null)
{
continue;
}
InstructionHandle[] ihs = il.getInstructionHandles();
for(int i=0; i < ihs.length; i++)
{
InstructionHandle ih = ihs[i];
Instruction instruction = ih.getInstruction();
if (!(instruction instanceof InvokeInstruction))
{
continue;
}
InvokeInstruction ii = (InvokeInstruction)instruction;
ReferenceType referenceType = ii.getReferenceType(cpg);
if (!(referenceType instanceof ObjectType))
{
continue;
}
ObjectType objectType = (ObjectType)referenceType;
String referencedClassName = objectType.getClassName();
JavaClass referencedJavaClass =
knownJavaClasses.get(referencedClassName);
if (referencedJavaClass == null)
{
continue;
}
String methodName = ii.getMethodName(cpg);
Type[] argumentTypes = ii.getArgumentTypes(cpg);
Method method =
findMethod(referencedJavaClass, methodName, argumentTypes);
Set<Method> methods = references.get(referencedJavaClass);
if (methods == null)
{
methods = new LinkedHashSet<Method>();
references.put(referencedJavaClass, methods);
}
methods.add(method);
}
}
return references;
}
private static Method findMethod(
JavaClass javaClass, String methodName, Type argumentTypes[])
throws ClassNotFoundException
{
for (Method method : javaClass.getMethods())
{
if (method.getName().equals(methodName))
{
if (Arrays.equals(argumentTypes, method.getArgumentTypes()))
{
return method;
}
}
}
for (JavaClass superClass : javaClass.getSuperClasses())
{
Method method = findMethod(superClass, methodName, argumentTypes);
if (method != null)
{
return method;
}
}
return null;
}
}
但请注意,从任何意义上讲,此信息可能都不完整。例如,由于多态性,您可能无法始终检测到某个类的对象上调用了某个方法,因为它是“隐藏的”#34;多态抽象背后。例如,在
之类的代码段中void call() {
MyClass m = new MyClass();
callToString(m);
}
void callToString(Object object) {
object.toString();
}
toString
的调用实际上发生在MyClass
的实例上。但由于多态性,它只能被识别为在某些Object
&#34;上调用此方法。
答案 1 :(得分:1)
免责声明:严格来说,这不是您问题的答案,因为它不使用BCEL而是使用Javassist。不过,您可能会发现我的经验和代码很有用。
几年前,我为此目的编写了一个Maven插件(我称之为Storyteller Maven Plugin) - 分析JAR文件中是否存在不必要或不需要的依赖项。
请看这个问题:
How to find unneccesary dependencies in a maven multi-project?
虽然插件工作但我从未发布过它。现在我moved it to GitHub只是为了让别人可以访问它。
您要求解析JAR以分析.class
个文件中的代码。下面是几个Javassist代码片段。
Search a JAR file for classes and create a CtClass per entry:
final JarFile artifactJarFile = new JarFile(artifactFile);
final Enumeration<JarEntry> jarEntries = artifactJarFile
.entries();
while (jarEntries.hasMoreElements()) {
final JarEntry jarEntry = jarEntries.nextElement();
if (jarEntry.getName().endsWith(".class")) {
InputStream is = null;
CtClass ctClass = null;
try {
is = artifactJarFile.getInputStream(jarEntry);
ctClass = classPool.makeClass(is);
} catch (IOException ioex1) {
throw new MojoExecutionException(
"Could not load class from JAR entry ["
+ artifactFile.getAbsolutePath()
+ "/" + jarEntry.getName() + "].");
} finally {
try {
if (is != null)
is.close();
} catch (IOException ignored) {
// Ignore
}
}
// ...
}
}
找出引用的类is then just:
final Collection<String> referencedClassNames = ctClass.getRefClasses();
总体而言,我对Javassist的非常相似的任务经验非常积极。我希望这会有所帮助。