个人中心
gpt4 book ai didi

java 如何扫描指定包下类(包括jar中的java类)

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章java 如何扫描指定包下类(包括jar中的java类)由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

在很多的实际场景中，我们需要得到某个包名下面所有的类， 。

包括我们自己在src里写的java类和一些第三方提供的jar包里的类，那么怎么来实现呢?

今天带大家来完成这件事.

src下面的类如何获取：

首先，比较简单的是得到我们自己写的类，我们先来完成这个， 。

项目的结构图如下:

java 如何扫描指定包下类(包括jar中的java类)

我故意创建了这么个比较复杂的项目结构，现在我们就来获取com.baibin包下所有的类，并且打印他们，代码如下:

?
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
import org.junit.Test;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class Main {
     List<String> classPaths = new ArrayList<String>();
     @Test
     public void searchClass() throws ClassNotFoundException {
         //包名
         String basePack = "com.baibin" ;
         //先把包名转换为路径,首先得到项目的classpath
         String classpath = Main. class .getResource( "/" ).getPath();
         //然后把我们的包名basPach转换为路径名
         basePack = basePack.replace( "." , File.separator);
         //然后把classpath和basePack合并
         String searchPath = classpath + basePack;
         doPath( new File(searchPath));
         //这个时候我们已经得到了指定包下所有的类的绝对路径了。我们现在利用这些绝对路径和java的反射机制得到他们的类对象
         for (String s : classPaths) {
             //把 D:\work\code\20170401\search-class\target\classes\com\baibin\search\a\A.class 这样的绝对路径转换为全类名com.baibin.search.a.A
             s = s.replace(classpath.replace( "/" , "\\" ).replaceFirst( "\\\\" , "" ), "" ).replace( "\\" , "." ).replace( ".class" , "" );
             Class cls = Class.forName(s);
             System.out.println(cls);
         }
     }
     /**
      * 该方法会得到所有的类，将类的绝对路径写入到classPaths中
      * @param file
      */
     private void doPath(File file) {
         if (file.isDirectory()) { //文件夹
             //文件夹我们就递归
             File[] files = file.listFiles();
             for (File f1 : files) {
                 doPath(f1);
             }
         } else { //标准文件
             //标准文件我们就判断是否是class文件
             if (file.getName().endsWith( ".class" )) {
                 //如果是class文件我们就放入我们的集合中。
                 classPaths.add(file.getPath());
             }
         }
     }
}

效果如下:

java 如何扫描指定包下类(包括jar中的java类)

总结：这样的src下面的都比较容易处理，也很容易想到，但是jar包下面的就没这么简单了， 。

但是还是有办法的.

jar中的类如何获取：

jar下的类我们可以通过JarURLConnection类来或者，代码如下:

?
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
import org.junit.Test;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class JarMain {
     @Test
     public void searchClass() throws IOException, ClassNotFoundException {
         String basePack = "org.junit" ;
         //通过当前线程得到类加载器从而得到URL的枚举
         Enumeration<URL> urlEnumeration = Thread.currentThread().getContextClassLoader().getResources(basePack.replace( "." , "/" ));
         while (urlEnumeration.hasMoreElements()) {
             URL url = urlEnumeration.nextElement(); //得到的结果大概是：jar:file:/C:/Users/ibm/.m2/repository/junit/junit/4.12/junit-4.12.jar!/org/junit
             String protocol = url.getProtocol(); //大概是jar
             if ( "jar" .equalsIgnoreCase(protocol)) {
                 //转换为JarURLConnection
                 JarURLConnection connection = (JarURLConnection) url.openConnection();
                 if (connection != null ) {
                     JarFile jarFile = connection.getJarFile();
                     if (jarFile != null ) {
                         //得到该jar文件下面的类实体
                         Enumeration<JarEntry> jarEntryEnumeration = jarFile.entries();
                         while (jarEntryEnumeration.hasMoreElements()) {
                             /*entry的结果大概是这样：
                                     org/
                                     org/junit/
                                     org/junit/rules/
                                     org/junit/runners/*/
                             JarEntry entry = jarEntryEnumeration.nextElement();
                             String jarEntryName = entry.getName();
                             //这里我们需要过滤不是class文件和不在basePack包名下的类
                             if (jarEntryName.contains( ".class" ) && jarEntryName.replaceAll( "/" , "." ).startsWith(basePack)) {
                                 String className = jarEntryName.substring( 0 , jarEntryName.lastIndexOf( "." )).replace( "/" , "." );
                                 Class cls = Class.forName(className);
                                 System.out.println(cls);
                             }
                         }
                     }
                 }
             }
         }
     }
}

通过这两种方式我们就可以得到指定包名下面所有的类了，这个还是挺有用的， 。

比如spring中经常用来扫描指定包注解的实现等.

补充：获取指定包名下的所有类 。

写了一个工具类，用于获取指定包名下的所有类，支持递归遍历，支持注解过滤，可从 classpath （class 文件与 jar 包）中获取.

?
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
import java.io.File;
import java.io.FileFilter;
import java.lang.annotation.Annotation;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class ClassUtil {
     // 获取指定包名下的所有类
     public static List<Class<?>> getClassList(String packageName, boolean isRecursive) {
         List<Class<?>> classList = new ArrayList<Class<?>>();
         try {
             Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(packageName.replaceAll( "\\." , "/" ));
             while (urls.hasMoreElements()) {
                 URL url = urls.nextElement();
                 if (url != null ) {
                     String protocol = url.getProtocol();
                     if (protocol.equals( "file" )) {
                         String packagePath = url.getPath();
                         addClass(classList, packagePath, packageName, isRecursive);
                     } else if (protocol.equals( "jar" )) {
                         JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
                         JarFile jarFile = jarURLConnection.getJarFile();
                         Enumeration<JarEntry> jarEntries = jarFile.entries();
                         while (jarEntries.hasMoreElements()) {
                             JarEntry jarEntry = jarEntries.nextElement();
                             String jarEntryName = jarEntry.getName();
                             if (jarEntryName.endsWith( ".class" )) {
                                 String className = jarEntryName.substring( 0 , jarEntryName.lastIndexOf( "." )).replaceAll( "/" , "." );
                                 if (isRecursive || className.substring( 0 , className.lastIndexOf( "." )).equals(packageName)) {
                                     classList.add(Class.forName(className));
                                 }
                             }
                         }
                     }
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return classList;
     }
     // 获取指定包名下的所有类（可根据注解进行过滤）
     public static List<Class<?>> getClassListByAnnotation(String packageName, Class<? extends Annotation> annotationClass) {
         List<Class<?>> classList = new ArrayList<Class<?>>();
         try {
             Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(packageName.replaceAll( "\\." , "/" ));
             while (urls.hasMoreElements()) {
                 URL url = urls.nextElement();
                 if (url != null ) {
                     String protocol = url.getProtocol();
                     if (protocol.equals( "file" )) {
                         String packagePath = url.getPath();
                         addClassByAnnotation(classList, packagePath, packageName, annotationClass);
                     } else if (protocol.equals( "jar" )) {
                         JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
                         JarFile jarFile = jarURLConnection.getJarFile();
                         Enumeration<JarEntry> jarEntries = jarFile.entries();
                         while (jarEntries.hasMoreElements()) {
                             JarEntry jarEntry = jarEntries.nextElement();
                             String jarEntryName = jarEntry.getName();
                             if (jarEntryName.endsWith( ".class" )) {
                                 String className = jarEntryName.substring( 0 , jarEntryName.lastIndexOf( "." )).replaceAll( "/" , "." );
                                 Class<?> cls = Class.forName(className);
                                 if (cls.isAnnotationPresent(annotationClass)) {
                                     classList.add(cls);
                                 }
                             }
                         }
                     }
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return classList;
     }
     private static void addClass(List<Class<?>> classList, String packagePath, String packageName, boolean isRecursive) {
         try {
             File[] files = getClassFiles(packagePath);
             if (files != null ) {
                 for (File file : files) {
                     String fileName = file.getName();
                     if (file.isFile()) {
                         String className = getClassName(packageName, fileName);
                         classList.add(Class.forName(className));
                     } else {
                         if (isRecursive) {
                             String subPackagePath = getSubPackagePath(packagePath, fileName);
                             String subPackageName = getSubPackageName(packageName, fileName);
                             addClass(classList, subPackagePath, subPackageName, isRecursive);
                         }
                     }
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
     private static File[] getClassFiles(String packagePath) {
         return new File(packagePath).listFiles( new FileFilter() {
             @Override
             public boolean accept(File file) {
                 return (file.isFile() && file.getName().endsWith( ".class" )) || file.isDirectory();
             }
         });
     }
     private static String getClassName(String packageName, String fileName) {
         String className = fileName.substring( 0 , fileName.lastIndexOf( "." ));
         if (StringUtil.isNotEmpty(packageName)) {
             className = packageName + "." + className;
         }
         return className;
     }
     private static String getSubPackagePath(String packagePath, String filePath) {
         String subPackagePath = filePath;
         if (StringUtil.isNotEmpty(packagePath)) {
             subPackagePath = packagePath + "/" + subPackagePath;
         }
         return subPackagePath;
     }
     private static String getSubPackageName(String packageName, String filePath) {
         String subPackageName = filePath;
         if (StringUtil.isNotEmpty(packageName)) {
             subPackageName = packageName + "." + subPackageName;
         }
         return subPackageName;
     }
     private static void addClassByAnnotation(List<Class<?>> classList, String packagePath, String packageName, Class<? extends Annotation> annotationClass) {
         try {
             File[] files = getClassFiles(packagePath);
             if (files != null ) {
                 for (File file : files) {
                     String fileName = file.getName();
                     if (file.isFile()) {
                         String className = getClassName(packageName, fileName);
                         Class<?> cls = Class.forName(className);
                         if (cls.isAnnotationPresent(annotationClass)) {
                             classList.add(cls);
                         }
                     } else {
                         String subPackagePath = getSubPackagePath(packagePath, fileName);
                         String subPackageName = getSubPackageName(packageName, fileName);
                         addClassByAnnotation(classList, subPackagePath, subPackageName, annotationClass);
                     }
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我。如有错误或未考虑完全的地方，望不吝赐教.

原文链接：https://blog.csdn.net/baibinboss/article/details/68947929 。

最后此篇关于java 如何扫描指定包下类(包括jar中的java类)的文章就讲到这里了,如果你想了解更多关于java 如何扫描指定包下类(包括jar中的java类)的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： Opencv实现傅里叶变换
文章推荐： C++设计模式之桥接模式(Bridge)
文章推荐： C++设计模式之组合模式(Composite)
文章推荐： 解决java读取EXCEL数据变成科学计数法的问题
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com