Kann man in Java wissen, ob eine Klasse bereits geladen wurde?

(Dank Aleksi) Diesen code:

public class TestLoaded {
     public static void main(String[] args) throws Exception {
          java.lang.reflect.Method m = ClassLoader.class.getDeclaredMethod("findLoadedClass", new Class[] { String.class });
          m.setAccessible(true);
          ClassLoader cl = ClassLoader.getSystemClassLoader();
          Object test1 = m.invoke(cl, "TestLoaded$ClassToTest");
          System.out.println(test1 != null);
          ClassToTest.reportLoaded();
          Object test2 = m.invoke(cl, "TestLoaded$ClassToTest");
          System.out.println(test2 != null);
     }
     static class ClassToTest {
          static {
               System.out.println("Loading " + ClassToTest.class.getName());
          }
          static void reportLoaded() {
               System.out.println("Loaded");
          }
     }
}

Produziert:

false
Loading TestLoaded$ClassToTest
Loaded
true

Beachten Sie, dass die Beispiel-Klassen sind nicht in einem Paket. Die volle binäre Namen erforderlich ist.

Ein Beispiel für eine binäre name ist "java.security.KeyStore$Builder$FileBuilder$1"

InformationsquelleAutor der Antwort Stephen Denne

Einen Weg, dies zu tun wäre zu schreiben Sie eine Java-Agenten mithilfe der instrumentation API. Dieses würde Ihnen erlauben, zu erfassen, das laden von Klassen durch die JVM.

public class ClassLoadedAgent implements ClassFileTransformer {

    private static ClassLoadedAgent AGENT = null;

    /** Agent "main" equivalent */
    public static void premain(String agentArguments,
            Instrumentation instrumentation) {
        AGENT = new ClassLoadedAgent();
        for (Class<?> clazz : instrumentation.getAllLoadedClasses()) {
            AGENT.add(clazz);
        }
        instrumentation.addTransformer(AGENT);
    }

    private final Map<ClassLoader, Set<String>> classMap = new WeakHashMap<ClassLoader, Set<String>>();

    private void add(Class<?> clazz) {
        add(clazz.getClassLoader(), clazz.getName());
    }

    private void add(ClassLoader loader, String className) {
        synchronized (classMap) {
            System.out.println("loaded: " + className);
            Set<String> set = classMap.get(loader);
            if (set == null) {
                set = new HashSet<String>();
                classMap.put(loader, set);
            }
            set.add(className);
        }
    }

    private boolean isLoaded(String className, ClassLoader loader) {
        synchronized (classMap) {
            Set<String> set = classMap.get(loader);
            if (set == null) {
                return false;
            }
            return set.contains(className);
        }
    }

    @Override
    public byte[] transform(ClassLoader loader, String className,
            Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
            byte[] classfileBuffer) throws IllegalClassFormatException {
        add(loader, className);
        return classfileBuffer;
    }

    public static boolean isClassLoaded(String className, ClassLoader loader) {
        if (AGENT == null) {
            throw new IllegalStateException("Agent not initialized");
        }
        if (loader == null || className == null) {
            throw new IllegalArgumentException();
        }
        while (loader != null) {
            if (AGENT.isLoaded(className, loader)) {
                return true;
            }
            loader = loader.getParent();
        }
        return false;
    }

}

META-INF/MANIFEST.MF:

Manifest-Version: 1.0 
Premain-Class: myinstrument.ClassLoadedAgent

Der Nachteil ist, dass Sie zum laden der agent beim starten der JVM:

java -javaagent:myagent.jar ....etcetera

InformationsquelleAutor der Antwort McDowell

Ich hatte ein ähnliches problem vor kurzem, wo ich vermutete, dass Klassen wurden nicht geladen werden kann (vermutlich durch -classpath oder so ähnlich) von meinem Benutzer, die in Konflikt mit den Klassen war ich dem laden später in meiner eigenen classloader.

Nachdem ich ein paar der Dinge, die hier erwähnt werden, das folgende schien, den trick zu tun für mich. Ich bin mir nicht sicher, ob es funktioniert für alle Fälle, es kann nur funktionieren, für die java-Klassen geladen, die aus jar-Dateien.

InputStream is = getResourceAsStream(name);

Wo name ist der Pfad zur class-Datei wie com/blah/blah/blah/foo.class.

getResourceAsStream zurückgegeben null wenn die Klasse nicht geladen wurden, in meine Klasse loader, oder der system-class-loader, und kehrte nicht-null, wenn die Klasse bereits geladen wurde.

InformationsquelleAutor der Antwort Eric Van Bezooijen