Hallo *,

gibt es eine Möglichkeit (analog wie Eclipse es kann, siehe Bild), für einen Typ alle Subklassen aufzulisten?
Via Reflection kann man die Superklasse eines Typs ermitteln, nicht jedoch seine Subklassen.

Gibt es hier eine Möglichkeit etwas zu realisieren?

Meine groben Vorüberlegungen:

1.) Durchlaufe alle Klassen auf dem Klassenpfad
2.) Wenn eine Klasse von der gesuchten Superklasse erbt, füge sie zu einer Liste der Subklassen für die Superklasse hinzu

Danke für eure Hilfe!

Greetings

Hi,
der einzigste (sinnvolle/beste) Weg führt zu einer ByteCodeAnalyse, um das zu erreichen, was du machen willst.

Viele Grüße

Sporticus

Hi und Willkommen beu tutorials.de

Stichwort: Reflection
Sind im Grunde genommen nichts anderes als ein paar spezielle Klassen, mit denen man andere untersuchen kann.
Typ, welche Methoden drin sind usw...

edit: Seh ja grad, das du das schon kennst...
Aber warum soll man die Subklassen nicht ermitteln können?
Man geht alle in Frage kommenden Klassen durch und prüft

Gruß

@Sporticus: Warum so kompliziert?

Hi,

also Reflection bietet eine Methode getSuperclass(). Diese wertet einfach die "extends XYZ" Klausel der Klassendefinition aus. Wenn keine spezifische Superklasse, also keine extends Klausel vorhanden ist, wird null zurückgeliefert (implizit ist damit die einzige Superklasse halt Object).
Es gibt, soweit ich weiß, aber keine Methoden um Subklassen aufzulisten, was auch einigermaßen Sinn macht. Denn nirgendwo in einem Classfile ist ja angegeben, welche Klassen von dieser Klasse erben.
Ergo wäre der Umweg nur möglich, alle Klassen zu durchlaufen und zu schauen ob sie von deiner gesuchten Klasse erben.
Das ist aber a.) hässlich b.) kann ziemliche unperformant werden, wenn man ein großes Projekt mit vielen Klassen hat.
Ich hab versucht nachzuschauen wie Eclipse das macht, es gibt im org.eclipse.jdt.core_3.6.2.v_A76_R36x.jar von Eclipse eine Klasse namens TypeHierarchy (org.eclipse.jdt.internal.core.hierarchy.TypeHierarchy), welche die im Bild gepostete Funktionalität bereitstellt.
Source dazu hier: http://grepcode.com/file/repository.....core.IType%29

Dummerweise ist das ein internal jar, also kann man es nicht außerhalb benutzen

Also entweder reverse engineering, oder das umständliche alle-klassen-im-klassenpfad-untersuchen, oder fällt jemandem noch etwas Anders ein?

Danke schonmal für euer Feedback

Greetings

P.S.: @Sporticus:
Hast Du irgendwelche Anhaltspunkte/Links was du mit ByteCode Analyse meinst, bzw. wie man soetwas angehen kann? Danke!

Zu Reverse Engineering: Was erwartest du dir davon?
Wie du selber schon gesagt hast werden die Subklassennamen nicht zusammen mit der Superklasse gespeichert.
Du müsstest trotzdem alle Klassen durchgehen.

Am Liebsten würde ich natürlich an das Eclipse jar andocken.
Schließlich haben die ja genau das was ich brauch schonmal implementiert
Dann könnte ich vorhandenen Code verwenden, statt nochmal selbst was implementieren zu müssen.
Mal schauen, vielleicht lässt sich ja doch irgendwie rankommen.

OT : bitte füge Screenshots mit der hier im Forum verfügbaren Anhangs-Funktion deinen Posts hinzu , da bei Fremd-Hostern das Problem besteht das die Bilder nach einer gewissen Zeit gelöscht werden und man später nicht mehr darauf zugreifen kann.

Zitat von SPiKEe

OT : bitte füge Screenshots mit der hier im Forum verfügbaren Anhangs-Funktion deinen Posts hinzu , da bei Fremd-Hostern das Problem besteht das die Bilder nach einer gewissen Zeit gelöscht werden und man später nicht mehr darauf zugreifen kann.

Danke für den Hinweis, hab den Post editiert.

Hallo,

schau dir mal Reflections an:
http://code.google.com/p/reflections/

wie auch schon gesagt wurde kannst du den Classpath auch selber nach Subtypen einer Klasse scannen.
Anstatt die Klassen hier über einen ClassLoader zu laden würde ich dir empfehlen die Class-Files mit einer Bytecode Library wie BCEL oder ASM zu analysieren, dass verbaucht weniger Speicher und läuft IMHO sehr viel schneller als mit "normalem" ClassLoading + Relfection.


Gruß Tom

Hallo,

wenn man solche Analysen mit normaler Reflection durchführt muss man leider jede zu untersuchende Klasse laden. Dies führt sehr schnell zu OOME: Permgen (bei Standardeinstellungen).

Deshalb hier mal ein kleines prototypisches Beispiel mit ASM 3.3 das auch mit Standard JVM Optionen ohne Probleme durchlaufen sollte:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179

package de.tutorials.training;   import org.objectweb.asm.ClassReader;   import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.lang.management.ManagementFactory; import java.lang.management.RuntimeMXBean; import java.lang.reflect.Modifier; import java.util.*; import java.util.jar.JarEntry; import java.util.jar.JarFile;   public class ClassHierarchyAnalysis {       private final static String CLASS_FILE_EXTENSION = ".class";     private final static String JAR_FILE_EXTENSION = ".jar";       public static void main(String[] args) throws Exception {           ClassHierarchyAnalysis cha = new ClassHierarchyAnalysis();           System.out.println(cha.subTypesOf(CharSequence.class)); //Interface         System.out.println(cha.subTypesOf(AbstractList.class)); //AbstractClass           //System.out.println(cha.subTypesOf(Set.class,new File("./bin/").getAbsolutePath())); -> MySet extends LinkedHashSet<String>     }       public Set<String> subTypesOf(Class<?> type, String... classpathComponents) {         Set<String> alreadyKnownSubTypeNames = new HashSet<String>();           if (Modifier.isFinal(type.getModifiers())) {             return alreadyKnownSubTypeNames;         }           String cp = classpathComponents.length == 0 ? getFullClassPath() : makeClasspath(classpathComponents);         System.out.println("Using classpath: " + cp);           for (String classPathComponent : cp.split(File.pathSeparator)) {             searchSubTypesInClassPathComponent(type, alreadyKnownSubTypeNames, classPathComponent);         }         return alreadyKnownSubTypeNames;     }       private void searchSubTypesInClassPathComponent(Class<?> baseType,  Set<String> alreadyKnownSubTypeNames, String classPathComponent) {         File classPathComponentFile = new File(classPathComponent);           if (!classPathComponentFile.exists()) {             System.out.println("Skipping non existing classpath component: " + classPathComponent);             return;         }           if (classPathComponent.endsWith(JAR_FILE_EXTENSION)) {             System.out.println("Scanning Jar File: " + classPathComponent);             searchSubTypesInJar(baseType, alreadyKnownSubTypeNames, classPathComponentFile);         } else if (classPathComponentFile.isDirectory()) {             System.out.println("Scanning Directory: " + classPathComponent);             searchSubTypesInDirectory(baseType, alreadyKnownSubTypeNames,   classPathComponentFile);         } else {             System.out.println("Skipping unknown classpath component: " + classPathComponent);         }     }       private void searchSubTypesInDirectory(Class<?> type, Set<String> knwonSubTypeNames, File classPathDirectory) {         Deque<File> stack = new LinkedList<File>();         stack.push(classPathDirectory);         while (!stack.isEmpty()) {             File file = stack.pop();             if (file.isDirectory()) {                 for (File nestedFiles : file.listFiles()) {                     stack.push(nestedFiles);                 }             } else {                 String classFileCandidate = file.getName();                 if (classFileCandidate.endsWith(CLASS_FILE_EXTENSION)) {                     try {                         String classFile = classPathDirectory.toURI().relativize(file.toURI()).getPath();                         analyzePotentialSubType(classFile, type,knwonSubTypeNames);                     } catch (FileNotFoundException e) {                         e.printStackTrace();                     } catch (IOException e) {                         e.printStackTrace();                     }                 }             }         }     }       private void searchSubTypesInJar(Class<?> baseType, Set<String> alreadyKnownSubTypeNames, File classPathJar) {         JarFile jarFile = null;         try {             jarFile = new JarFile(classPathJar);               Enumeration<JarEntry> entries = jarFile.entries();               while (entries.hasMoreElements()) {                 JarEntry entry = entries.nextElement();                 String classFileCandidate = entry.getName();                 if (classFileCandidate.endsWith(CLASS_FILE_EXTENSION)) {                     analyzePotentialSubType(classFileCandidate, baseType,alreadyKnownSubTypeNames);                 }             }         } catch (IOException e) {             e.printStackTrace();         } finally {             if (jarFile != null) {                 try {                     jarFile.close();                 } catch (IOException e) {                     e.printStackTrace();                 }             }         }     }       private void analyzePotentialSubType(String classFilePath, Class<?> baseType, Set<String> alreadyKnownSubTypeNames) throws IOException {         boolean subtypeFound = false;         boolean stopSearch = false;         String baseTypePath = baseType.getName().replace('.', '/');         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();                 String currentClassFileCandidate = classFilePath;         do {             InputStream classInputStream = null;             try {                                 classInputStream = classLoader.getResourceAsStream(currentClassFileCandidate);                 ClassReader cr = new ClassReader(classInputStream);                   if (baseType.isInterface()) {                     subtypeFound = Arrays.asList(cr.getInterfaces()).contains(baseTypePath);                 } else {                     subtypeFound = baseTypePath.equals(cr.getSuperName());                 }                   if (subtypeFound || cr.getSuperName() == null /* we reached java.lang.Object */) {                     stopSearch = true;                 }else{                     currentClassFileCandidate = cr.getSuperName() +CLASS_FILE_EXTENSION;                 }             } catch (Throwable t) {                 System.err.printf("Could not analyze class: %s due to error: %s",toClassName(classFilePath), t.getMessage()).println();             } finally {                 if (classInputStream != null) {                     classInputStream.close();                 }             }         } while (!stopSearch);           if (subtypeFound) {             String subTypeName = toClassName(classFilePath);             alreadyKnownSubTypeNames.add(subTypeName);             System.out.printf("%s is a subtype of %s", subTypeName,  baseType.getName()).println();         }     }       private String toClassName(String classFileCandidate) {         return classFilePathToClassName(classFileCandidate).substring(0,classFileCandidate.length() - CLASS_FILE_EXTENSION.length());     }       private String classFilePathToClassName(String classFileCandidate) {         return classFileCandidate.replace('/', '.');     }       private String getFullClassPath() {         RuntimeMXBean rmx = ManagementFactory.getRuntimeMXBean();         return makeClasspath(rmx.getBootClassPath(), rmx.getClassPath());     }       private String makeClasspath(String... classpathComponents) {         String cp = "";         for (String cpc : classpathComponents) {             cp += cpc + File.pathSeparatorChar;         }         return cp;     } }

Gruß Tom