Java扫描指定包中所有类

1. 扫描类

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import com.cnp.andromeda.common.util.StringUtil;

/**
 * @Author
 * @Description 包扫描器
 * @CopyRight
 */
public class ClassScanner{
    private Map<String, Class<?>> classes           = new HashMap<String, Class<?>>();
    private FilenameFilter        javaClassFilter;                                    // 类文件过滤器,只扫描一级类
    private final String          CLASS_FILE_SUFFIX = ".class";                       // Java字节码文件后缀
    private String                packPrefix;                                         // 包路径根路劲

    public ClassScanner(){
        javaClassFilter = new FilenameFilter(){
            @Override
            public boolean accept(File dir, String name){
                // 排除内部内
                return !name.contains("$");
            }
        };
    }

    /**
     * @Title: scanning
     * @Description 扫描指定包(本地)
     * @param basePath 包所在的根路径
     * @param packagePath 目标包路径
     * @return Integer 被扫描到的类的数量
     * @throws ClassNotFoundException
     */
    public Integer scanning(String basePath, String packagePath) throws ClassNotFoundException{
        packPrefix = basePath;

        String packTmp = packagePath.replace('.', '/');
        File dir = new File(basePath, packTmp);

        // 不是文件夹
        if(dir.isDirectory()){
            scan0(dir);
        }

        return classes.size();
    }

    /**
     * @Title: scanning
     * @Description 扫描指定包, Jar或本地
     * @param packagePath 包路径
     * @param recursive 是否扫描子包
     * @return Integer 类数量
     */
    public Integer scanning(String packagePath, boolean recursive){
        Enumeration<URL> dir;
        String filePackPath = packagePath.replace('.', '/');
        try{
            // 得到指定路径中所有的资源文件
            dir = Thread.currentThread().getContextClassLoader().getResources(filePackPath);
            packPrefix = Thread.currentThread().getContextClassLoader().getResource("").getPath();
            if(System.getProperty("file.separator").equals("\")){
                packPrefix = packPrefix.substring(1);
            }

            // 遍历资源文件
            while(dir.hasMoreElements()){
                URL url = dir.nextElement();
                String protocol = url.getProtocol();

                if("file".equals(protocol)){
                    File file = new File(url.getPath().substring(1));
                    scan0(file);
                } else if("jar".equals(protocol)){
                    scanJ(url, recursive);
                }
            }
        }
        catch(Exception e){
            throw new RuntimeException(e);
        }

        return classes.size();
    }

    /**
     * @Title: scanJ
     * @Description 扫描Jar包下所有class
     * @param url jar-url路径
     * @param recursive 是否递归遍历子包
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private void scanJ(URL url, boolean recursive) throws IOException, ClassNotFoundException{
        JarURLConnection jarURLConnection = (JarURLConnection)url.openConnection();
        JarFile jarFile = jarURLConnection.getJarFile();

        // 遍历Jar包
        Enumeration<JarEntry> entries = jarFile.entries();
        while(entries.hasMoreElements()){
            JarEntry jarEntry = (JarEntry)entries.nextElement();
            String fileName = jarEntry.getName();

            if (jarEntry.isDirectory()) {
                if (recursive) {
                }
                continue;
            }

            // .class
            if(fileName.endsWith(CLASS_FILE_SUFFIX)){
                String className = fileName.substring(0, fileName.indexOf('.')).replace('/', '.');
                classes.put(className, Class.forName(className));
            }

        }
    }

    /**
     * @Title: scan0
     * @Description 执行扫描
     * @param dir Java包文件夹
     * @throws ClassNotFoundException
     */
    private void scan0(File dir) throws ClassNotFoundException{
        File[] fs = dir.listFiles(javaClassFilter);
        for(int i = 0; fs != null && i < fs.length; i++){
            File f = fs[i];
            String path = f.getAbsolutePath();

            // 跳过其他文件
            if(path.endsWith(CLASS_FILE_SUFFIX)){
                String className = StringUtil.getPackageByPath(f, packPrefix); // 获取包名
                classes.put(className, Class.forName(className));
            }
        }
    }

    /**
     * @Title: getClasses
     * @Description 获取包中所有类
     * @return Map&lt;String,Class&lt;?&gt;&gt; K:类全名, V:Class字节码
     */
    public Map<String, Class<?>> getClasses(){
        return classes;
    }

    public static void main(String[] args) throws ClassNotFoundException{
        ClassScanner cs = new ClassScanner();
        int c = cs.scanning("W:/IWiFI/Code/trunk/operation/target/classes/", "com/cnp/andromeda/common/util/");
        System.out.println(c);
        System.out.println(cs.getClasses().keySet());

        ClassScanner cs2 = new ClassScanner();
        int c2 = cs2.scanning("com.cnp.swarm", false);
        System.out.println(c2);
        System.out.println(cs2.getClasses().keySet());
    }
}

2. 依赖工具类

import java.io.File;

/**
 * @FileName: StringUtil.java
 * @Author
 * @Description:
 * @Date 2014年11月16日 上午10:04:03
 * @CopyRight
 */

/**
 * 字符串工具类
 */
public final class StringUtil {

    /**
     * @Title: getMethodName
     * @Description: 获取对象类型属性的get方法名
     * @param propertyName
     *            属性名
     * @return String "get"开头且参数(propertyName)值首字母大写的字符串
     */
    public static String convertToReflectGetMethod(String propertyName) {
        return "get" + toFirstUpChar(propertyName);
    }

    /**
     * @Title: convertToReflectSetMethod
     * @Description: 获取对象类型属性的set方法名
     * @param propertyName
     *            属性名
     * @return String "set"开头且参数(propertyName)值首字母大写的字符串
     */
    public static String convertToReflectSetMethod(String propertyName) {
        return "set" + toFirstUpChar(propertyName);
    }

    /**
     * @Title: toFirstUpChar
     * @Description: 将字符串的首字母大写
     * @param target
     *            目标字符串
     * @return String 首字母大写的字符串
     */
    public static String toFirstUpChar(String target) {
        StringBuilder sb = new StringBuilder(target);
        sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
        return sb.toString();
    }

    /**
     * @Title: getFileSuffixName
     * @Description: 获取文件名后缀
     * @param fileName
     *            文件名
     * @return String 文件名后缀。如：jpg
     */
    public static String getFileSuffixName(String fileName) {
        return fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
    }

    /**
     *
     * @Title: checkStringIsNotEmpty
     * @Description:验证字符串是否不为空
     * @param stringValue
     *            传入要验证的字符串
     * @return boolean true：不为 空 或 不为null; false:值为 空 或 为null
     */
    public static boolean isNotEmpty(String stringValue) {
        if (null == stringValue || "".equals(stringValue.trim())) {
            return false;
        }
        return true;
    }

    /**
     * @Title: getPackageByPath
     * @Description 通过指定文件获取类全名
     * @param classFile 类文件
     * @return String 类全名
     */
    public static String getPackageByPath(File classFile, String exclude){
        if(classFile == null || classFile.isDirectory()){
            return null;
        }

        String path = classFile.getAbsolutePath().replace('\', '/');

        path = path.substring(path.indexOf(exclude) + exclude.length()).replace('/', '.');
        if(path.startsWith(".")){
            path = path.substring(1);
        }
        if(path.endsWith(".")){
            path = path.substring(0, path.length() - 1);
        }

        return path.substring(0, path.lastIndexOf('.'));
    }
}