Encuentra desde dónde se carga la clase java

¿Alguien sabe cómo averiguar programáticamente de dónde carga Java Classloader realmente la clase?

A menudo trabajo en proyectos grandes donde el classpath se hace muy largo y la búsqueda manual no es realmente una opción. Recientemente tuve un problema en el que el cargador de clases estaba cargando una versión incorrecta de una clase porque estaba en el classpath en dos lugares diferentes.

Entonces, ¿cómo puedo hacer que el cargador de clases me diga de qué parte del disco proviene el archivo de clase real?

Editar: ¿Qué pasa si el cargador de clases realmente no puede cargar la clase debido a una discrepancia de versión (u otra cosa), ¿hay alguna forma de que podamos averiguar qué archivo está tratando de leer antes de leerlo?

Aquí hay un ejemplo:

package foo;

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

Esta impreso:

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

Otra forma de averiguar desde dónde se carga una clase (sin manipular la fuente) es iniciar Java VM con la opción: -verbose:class

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

Esto es lo que usamos:

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

Esto funcionará dependiendo de la implementación de ClassLoader: getClass().getProtectionDomain().getCodeSource().getLocation()

La versión de Jon falla cuando el objeto ClassLoaderse registra como lo nullque parece implicar que fue cargado por Boot ClassLoader.

Este método trata ese 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";
}

Editar solo la primera línea: Main.class

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

System.out.println(path);

Salida:

/C:/Users/Test/bin/

Tal vez mal estilo pero funciona bien!

Por lo general, no sabemos qué usar la codificación rígida. Podemos obtener className primero, y luego usar ClassLoader para obtener la URL de la clase.

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

Echa un vistazo a esta pregunta similar. Herramienta para descubrir la misma clase.

Creo que el obstáculo más relevante es si tienes un cargador de clases personalizado (cargando desde un db o ldap)

Manera simple:

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

Ejemplo de salida:

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

O

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

Ejemplo de salida:

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

Este enfoque funciona tanto para archivos como para frascos:

Class clazz = Class.forName(nameOfClassYouWant);

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

Suponiendo que está trabajando con una clase llamada MyClass, lo siguiente debería funcionar:

MyClass.class.getClassLoader();

Si puede o no obtener la ubicación en el disco del archivo .class depende del cargador de clases en sí. Por ejemplo, si está utilizando algo como BCEL, una clase determinada puede que ni siquiera tenga una representación en el disco.