java工具类-获取包下的所有类

可以获取文件形式的也可以获取jar包形式的

1. package com.ergal.ezweb.utils;
3. import java.io.File;
4. import java.io.FileFilter;
5. import java.io.IOException;
6. import java.net.JarURLConnection;
7. import java.net.URL;
8. import java.net.URLDecoder;
9. import java.util.Enumeration;
10. import java.util.LinkedHashSet;
11. import java.util.Set;
12. import java.util.jar.JarEntry;
13. import java.util.jar.JarFile;
15. import org.apache.commons.logging.Log;
16. import org.apache.commons.logging.LogFactory;
18. /**
19.  * 类相关的工具类
20.  * 
21.  * @author <a href="mailto:ohergal@gmail.com">ohergal</a>
22.  * 
23.  */
24. public class ClassUtil {
25.     private static final Log log = LogFactory.getLog(ClassUtil.class);
26.     /*
27.      * 取得某一类所在包的所有类名 不含迭代
28.      */
29.     public static String[] getPackageAllClassName(String classLocation, String packageName){
30.         //将packageName分解
31.         String[] packagePathSplit = packageName.split("[.]");
32.         String realClassLocation = classLocation;
33.         int packageLength = packagePathSplit.length;
34.         for(int i = 0; i< packageLength; i++){
35.             realClassLocation = realClassLocation + File.separator+packagePathSplit[i];
36.         }
37.         File packeageDir = new File(realClassLocation);
38.         if(packeageDir.isDirectory()){
39.             String[] allClassName = packeageDir.list();
40.             return allClassName;
41.         }
42.         return null;
43.     }
44.     
45.     /**
46.      * 从包package中获取所有的Class
47.      * @param pack
48.      * @return
49.      */
50.     public static Set<Class<?>> getClasses(Package pack){
51.         
52.         //第一个class类的集合
53.         Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
54.         //是否循环迭代
55.         boolean recursive = true;
56.         //获取包的名字 并进行替换
57.         String packageName = pack.getName();
58.         String packageDirName = packageName.replace('.', '/');
59.         //定义一个枚举的集合 并进行循环来处理这个目录下的things
60.         Enumeration<URL> dirs;
61.         try {
62.             dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
63.             //循环迭代下去
64.             while (dirs.hasMoreElements()){
65.                 //获取下一个元素
66.                 URL url = dirs.nextElement();
67.                 //得到协议的名称
68.                 String protocol = url.getProtocol();
69.                 //如果是以文件的形式保存在服务器上
70.                 if ("file".equals(protocol)) {
71.                     //获取包的物理路径
72.                     String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
73.                     //以文件的方式扫描整个包下的文件 并添加到集合中
74.                     findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
75.                 } else if ("jar".equals(protocol)){
76.                     //如果是jar包文件 
77.                     //定义一个JarFile
78.                     JarFile jar;
79.                     try {
80.                         //获取jar
81.                         jar = ((JarURLConnection) url.openConnection()).getJarFile();
82.                         //从此jar包 得到一个枚举类
83.                         Enumeration<JarEntry> entries = jar.entries();
84.                         //同样的进行循环迭代
85.                         while (entries.hasMoreElements()) {
86.                             //获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
87.                             JarEntry entry = entries.nextElement();
88.                             String name = entry.getName();
89.                             //如果是以/开头的
90.                             if (name.charAt(0) == '/') {
91.                                 //获取后面的字符串
92.                                 name = name.substring(1);
93.                             }
94.                             //如果前半部分和定义的包名相同
95.                             if (name.startsWith(packageDirName)) {
96.                                 int idx = name.lastIndexOf('/');
97.                                 //如果以"/"结尾 是一个包
98.                                 if (idx != -1) {
99.                                     //获取包名 把"/"替换成"."
100.                                     packageName = name.substring(0, idx).replace('/', '.');
101.                                 }
102.                                 //如果可以迭代下去 并且是一个包
103.                                 if ((idx != -1) || recursive){
104.                                     //如果是一个.class文件 而且不是目录
105.                                     if (name.endsWith(".class") && !entry.isDirectory()) {
106.                                         //去掉后面的".class" 获取真正的类名
107.                                         String className = name.substring(packageName.length() + 1, name.length() - 6);
108.                                         try {
109.                                             //添加到classes
110.                                             classes.add(Class.forName(packageName + '.' + className));
111.                                         } catch (ClassNotFoundException e) {
112.                                             log.error("添加用户自定义视图类错误 找不到此类的.class文件");
113.                                             e.printStackTrace();
114.                                         }
115.                                       }
116.                                 }
117.                             }
118.                         }
119.                     } catch (IOException e) {
120.                         log.error("在扫描用户定义视图时从jar包获取文件出错");
121.                         e.printStackTrace();
122.                     } 
123.                 }
124.             }
125.         } catch (IOException e) {
126.             e.printStackTrace();
127.         }
128.        
129.         return classes;
130.     }
131.     
132.     /**
133.      * 以文件的形式来获取包下的所有Class
134.      * @param packageName
135.      * @param packagePath
136.      * @param recursive
137.      * @param classes
138.      */
139.     public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, Set<Class<?>> classes){
140.         //获取此包的目录 建立一个File
141.         File dir = new File(packagePath);
142.         //如果不存在或者 也不是目录就直接返回
143.         if (!dir.exists() || !dir.isDirectory()) {
144.             log.warn("用户定义包名 " + packageName + " 下没有任何文件");
145.             return;
146.         }
147.         //如果存在 就获取包下的所有文件 包括目录
148.         File[] dirfiles = dir.listFiles(new FileFilter() {
149.         //自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
150.               public boolean accept(File file) {
151.                 return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
152.               }
153.             });
154.         //循环所有文件
155.         for (File file : dirfiles) {
156.             //如果是目录 则继续扫描
157.             if (file.isDirectory()) {
158.                 findAndAddClassesInPackageByFile(packageName + "." + file.getName(),
159.                                       file.getAbsolutePath(),
160.                                       recursive,
161.                                       classes);
162.             }
163.             else {
164.                 //如果是java类文件 去掉后面的.class 只留下类名
165.                 String className = file.getName().substring(0, file.getName().length() - 6);
166.                 try {
167.                     //添加到集合中去
168.                     classes.add(Class.forName(packageName + '.' + className));
169.                 } catch (ClassNotFoundException e) {
170.                     log.error("添加用户自定义视图类错误 找不到此类的.class文件");
171.                     e.printStackTrace();
172.                 }
173.             }
174.         }
175.     }
176. }