Как мне прочитать все классы из пакета Java в classpath?
Мне нужно прочитать классы, содержащиеся в пакете Java. Эти классы находятся в classpath. Мне нужно сделать эту задачу непосредственно из Java-программы. Вы знаете простой способ сделать?
List<Class> classes = readClassesFrom("my.package")
17 ответов
Если у вас есть Spring в вашем classpath, то следующее сделает это.
Найдите все классы в пакете, аннотированные XmlRootElement:
private List<Class> findMyTypes(String basePackage) throws IOException, ClassNotFoundException
{
ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourcePatternResolver);
List<Class> candidates = new ArrayList<Class>();
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + "/" + "**/*.class";
Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
if (isCandidate(metadataReader)) {
candidates.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
}
}
}
return candidates;
}
private String resolveBasePackage(String basePackage) {
return ClassUtils.convertClassNameToResourcePath(SystemPropertyUtils.resolvePlaceholders(basePackage));
}
private boolean isCandidate(MetadataReader metadataReader) throws ClassNotFoundException
{
try {
Class c = Class.forName(metadataReader.getClassMetadata().getClassName());
if (c.getAnnotation(XmlRootElement.class) != null) {
return true;
}
}
catch(Throwable e){
}
return false;
}
Вы можете использовать проект Reflections, описанный здесь
Это довольно полный и простой в использовании.
Краткое описание с вышеуказанного сайта:
Reflections сканирует ваш путь к классам, индексирует метаданные, позволяет запрашивать их во время выполнения и может сохранять и собирать эту информацию для многих модулей в вашем проекте.
Пример:
Reflections reflections = new Reflections(
new ConfigurationBuilder()
.setUrls(ClasspathHelper.forJavaClassPath())
);
Set<Class<?>> types = reflections.getTypesAnnotatedWith(Scannable.class);
Я использую этот, он работает с файлами или архивами JAR
public static ArrayList<String>getClassNamesFromPackage(String packageName) throws IOException{
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
URL packageURL;
ArrayList<String> names = new ArrayList<String>();;
packageName = packageName.replace(".", "/");
packageURL = classLoader.getResource(packageName);
if(packageURL.getProtocol().equals("jar")){
String jarFileName;
JarFile jf ;
Enumeration<JarEntry> jarEntries;
String entryName;
// build jar file name, then loop through zipped entries
jarFileName = URLDecoder.decode(packageURL.getFile(), "UTF-8");
jarFileName = jarFileName.substring(5,jarFileName.indexOf("!"));
System.out.println(">"+jarFileName);
jf = new JarFile(jarFileName);
jarEntries = jf.entries();
while(jarEntries.hasMoreElements()){
entryName = jarEntries.nextElement().getName();
if(entryName.startsWith(packageName) && entryName.length()>packageName.length()+5){
entryName = entryName.substring(packageName.length(),entryName.lastIndexOf('.'));
names.add(entryName);
}
}
// loop through files in classpath
}else{
URI uri = new URI(packageURL.toString());
File folder = new File(uri.getPath());
// won't work with path which contains blank (%20)
// File folder = new File(packageURL.getFile());
File[] contenuti = folder.listFiles();
String entryName;
for(File actual: contenuti){
entryName = actual.getName();
entryName = entryName.substring(0, entryName.lastIndexOf('.'));
names.add(entryName);
}
}
return names;
}
Spring реализовал отличную функцию поиска по пути к классам в PathMatchingResourcePatternResolver, Если вы используете classpath* Префикс: вы можете найти все ресурсы, включая классы в данной иерархии, и даже отфильтровать их, если хотите. Тогда вы можете использовать детей AbstractTypeHierarchyTraversingFilter, AnnotationTypeFilter а также AssignableTypeFilter фильтровать эти ресурсы либо по аннотациям на уровне класса, либо по интерфейсам, которые они реализуют.
Java 1.6.0_24:
public static File[] getPackageContent(String packageName) throws IOException{
ArrayList<File> list = new ArrayList<File>();
Enumeration<URL> urls = Thread.currentThread().getContextClassLoader()
.getResources(packageName);
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
File dir = new File(url.getFile());
for (File f : dir.listFiles()) {
list.add(f);
}
}
return list.toArray(new File[]{});
}
Это решение было протестировано в среде EJB.
Вы можете попробовать мою библиотеку FastClasspathScanner. Сканирование пути к классам не так просто, как проверка java.class.path свойство и рекурсивное сканирование для классов там, потому что есть много способов, которыми можно указать путь к классам (например, вы можете добавить Class-Path записи в манифест jarfile). Использование Class.forName() фактически инициализирует класс, что может быть не тем, что вы хотите, и т. Д. FastClasspathScanner обрабатывает эти сложности для вас.
Чтобы перечислить все классы в пакете, сделайте следующее:
String packageName = "my.package";
Set<String> classNames = new FastClassPathScanner(packageName)
.scan()
.getNamesOfAllClasses();
String packageNamePrefix = packageName + ".";
for (String className : classNames) {
if (className.startsWith(packageNamePrefix) {
System.out.println("Found class: " + className);
}
}
Вам нужен чек if (className.startsWith(packageNamePrefix) потому что если класс ссылается на другой класс (например, как суперкласс), и он находится за пределами префикса пакета в белом списке my.package, он будет включен в набор, возвращенный .getNamesOfAllClasses(),
Scannotation и Reflections используют подход сканирования пути класса:
Reflections reflections = new Reflections("my.package");
Set<Class<? extends Object>> classes = reflections.getSubTypesOf(Object.class);
Другой подход заключается в использовании Java Pluggable Annotation Processing API для написания процессора аннотаций, который будет собирать все аннотированные классы во время компиляции и создавать индексный файл для использования во время выполнения. Этот механизм реализован в библиотеке ClassIndex:
Iterable<Class> classes = ClassIndex.getPackageClasses("my.package");
Насколько я знаю, эта функциональность до сих пор подозрительно отсутствует в API отражения Java. Вы можете получить объект пакета, просто выполнив это:
Package packageObj = Package.getPackage("my.package");
Но, как вы, наверное, заметили, это не позволит вам перечислить классы в этом пакете. На данный момент вы должны использовать более ориентированный на файловую систему подход.
Я нашел несколько примеров реализации в этом посте
Я не уверен на 100%, что эти методы будут работать, когда ваши классы похоронены в файлах JAR, но я надеюсь, что один из них сделает это за вас.
Я согласен с @skaffman... если у вас есть другой способ сделать это, я бы рекомендовал сделать это вместо этого.
eXtcos выглядит многообещающе. Представьте, что вы хотите найти все классы, которые:
- Вытяните из класса "Компонент" и сохраните их
- Помечены "MyComponent", и
- Находятся в "общей" упаковке.
С eXtcos это так же просто, как
ClasspathScanner scanner = new ClasspathScanner();
final Set<Class> classStore = new ArraySet<Class>();
Set<Class> classes = scanner.getClasses(new ClassQuery() {
protected void query() {
select().
from(“common”).
andStore(thoseExtending(Component.class).into(classStore)).
returning(allAnnotatedWith(MyComponent.class));
}
});
Билл Берк написал (хорошая статья о сканировании классов), а затем написал Scannotation.
Hibernate уже написал:
- org.hibernate.ejb.packaging.Scanner
- org.hibernate.ejb.packaging.NativeScanner
CDI может решить эту проблему, но не знаю - еще не полностью изучил
,
@Inject Instance< MyClass> x;
...
x.iterator()
Также для аннотаций:
abstract class MyAnnotationQualifier
extends AnnotationLiteral<Entity> implements Entity {}
Вот еще один вариант, небольшая модификация другого ответа выше / ниже:
Reflections reflections = new Reflections("com.example.project.package",
new SubTypesScanner(false));
Set<Class<? extends Object>> allClasses =
reflections.getSubTypesOf(Object.class);
Я реализовал это, и это работает в большинстве случаев. Поскольку это долго, я положил это в файл здесь.
Идея состоит в том, чтобы найти расположение исходного файла класса, который доступен в большинстве случаев (насколько я тестировал, известным исключением являются файлы классов JVM). Если код находится в каталоге, просмотрите все файлы и только файлы спот-классов. Если код находится в файле JAR, просканируйте все записи.
Этот метод можно использовать только когда:
У вас есть класс, который находится в том же пакете, который вы хотите обнаружить. Этот класс называется SeedClass. Например, если вы хотите перечислить все классы в java.io, начальный класс может быть
java.io.File,Ваши классы находятся в каталоге или в файле JAR, в котором есть информация об исходном файле (не файл исходного кода, а просто исходный файл). Насколько я пытался, он работает почти на 100%, за исключением класса JVM (эти классы поставляются с JVM).
Ваша программа должна иметь разрешение на доступ к ProtectionDomain этих классов. Если ваша программа загружена локально, проблем не должно быть.
Я тестировал программу только для своего регулярного использования, поэтому у нее все еще могут быть проблемы.
Надеюсь, это поможет.
В те времена, когда апплеты были обычным явлением, на пути к классам мог быть URL. Когда загрузчику классов требуется класс, он будет выполнять поиск во всех местах на пути к классам, включая ресурсы http. Поскольку вы можете иметь такие вещи, как URL-адреса и каталоги на пути к классам, нет простого способа получить окончательный список классов.
Тем не менее, вы можете получить довольно близко. Некоторые из библиотек Spring делают это сейчас. Вы можете получить все банки на пути к классам и открыть их, как файлы. Затем вы можете взять этот список файлов и создать структуру данных, содержащую ваши классы.
Если вы уже используете Guava, вы можете использовать ClassPath. Просмотрите документы здесь: https://google.github.io/guava/releases/17.0/api/docs/com/google/common/reflect/ClassPath.html
Использовать зависимости maven:
groupId: net.sf.extcos
artifactId: extcos
version: 0.4b
затем используйте этот код:
ComponentScanner scanner = new ComponentScanner();
Set classes = scanner.getClasses(new ComponentQuery() {
@Override
protected void query() {
select().from("com.leyton").returning(allExtending(DynamicForm.class));
}
});
Брент - причина, по которой ассоциация является одним из способов, связана с тем, что любой класс в любом компоненте вашего CLASSPATH может объявить себя в любом пакете (кроме java/javax). Таким образом, просто нет отображения ВСЕХ классов в данном "пакете", потому что никто не знает и не может знать. Вы можете обновить файл JAR завтра и удалить или добавить классы. Это все равно, что пытаться получить список всех людей по имени Джон / Джон / Йохан во всех странах мира - никто из нас не является всезнающим, поэтому никто из нас никогда не получит правильного ответа.