Trouver où la classe java est chargée

Est-ce que quelqu'un sait comment découvrir par programmation d'où le chargeur de classe Java charge réellement la classe?

Je travaille souvent sur de gros projets où le chemin des classes devient très long et la recherche manuelle n'est pas vraiment une option. J'ai récemment eu un problème où le classloader chargeait une version incorrecte d'une classe car il était sur le chemin de classe à deux endroits différents.

Alors, comment puis-je faire en sorte que le chargeur de classe me dise d'où vient le fichier de classe réel sur le disque?

Edit: Qu'en est-il si le chargeur de classe ne parvient pas à charger la classe en raison d'une incompatibilité de version (ou autre chose), est-il possible de savoir quel fichier il essaie de lire avant de le lire?

Voici un exemple:

package foo;

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

Ceci a imprimé:

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

Une autre façon de savoir à partir de laquelle une classe est chargée (sans manipuler la source) consiste à démarrer la machine virtuelle Java avec l'option: -verbose:class

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

Voici ce que nous utilisons:

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

Cela fonctionnera en fonction de l'implémentation de ClassLoader: getClass().getProtectionDomain().getCodeSource().getLocation()

La version de Jon échoue lorsque l'objet ClassLoaderest enregistré comme nullce qui semble impliquer qu'il a été chargé par Boot ClassLoader.

Cette méthode traite ce problème:

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

Modifier seulement la 1ère ligne: Main.class

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

System.out.println(path);

Production:

/C:/Users/Test/bin/

Peut-être mauvais style mais fonctionne bien!

En règle générale, nous ne savons pas quoi utiliser le codage en dur. Nous pouvons d'abord obtenir className, puis utiliser ClassLoader pour obtenir l'URL de la classe.

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

Jetez un œil à cette question similaire. Outil pour découvrir la même classe.

Je pense que l'obstacle le plus pertinent est si vous avez un classloader personnalisé (chargement depuis une base de données ou un ldap)

Manière simple:

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

Exemple de sortie:

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

Ou

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

Exemple de sortie:

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

Cette approche fonctionne pour les fichiers et les fichiers JAR:

Class clazz = Class.forName(nameOfClassYouWant);

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

En supposant que vous travaillez avec une classe nommée MyClass, ce qui suit devrait fonctionner:

MyClass.class.getClassLoader();

Le fait que vous puissiez ou non obtenir l'emplacement sur le disque du fichier .class dépend du chargeur de classe lui-même. Par exemple, si vous utilisez quelque chose comme BCEL, une certaine classe peut même ne pas avoir de représentation sur disque.