Encontre de onde a classe java é carregada

Alguém sabe como descobrir programaticamente de onde o java classloader realmente carrega a classe?

Costumo trabalhar em grandes projetos em que o caminho da classe fica muito longo e a pesquisa manual não é realmente uma opção. Recentemente, tive um problema em que o carregador de classes estava carregando uma versão incorreta de uma classe porque estava no caminho de classe em dois locais diferentes.

Então, como posso fazer com que o carregador de classes me diga de onde vem o arquivo de classe real?

Edit: E se o carregador de classes realmente não carregar a classe devido a uma incompatibilidade de versão (ou outra coisa), existe alguma maneira de descobrir qual arquivo está tentando ler antes de lê-lo?

Aqui está um exemplo:

package foo;

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

Este impresso:

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

Outra maneira de descobrir de onde uma classe é carregada (sem manipular a fonte) é iniciar a Java VM com a opção: -verbose:class

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

Isto é o que usamos:

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

Isso funcionará dependendo da implementação do ClassLoader: getClass().getProtectionDomain().getCodeSource().getLocation()

A versão de Jon falha quando o objeto ClassLoaderé registrado, o nullque parece implicar que ele foi carregado pela inicialização ClassLoader.

Este método lida com esse 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";
}

Edite apenas a 1ª linha: Main.class

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

System.out.println(path);

Resultado:

/C:/Users/Test/bin/

Talvez estilo ruim, mas funciona bem!

Normalmente, não fazemos o que usar codificação. Podemos obter className primeiro e, em seguida, usar ClassLoader para obter o URL da classe.

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

Dê uma olhada nesta pergunta semelhante. Ferramenta para descobrir a mesma classe.

Eu acho que o obstáculo mais relevante é se você tiver um carregador de classe personalizado (carregando de um db ou ldap)

Maneira simples:

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

Exemplo de saída:

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

Ou

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

Exemplo de saída:

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

Essa abordagem funciona para arquivos e jars:

Class clazz = Class.forName(nameOfClassYouWant);

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

Supondo que você esteja trabalhando com uma classe chamada MyClass, o seguinte deve funcionar:

MyClass.class.getClassLoader();

A obtenção ou não da localização em disco do arquivo .class depende do próprio carregador de classes. Por exemplo, se você estiver usando algo como o BCEL, uma determinada classe pode nem ter uma representação no disco.