All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.enodeframework.common.extensions.ClassPathScanHandler Maven / Gradle / Ivy
package org.enodeframework.common.extensions;
import org.reflections.Reflections;
import org.reflections.util.ConfigurationBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nonnull;
import java.io.File;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.regex.Pattern;
/**
* @author [email protected]
*/
public class ClassPathScanHandler {
private static final Logger LOGGER = LoggerFactory.getLogger(ClassPathScanHandler.class);
/**
* class file extension name.
*/
private static final String CLASS_EXTENSION_NAME = ".class";
/**
* 是否排除内部类 true->是 false->否.
*/
private boolean excludeInner = true;
/**
* 过滤规则适用情况 true—>搜索符合规则的 false->排除符合规则的.
*/
private boolean checkInOrEx = true;
/**
* 过滤规则列表 如果是null或者空，即全部符合不过滤.
*/
private List classFilters = null;
/**
* the reflections.
*/
private Reflections reflections = null;
/**
* the classes and the scanPackages to be scanned.
*
* @param scanPackages scanPackages.
*/
public ClassPathScanHandler(String... scanPackages) {
this.reflections = new Reflections(new ConfigurationBuilder().forPackages(scanPackages));
}
/**
* excludeInner: 是否排除内部类 true 是 false 否
* checkInOrEx: 过滤规则适用情况 true: 搜索符合规则的 false: 排除符合规则的
* classFilters: 自定义过滤规则，如果是null或者空，即全部符合不过滤
*
* @param excludeInner whether exclude the inner class.
* @param checkInOrEx whether exclude the rule checking.
* @param classFilters the customized the classes to be filtered.
*/
public ClassPathScanHandler(Boolean excludeInner, Boolean checkInOrEx, List classFilters) {
this.excludeInner = excludeInner;
this.checkInOrEx = checkInOrEx;
this.classFilters = classFilters;
}
/**
* get all the classes with annotation.
*
* @param annotation the specific annotation.
* @param honorInherited honorInherited
* @return the set of the classes.
*/
public Set> getAllClassesWithAnnotation(Class annotation, boolean honorInherited) {
return reflections.getTypesAnnotatedWith(annotation, honorInherited);
}
/**
* get all the sub classes with the specific parent class.
*
* @param parent the parent class.
* sub class's type.
* @return the set of the sub classes found.
*/
public Set> getAllSubClassesByParent(Class parent) {
return reflections.getSubTypesOf(parent);
}
/**
* scan the package.
*
* @param basePackage the basic class package's string.
* @param recursive whether to search recursive.
* @return Set of the found classes.
*/
public Set> getPackageAllClasses(String basePackage, boolean recursive) {
if (basePackage == null) {
return new HashSet<>();
}
Set> classes = new LinkedHashSet>();
String packageName = basePackage;
if (packageName.endsWith(".")) {
packageName = packageName.substring(0, packageName.lastIndexOf('.'));
}
String package2Path = packageName.replace('.', '/');
try {
Enumeration dirs = Thread.currentThread().getContextClassLoader().getResources(package2Path);
while (dirs.hasMoreElements()) {
URL url = dirs.nextElement();
String protocol = url.getProtocol();
if ("file".equals(protocol)) {
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
doScanPackageClassesByFile(classes, packageName, filePath, recursive);
} else if ("jar".equals(protocol)) {
doScanPackageClassesByJar(packageName, url, recursive, classes);
}
}
} catch (IOException e) {
LOGGER.error("ignore this IOException", e);
}
TreeSet> sortedClasses = new TreeSet<>(new ClassNameComparator());
sortedClasses.addAll(classes);
return sortedClasses;
}
/**
* 以jar的方式扫描包下的所有Class文件> classes) {
String package2Path = basePackage.replace('.', '/');
JarFile jar;
try {
jar = ((JarURLConnection) url.openConnection()).getJarFile();
Enumeration entries = jar.entries();
while (entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
String name = entry.getName();
if (!name.startsWith(package2Path) || entry.isDirectory()) {
continue;
}
// 判断是否递归搜索子包
if (!recursive && name.lastIndexOf('/') != package2Path.length()) {
continue;
}
// 判断是否过滤 inner class
if (this.excludeInner && name.indexOf('$') != -1) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("exclude inner class with name: {}", name);
}
continue;
}
String classSimpleName = name.substring(name.lastIndexOf('/') + 1);
// 判定是否符合过滤条件
if (this.filterClassName(classSimpleName)) {
String className = name.replace('/', '.');
className = className.substring(0, className.length() - 6);
try {
classes.add(Thread.currentThread().getContextClassLoader().loadClass(className));
} catch (ClassNotFoundException e) {
LOGGER.error("Class.forName error:URL is {}", url.getPath());
}
}
}
} catch (IOException e) {
LOGGER.error("IOException error:URL is {}", url.getPath());
} catch (Throwable e) {
LOGGER.error("ScanPackageClassesByJar error:URL is {}", url.getPath());
}
}
/**
* 以文件的方式扫描包下的所有Class文件.
*
* @param packageName the package name for scanning.
* @param packagePath the package path for scanning.
* @param recursive whether to search recursive.
* @param classes set of the found classes.
*/
private void doScanPackageClassesByFile(
Set> classes, String packageName, String packagePath, final boolean recursive) {
File dir = new File(packagePath);
if (!dir.exists() || !dir.isDirectory()) {
return;
}
File[] files = dir.listFiles(pathname -> filterClassFileByCustomization(pathname, recursive));
if (null == files) {
return;
}
for (File file : files) {
if (file.isDirectory()) {
doScanPackageClassesByFile(classes, packageName + "." + file.getName(), file.getAbsolutePath(), recursive);
} else {
String className = file.getName().substring(0,
file.getName().length() - CLASS_EXTENSION_NAME.length());
try {
classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
} catch (ClassNotFoundException e) {
LOGGER.error("IOException error:");
}
}
}
}
/**
* filter the class file from the customized rules.
*
* @param file the class file to be filtered.
* @param recursive whether search recursive.
* @return true: match, false: not match.
*/
private boolean filterClassFileByCustomization(@Nonnull File file, boolean recursive) {
if (file.isDirectory()) {
return recursive;
}
String filename = file.getName();
if (excludeInner && filename.indexOf('$') != -1) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("exclude inner class with name:{}", filename);
}
return false;
}
return filterClassName(filename);
}
/**
* 根据过滤规则判断类名.
*
* @param className the class name.
* @return whether to be filtered.
*/
private boolean filterClassName(String className) {
if (!className.endsWith(CLASS_EXTENSION_NAME)) {
return false;
}
if (null == this.classFilters || this.classFilters.isEmpty()) {
return true;
}
String tmpName = className.substring(0, className.length() - 6);
boolean flag = false;
for (String str : classFilters) {
flag = matchInnerClassname(tmpName, str);
if (flag) {
break;
}
}
return (checkInOrEx && flag) || (!checkInOrEx && !flag);
}
/**
* check the className whether match the inner class's rule.
*
* @param className the inner class name.
* @param filterString the filter string.
* @return true or false.
*/
private boolean matchInnerClassname(String className, String filterString) {
String reg = "^" + filterString.replace("*", ".*") + "$";
Pattern p = Pattern.compile(reg);
return p.matcher(className).find();
}
}
