Java遍历包中所有类⽅法注解⼀.代码实例
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.lang.annotation.Annotation;
import flect.Method;
import java.JarURLConnection;
import java.URL;
import java.URLDecoder;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class ClassUtil {
public static void main(String[] args) {
// 包下⾯的类
Set<Class<?>> clazzs = getClasses("st");
if (clazzs == null) {
return;
}
System.out.printf(clazzs.size() + "");
// 某类或者接⼝的⼦类
Set<Class<?>> inInterface = getByInterface(Object.class, clazzs);
System.out.printf(inInterface.size() + "");
for (Class<?> clazz : clazzs) {
// 获取类上的注解
Annotation[] annos = Annotations();
for (Annotation anno : annos) {
System.out.SimpleName().concat(".").concat(anno.annotationType().getSimpleName()));
}
// 获取⽅法上的注解
Method[] methods = DeclaredMethods();
for (Method method : methods) {
Annotation[] annotations = DeclaredAnnotations();
for (Annotation annotation : annotations) {
System.out.SimpleName().concat(".").Name()).concat(".")
.concat(annotation.annotationType().getSimpleName()));
}
}
}
}
/**
* 从包package中获取所有的Class
*
* @param pack
* @return
*/
public static Set<Class<?>> getClasses(String pack) {
// 第⼀个class类的集合
Set<Class<?>> classes = new LinkedHashSet<>();
// 是否循环迭代
boolean recursive = true;
// 获取包的名字并进⾏替换
String packageName = pack;
String packageDirName = place('.', '/');
// 定义⼀个枚举的集合并进⾏循环来处理这个⽬录下的things
Enumeration<URL> dirs;
try {
dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
// 循环迭代下去
while (dirs.hasMoreElements()) {
// 获取下⼀个元素
java replace方法URL url = Element();
// 得到协议的名称
String protocol = Protocol();
// 如果是以⽂件的形式保存在服务器上
if ("file".equals(protocol)) {
// 获取包的物理路径
String filePath = URLDecoder.File(), "UTF-8");
// 以⽂件的⽅式扫描整个包下的⽂件并添加到集合中
findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
} else if ("jar".equals(protocol)) {
// 如果是jar包⽂件
// 定义⼀个JarFile
/
/ println("jar类型的扫描");
JarFile jar;
try {
// 获取jar
jar = ((JarURLConnection) url.openConnection()).getJarFile();
// 从此jar包得到⼀个枚举类
Enumeration<JarEntry> entries = ies();
// 同样的进⾏循环迭代
while (entries.hasMoreElements()) {
// 获取jar⾥的⼀个实体可以是⽬录和⼀些jar包⾥的其他⽂件如META-INF等⽂件
JarEntry entry = Element();
String name = Name();
// 如果是以/开头的
if (name.charAt(0) == '/') {
// 获取后⾯的字符串
name = name.substring(1);
}
// 如果前半部分和定义的包名相同
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
// 如果以"/"结尾是⼀个包
if (idx != -1) {
/
/ 获取包名把"/"替换成"."
packageName = name.substring(0, idx).replace('/', '.');
}
// 如果可以迭代下去并且是⼀个包
if ((idx != -1) || recursive) {
// 如果是⼀个.class⽂件⽽且不是⽬录
if (dsWith(".class") && !entry.isDirectory()) {
// 去掉后⾯的".class" 获取真正的类名
String className = name.substring(packageName.length() + 1, name.length() - 6);
try {
// 添加到classes
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
// ("在扫描⽤户定义视图时从jar包获取⽂件出错");
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
/**
* 以⽂件的形式来获取包下的所有Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,            Set<Class<?>> classes) {
// 获取此包的⽬录建⽴⼀个File
File dir = new File(packagePath);
// 如果不存在或者也不是⽬录就直接返回
if (!ists() || !dir.isDirectory()) {
// log.warn("⽤户定义包名 " + packageName + " 下没有任何⽂件");
return;
}
// 如果存在就获取包下的所有⽂件包括⽬录
File[] dirfiles = dir.listFiles(new FileFilter() {
// ⾃定义过滤规则如果可以循环(包含⼦⽬录) 或则是以.class结尾的⽂件(编译好的java类⽂件)
public boolean accept(File file) {
return (recursive && file.isDirectory()) || (Name().endsWith(".class"));
}
});
// 循环所有⽂件
for (File file : dirfiles) {
/
/ 如果是⽬录则继续扫描
if (file.isDirectory()) {
findAndAddClassesInPackageByFile(packageName + "." + Name(), AbsolutePath(), recursive,                        classes);
} else {
// 如果是java类⽂件去掉后⾯的.class 只留下类名
String className = Name().substring(0, Name().length() - 6);
try {
// 添加到集合中去
// classes.add(Class.forName(packageName + '.' + className));
// 经过回复同学的提醒，这⾥⽤forName有⼀些不好，会触发static⽅法，没有使⽤classLoader的load⼲净                    classes.add(
Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
} catch (ClassNotFoundException e) {
// ("添加⽤户⾃定义视图类错误不到此类的.class⽂件");
e.printStackTrace();
}
}
}
}
// --------------------------------------------------------------------------------------------------------
@SuppressWarnings({ "rawtypes", "unchecked" })
public static Set<Class<?>> getByInterface(Class clazz, Set<Class<?>> classesAll) {
Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
// 获取指定接⼝的实现类
if (!clazz.isInterface()) {
try {
/**
* 循环判断路径下的所有类是否继承了指定类并且排除⽗类⾃⼰
*/
Iterator<Class<?>> iterator = classesAll.iterator();
while (iterator.hasNext()) {
Class<?> cls = ();
/**
* isAssignableFrom该⽅法的解析，请参考博客：
* blog.csdn/u010156024/article/details/44875195
*/
if (clazz.isAssignableFrom(cls)) {
if (!clazz.equals(cls)) {// ⾃⾝并不加进去
classes.add(cls);
} else {
}
}
}
} catch (Exception e) {
System.out.println("出现异常");
}
}
return classes;
}
}
代码来源于⽹络

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。