Alle Subklassen eines Typs ermitteln

dondope

Grünschnabel
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
 

Anhänge

  • typehierarchyuusy.png
    typehierarchyuusy.png
    5,4 KB · Aufrufe: 250
Zuletzt bearbeitet:
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?
 
Zuletzt bearbeitet:
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...hy.getAllSubtypes(org.eclipse.jdt.core.IType)

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.
 
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:
Java:
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
 
Zurück