Trova da dove viene caricata la classe java

Qualcuno sa come scoprire a livello di programmazione da dove il classloader java carica effettivamente la classe?

Lavoro spesso su grandi progetti in cui il percorso di classe diventa molto lungo e la ricerca manuale non è davvero un'opzione. Di recente ho avuto un problema in cui il classloader stava caricando una versione errata di una classe perché si trovava sul percorso di classe in due luoghi diversi.

Quindi, come posso ottenere il classloader per dirmi da dove proviene il file di classe reale?

Modifica: Che dire se il classloader non riesce a caricare la classe a causa di una mancata corrispondenza della versione (o qualcos'altro), c'è comunque modo di scoprire quale file sta cercando di leggere prima di leggerlo?

Ecco un esempio:

package foo;

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

Questo stampato:

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

Un altro modo per scoprire da dove viene caricata una classe (senza manipolare l'origine) è avviare la VM Java con l'opzione: -verbose:class

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

Questo è ciò che usiamo:

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

Questo funzionerà in base all'implementazione ClassLoader: getClass().getProtectionDomain().getCodeSource().getLocation()

La versione di Jon ha esito negativo quando l'oggetto ClassLoaderè registrato in quanto nullsembra implicare che sia stato caricato dal Boot ClassLoader.

Questo metodo risolve questo problema:

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";
}

Modifica solo la 1a riga: Main.class

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

System.out.println(path);

Produzione:

/C:/Users/Test/bin/

Forse cattivo stile ma funziona bene!

In genere, non utilizziamo l'hardcoding. È possibile ottenere prima className e quindi utilizzare ClassLoader per ottenere l'URL della classe.

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

Dai un'occhiata a questa domanda simile. Strumento per scoprire la stessa classe ..

Penso che l'ostacolo più rilevante sia se si dispone di un classloader personalizzato (caricamento da un db o ldap)

Modo semplice:

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

Out Esempio:

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

O

String obj = "test semplice"; System.out.println (obj.getClass () getResource (obj.getClass () getSimpleName () +).. "Class.");

Out Esempio:

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

Questo approccio funziona sia per file che per vasi:

Class clazz = Class.forName(nameOfClassYouWant);

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

Supponendo che tu stia lavorando con una classe denominata MyClass, dovrebbe funzionare quanto segue:

MyClass.class.getClassLoader();

La possibilità di ottenere o meno la posizione su disco del file .class dipende dal classloader stesso. Ad esempio, se stai usando qualcosa come BCEL, una certa classe potrebbe non avere nemmeno una rappresentazione su disco.