Finden Sie heraus, woher die Java-Klasse geladen wird

Weiß jemand, wie man programmgesteuert herausfindet, woher der Java-Klassenladeprogramm die Klasse tatsächlich lädt?

Ich arbeite oft an großen Projekten, bei denen der Klassenpfad sehr lang wird und die manuelle Suche keine Option ist. Ich hatte kürzlich ein Problem, bei dem der Klassenladeprogramm eine falsche Version einer Klasse lud, weil sie sich an zwei verschiedenen Stellen im Klassenpfad befand.

Wie kann ich den Klassenladeprogramm dazu bringen, mir mitzuteilen, woher auf der Festplatte die eigentliche Klassendatei stammt?

Bearbeiten: Was ist, wenn der Klassenladeprogramm die Klasse aufgrund einer Versionsinkongruenz (oder etwas anderem) nicht laden kann? Können wir trotzdem herausfinden, welche Datei er zu lesen versucht, bevor er sie liest?

Hier ist ein Beispiel:

package foo;

public class Test
{
    public static void main(String[] args)
    {
        ClassLoader loader = Test.class.getClassLoader();
        System.out.println(loader.getResource("foo/Test.class"));
    }
}

Dies ausgedruckt:

file:/C:/Users/Jon/Test/foo/Test.class

Eine andere Möglichkeit, herauszufinden, woher eine Klasse geladen wird (ohne die Quelle zu manipulieren), besteht darin, die Java-VM mit der folgenden Option zu starten: -verbose:class

getClass().getProtectionDomain().getCodeSource().getLocation();

Dies ist, was wir verwenden:

public static String getClassResource(Class<?> klass) {
  return klass.getClassLoader().getResource(
     klass.getName().replace('.', '/') + ".class").toString();
}

Dies funktioniert abhängig von der ClassLoader-Implementierung: getClass().getProtectionDomain().getCodeSource().getLocation()

Jons Version schlägt fehl, wenn das Objekt ClassLoaderregistriert ist, nullwas darauf hindeutet, dass es vom Boot geladen wurde ClassLoader.

Diese Methode behandelt dieses Problem:

public static String whereFrom(Object o) {
  if ( o == null ) {
    return null;
  }
  Class<?> c = o.getClass();
  ClassLoader loader = c.getClassLoader();
  if ( loader == null ) {
    // Try the bootstrap classloader - obtained from the ultimate parent of the System Class Loader.
    loader = ClassLoader.getSystemClassLoader();
    while ( loader != null && loader.getParent() != null ) {
      loader = loader.getParent();
    }
  }
  if (loader != null) {
    String name = c.getCanonicalName();
    URL resource = loader.getResource(name.replace(".", "/") + ".class");
    if ( resource != null ) {
      return resource.toString();
    }
  }
  return "Unknown";
}

Bearbeiten Sie nur die erste Zeile: Main.class

Class<?> c = Main.class;
String path = c.getResource(c.getSimpleName() + ".class").getPath().replace(c.getSimpleName() + ".class", "");

System.out.println(path);

Ausgabe:

/C:/Users/Test/bin/

Vielleicht schlechter Stil, funktioniert aber gut!

Normalerweise verwenden wir keine Hardcodierung. Wir können zuerst className abrufen und dann ClassLoader verwenden, um die Klassen-URL abzurufen.

        String className = MyClass.class.getName().replace(".", "/")+".class";
        URL classUrl  = MyClass.class.getClassLoader().getResource(className);
        String fullPath = classUrl==null ? null : classUrl.getPath();

Schauen Sie sich diese ähnliche Frage an. Werkzeug, um die gleiche Klasse zu entdecken ..

Ich denke, das wichtigste Hindernis ist, wenn Sie einen benutzerdefinierten Klassenladeprogramm haben (Laden von einer Datenbank oder einer LDAP).

Einfacher Weg:

System.out.println (java.lang.String.class.getResource (String.class.getSimpleName () + ". Class"));

Unser Beispiel:

jar: file: / D: /Java/jdk1.8/jre/lib/rt.jar! /java/lang/String.class

Oder

String obj = "einfacher Test"; System.out.println (obj.getClass (). GetResource (obj.getClass (). GetSimpleName () + ". Class"));

Unser Beispiel:

jar: file: / D: /Java/jdk1.8/jre/lib/rt.jar! /java/lang/String.class

Dieser Ansatz funktioniert sowohl für Dateien als auch für Gläser:

Class clazz = Class.forName(nameOfClassYouWant);

URL resourceUrl = clazz.getResource("/" + clazz.getCanonicalName().replace(".", "/") + ".class");
InputStream classStream = resourceUrl.openStream(); // load the bytecode, if you wish

Angenommen, Sie arbeiten mit einer Klasse namens MyClass, sollte Folgendes funktionieren:

MyClass.class.getClassLoader();

Ob Sie den Speicherort der .class-Datei auf der Festplatte abrufen können oder nicht, hängt vom Klassenladeprogramm selbst ab. Wenn Sie beispielsweise BCEL verwenden, verfügt eine bestimmte Klasse möglicherweise nicht einmal über eine Darstellung auf der Festplatte.