# Class-files zur Laufzeit zu Reflection-Zwecken laden



## tbar0711 (11. Feb 2010)

Hallo,

folgender Sachverhalt:
Ich bekomme immer wieder verschiedene ear-files, die wiederum ein bestimmtes jar-file enthalten, welches wiederum unter bestimmten packages verschiedene Java class-files enthält. Einige dieser class-files sind session beans.

Nun möchte ich ein Java-Programm schreiben, welches diese class-files zur Laufzeit per Classloader läd und über Reflection die Annotationen ausliest und entsprechend durch Erkennen einer @Stateful oder @Stateless -Annotation eine Session Bean identifiziert. Diese Session Bean möchte ich dann per Reflection nach weiteren Dingen durchsuchen (z.B. Annotationen von Methoden usw.).

Der Sinn dahinter ist, dass die Session Beans bestimmte Konventionen erfüllen müssen und erst, wenn alle Session Beans diese erfüllen, dürfen sie auf den JBoss deployed werden. Daher soll die Prüfung außerhalb eines Applikationsserver erfolgen.

Nun ist meine Frage:
Geht denn das überhaupt?
Wenn ja, wie kann ich die class-files als Class-Objekte zur Laufzeit laden, damit ich Reflections durchführen kann?

Ich vermute, ich muss zunächst das ear-file und danach das jar-file entpacken und dann die Ordnerstruktur nach class-files durchsuchen. Die gefundenen class-files müssen dann mit einem Classloader geladen werden.

Ich wäre euch sehr dankbar, wenn ihr mir Code-Vorschläge diesbezüglich geben könntet.

Grüße
Tom


----------



## Wildcard (11. Feb 2010)

Entpacken ist nicht nötig. Du kannst die Jar Entries durchgehen und alles was auf .class endet verwenden (eigener Classloader der mit InputStreams arbeitet).
Siehe zB hier:
http://java.sun.com/javase/6/docs/api/java/lang/ClassLoader.html#defineClass(java.lang.String,%20byte[],%20int,%20int)


----------



## tbar0711 (12. Feb 2010)

Danke, ich habe bin nun soweit, dass ich die komplette jar nach .class Dateien durchsuchen kann.
Dann hole ich mir per Class.forName(Package und Klassenname) die Klassen.

Das Problem ist nun, dass ich nicht alle Klassen bekomme. Manche Klassen importieren wohl Klassen, die ich nicht verfügbar habe, woraufhin mein Class.forName mit der Exception in thread "main" java.lang.NoClassDefFoundError abfliegt.

Gibt es nun eine Möglichkeit, dieses Problem zu umgehen? Die Imports interessieren mich an dieser Stelle nämlich nicht. Ich möchte nur per Reflection herausfinden, welche Annotations die jeweilige Klasse hat. Die eigentliche Lauffähigkeit der Klasse ist in dem Moment nicht wichtig.

Deshalb meine Frage: Gibt es eine Möglichkeit, die jeweilige Klasse doch per Class.forName ohne Fehler zu bekommen, ohne sämtliche von ihr importierten jars verfügbar zu haben?

Grüße
Tom


----------



## FArt (12. Feb 2010)

Du kannst die Klasse nur laden, wenn auch alle davon abhängigen Klassen geladen werden können. Somit müssen auch diese Ressourcen im Klassenpfad sein.


----------



## tbar0711 (12. Feb 2010)

Gibt es nicht noch eine andere Möglichkeit? Ich weiss nämlich nicht im Voraus, welche Abhängigkeiten das jeweilige von meinem Programm zu prüfende jar hat. ;(


----------



## FArt (12. Feb 2010)

> Gibt es nicht noch eine andere Möglichkeit?


Dann musst du die Klassen wohl selber aus dem JAR holen (ohne Classloader) und dich auf die Bytecode-Ebene verlagern...


----------



## Wildcard (13. Feb 2010)

tbar0711 hat gesagt.:


> Gibt es nicht noch eine andere Möglichkeit? Ich weiss nämlich nicht im Voraus, welche Abhängigkeiten das jeweilige von meinem Programm zu prüfende jar hat. ;(



Verpass diesen Jars doch ein OSGi Manifest, dann sind die Abhängigkeiten explizit gelistet.


----------



## tbar0711 (17. Feb 2010)

Hi,

ok, nun mal angenommen, ich bekomme in einer Schleife nacheinander alle jars, die ich brauche, mit deren absolutem Pfad (z.B. /home/meinName/scheduler-plugin.jar). 

Wie kann ich diese jars zur Laufzeit meinem Classpath hinzufügen? 
Dabei möchte ich nicht nur bestimmte Klassen der jeweiligen Jar, sondern alle (also jeweils das komplette jar).

Grüße
Tom


----------



## tuxedo (17. Feb 2010)

Es gibt ne Lib namens Scannotation. Der gibst du einfach die JAR URLs und kannst dann nach Annotations in den JARs suchen ohne auch nur eine davon Instantiieren zu müssen oder von allen .class Files kenntniss zu haben... Intern wird Javassist benutzt und auf ByteCode ebene gesucht...

- Alex


----------



## tbar0711 (17. Feb 2010)

Das hört sich ja super an.

Hab jetzt mal mit dem Scannotation herumgespielt. Leider bekomme ich aber immer Source not found, wenn ich der scanArchives-Methode die url übergebe. Ich weiss nur den Pfad zum jar-File als String.
Das ganze läuft auf Linux.

Die url habe ich versucht, so zu übergeben:


```
URLClassLoader classLoader = new URLClassLoader(new URL[]{SecurityMain.class.getResource("/home/meinName/jar-test/myApplication.jar")}, SecurityMain.class.getClassLoader());

		AnnotationDB adb = new AnnotationDB();
		try {
			adb.scanArchives(classLoader.getURLs());
			// Just scan Class Annotations
			adb.setScanFieldAnnotations(false);
			adb.setScanMethodAnnotations(false);
			adb.setScanParameterAnnotations(false);
			
			Map<String, Set<String>> annotationIndex = adb.getAnnotationIndex();
			
			// Classes with stateless annotation
			Set<String> entities = annotationIndex.get("javax.ejb.Stateless");

			// Classes with statful annotation
			Set<String> entities2 = annotationIndex.get("javax.ejb.Stateful");
			
			

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
```

Habt ihr eine Idee, was da falsch läuft?

Grüße
Tom


----------



## tuxedo (17. Feb 2010)

Ich hab das so gemacht:


```
/**
     * Returns a list of class-names which contain the <code>MarvinModule</code> annotation
     *
     * @param file the archive to check
     * @param myAnnotationClass the annotation to check for
     * @return a list of class-names. The list can be zero sized if no annotated class is found
     * @throws ArchiveLoadException
     */
    private static List<String> getAnnotatedClasses(File file, Class<?> myAnnotationClass) throws ArchiveLoadException {
        AnnotationDB adb = new AnnotationDB();
        List<String> annotationList = new ArrayList<String>();
        try {
            URL[] urls = new URL[]{file.toURI().toURL()};
            adb.scanArchives(urls);
            Map<String, Set<String>> annotationIndex = adb.getAnnotationIndex();
            Iterator<String> iterator = annotationIndex.keySet().iterator();
            while (iterator.hasNext()) {
                String annotationKey = iterator.next();
                Set<String> classSet = annotationIndex.get(annotationKey);
                Iterator<String> classSetIterator = classSet.iterator();
                while (classSetIterator.hasNext()) {
                    String annotatedClass = classSetIterator.next();
                    logger.debug("Annotation found: {} in {}", annotationKey, annotatedClass);
                    if (annotationKey.equals(myAnnotationClass.getClass().getName())) {
                        logger.debug("Adding class {} to modules list", annotatedClass);
                        annotationList.add(annotatedClass);
                    }
                }
            }
        } catch (IOException ex) {
            throw new ArchiveLoadException("could not load file [" + file.getAbsolutePath() + "] for inspecting annotations ...");
        }
        return annotationList;
    }
```

Vielleicht kannst du's ja in teilen weiterverwenden ....


----------



## tbar0711 (17. Feb 2010)

Hallo,

danke nochmal für die Hilfe. Ich habe nun mein Problem gelöst und konnte mit Scannotation die Annotations auslesen.

Allerdings reicht mir das leider noch nicht, da ich aufgrund einer Session Bean nicht das zugehörige Interface, sowie dessen Methoden ermitteln kann. Auch kann ich nicht die Methoden der Session Bean ermitteln. Das mit crossReferenceImplementedInterfaces() funktioniert leider nicht.

Daher würde ich das ganze doch lieber über Reflection lösen. Wie gesagt, momentan bekomme ich alle jars, die ich brauche, über eine Schleife als String (kompletter Pfad und jarname).

Wie kann ich nun diese einzelnen jars zur Laufzeit innerhalb meiner Schleife zum Classpath hinzufügen? Hierbei möchte ich mir nicht einzelne Klassen aus den jars holen, sondern jeweils die komplette jar.

Grüße
Tom


----------



## FArt (18. Feb 2010)

URLClassLoader (Java 2 Platform SE v1.4.2)

... und setzen des ContextClassLoaders...
Class Loading


----------



## tbar0711 (18. Feb 2010)

Hi,

ich hab das jetzt so ungefähr gemacht:

```
URL p2 = new URL("file:/home/Temp/firstjar.jar");
			URL p = new URL("file:/home/Temp/secondjar.jar");
			
			java.net.URLClassLoader loader = new java.net.URLClassLoader(new URL[]{p,p2}, ClassLoader.getSystemClassLoader());
		
foundClass = Class.forName(className,true,loader);
```

Danke für die Tips

Grüße
Tom


----------



## iholta (8. Sep 2010)

Hey!

So, erster post =)
Ich habe folgendes Problem: Wenn ich Files aus dem gleichen Verzeichnis lade, also mit Class.forName(..) kann ich ohne Probleme alle Annotations auslesen. LAde ich das ganze über den URLClassLoader aus einem anderen Verzeichnis, finde ich keine Annotations mehr. Wie ist das möglich?

Wäre super wenn mir jemand helfen kann


----------



## tbar0711 (8. Sep 2010)

Hi,

kannst mal deinen Code posten und das Problem etwas genauer erklären?

Grüße
Tom


----------



## iholta (8. Sep 2010)

Also, ich möchte aus meinen class files annotations wie:

@Path("/test")
public class SimpleService {...}
 oder 
public String hallo(@QueryParam("name") String name, @QueryParam("num") int i){..}
auslesen.

Wenn ich folgenden (verienfachten) code verwende:
private void scan(String filename) {
			Class clazz= Class.forName(filename);
			for (Annotation ann:clazz.getAnnotations()){
				System.out.println(ann.toString());
			}
}
gibt er mir korrekt @javax.ws.rs.Path(value=/test) aus. Da das aber nur mit klassen im selben verzeichnis funktioniert habe ich es umgeändert auf:
        File fJar = new File(path); 
		    URL url = null;
		    try
		    {
		      url = fJar.toURI().toURL();
	       	      URLClassLoader urlcl = new URLClassLoader(new URL[] {url});
                      String strPackage = file; 
        	      clazz = Class.forName(strPackage, true, urlcl);
	              }
			catch(Exception ex)
			{ex.printStackTrace();}

		for (Annotation ann:clazz.getAnnotations()){
				System.out.println(ann.toString());
			}
Jetz bekomme ich keine Annotations mehr, die klasser wird aber richtig geladen, denn ich bekomme immer noch die richtigen Methoden heraus. hoff es ist jetz verständlicher..


----------



## tbar0711 (8. Sep 2010)

Hi,

hat die Klasse, die du jetzt geladen hast, überhaupt eine Annotation? So wie Deine Klasse SimpleService die Annotation @Path("/test") hat?

Oder willst Du die Annotations auf Methodenebene auslesen? Dann müsstest Du Dir die Methoden über clazz.getDeclaredMethods() holen und diese in einen Array vom Typ java.lang.reflect.Method stecken und anschließend Dir für jede Methode mit getAnnotations() die Annotationen holen.

Kannst auch mal im Debug-Modus schauen, was dein Class-Objekt alles so mitbringt.

Grüße
Tom


----------



## iholta (8. Sep 2010)

Ja, sie hat annotations. Ich lade beim zweiten mal genau die gleiche Klasse (also SimpleService), nur aus einem anderen Verzeichnis. Habe jetzt bemerkt, wenn ich das Programm mit dem URLClassLoader auch im selben Verzeichnis ausführe funktioniert es auch.

Das mit den MEthoden ist mir klar, die muss ich später auch noch holen, hoffe aber dass das kein problem ist wenn die class- annotations mal funktionieren.

und..mir ist nich ganz klar was ich im debug-modus machen soll..?

Danke


----------

