扫描指定包（包括jar）下的class文件-白红宇

扫描指定包（包括jar）下的class文件

阅读量：6857 次

发布时间：2019-06-26

本文共 7720 字，大约阅读时间需要 25 分钟。

package com.newcosoft.util;import java.io.File;import java.io.FileFilter;import java.io.IOException;import java.net.JarURLConnection;import java.net.MalformedURLException;import java.net.URL;import java.net.URLDecoder;import java.util.ArrayList;import java.util.Enumeration;import java.util.LinkedHashSet;import java.util.List;import java.util.Set;import java.util.jar.JarEntry;import java.util.jar.JarFile;import java.util.regex.Pattern;import org.apache.log4j.Logger;/** * 扫描指定包（包括jar）下的class文件 
 * @author wangjie * */public class ClassPathScanHandler {    /**     * logger     */    private static final Logger logger = Logger            .getLogger(ClassPathScanHandler.class);    /**     * 是否排除内部类 true->是 false->否     */    private boolean excludeInner = true;    /**     * 过滤规则适用情况 true—>搜索符合规则的 false->排除符合规则的     */    private boolean checkInOrEx = true;    /**     * 过滤规则列表 如果是null或者空，即全部符合不过滤     */    private List
    
      classFilters = null;    public static final String JBOSS6_VFS = "vfs";       public static final String JBOSS5_VFSZIP = "vfszip";       public static final String JBOSS5_VFSMEMORY = "vfsmemory";       public FileUrlHandler fileUrlHandler;    /**     * 无参构造器，默认是排除内部类、并搜索符合规则     */    public ClassPathScanHandler() {    }    /**     * excludeInner:是否排除内部类 true->是 false->否
     
     * checkInOrEx：过滤规则适用情况 true—>搜索符合规则的 false->排除符合规则的
     
     * classFilters：自定义过滤规则，如果是null或者空，即全部符合不过滤     * @param excludeInner     * @param checkInOrEx     * @param classFilters     */    public ClassPathScanHandler(Boolean excludeInner, Boolean checkInOrEx,            List
     
       classFilters) {        this.excludeInner = excludeInner;        this.checkInOrEx = checkInOrEx;        this.classFilters = classFilters;    }    public FileUrlHandler getFileUrlHandler() {		return fileUrlHandler;	}	public void setFileUrlHandler(FileUrlHandler fileUrlHandler) {		this.fileUrlHandler = fileUrlHandler;	}    /**     * 扫描包     * @param basePackage 基础包     * @param recursive 是否递归搜索子包     * @return Set     */    public Set
      
       > getPackageAllClasses(String basePackage,            boolean recursive) {        Set
       
        > classes = new LinkedHashSet
        
         >();        String packageName = basePackage;        if (packageName.endsWith(".")) {            packageName = packageName                    .substring(0, packageName.lastIndexOf('.'));        }        String package2Path = packageName.replace('.', '/');        Enumeration
         
           dirs; try { dirs = Thread.currentThread().getContextClassLoader().getResources( package2Path); while (dirs.hasMoreElements()) { URL url = dirs.nextElement(); if(fileUrlHandler != null){ url = fileUrlHandler.replaceVfsFileUrl(url); } String protocol = url.getProtocol(); if ("file".equals(protocol)) { logger.info("扫描file类型的class文件...."); String filePath = URLDecoder.decode(url.getFile(), "UTF-8"); doScanPackageClassesByFile(classes, packageName, filePath, recursive); } else if ("jar".equals(protocol)) { logger.info("扫描jar文件中的类...."); doScanPackageClassesByJar(packageName, url, recursive, classes); } } } catch (IOException e) { logger.error("IOException error:", e); } return classes; } /** * 以jar的方式扫描包下的所有Class文件
          
 * @param basePackage eg：michael.utils. * @param url * @param recursive * @param classes */ private void doScanPackageClassesByJar(String basePackage, URL url, final boolean recursive, Set
          
           > classes) { String packageName = basePackage; String package2Path = packageName.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) { logger.info("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:", e); } } } } catch (IOException e) { logger.error("IOException error:", e); } } /** * 以文件的方式扫描包下的所有Class文件 * * @param packageName * @param packagePath * @param recursive * @param classes */ private void doScanPackageClassesByFile(Set
            
             > classes, String packageName, String packagePath, boolean recursive) { File dir = new File(packagePath); if (!dir.exists() || !dir.isDirectory()) { return; } final boolean fileRecursive = recursive; File[] dirfiles = dir.listFiles(new FileFilter() { // 自定义文件过滤规则 public boolean accept(File file) { if (file.isDirectory()) { return fileRecursive; } String filename = file.getName(); if (excludeInner && filename.indexOf('$') != -1) { logger.info("exclude inner class with name:" + filename); return false; } return filterClassName(filename); } }); for (File file : dirfiles) { if (file.isDirectory()) { doScanPackageClassesByFile(classes, packageName + "." + file.getName(), file.getAbsolutePath(), recursive); } else { String className = file.getName().substring(0, file.getName().length() - 6); try { classes.add(Thread.currentThread().getContextClassLoader() .loadClass(packageName + '.' + className)); } catch (ClassNotFoundException e) { logger.error("IOException error:", e); } } } } /** * 根据过滤规则判断类名 * @param className * @return */ private boolean filterClassName(String className) { if (!className.endsWith(".class")) { 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) { String tmpreg = "^" + str.replace("*", ".*") + "$"; Pattern p = Pattern.compile(tmpreg); if (p.matcher(tmpName).find()) { flag = true; break; } } return (checkInOrEx && flag) || (!checkInOrEx && !flag); } /** * @return the excludeInner */ public boolean isExcludeInner() { return excludeInner; } /** * @return the checkInOrEx */ public boolean isCheckInOrEx() { return checkInOrEx; } /** * @return the classFilters */ public List
             
               getClassFilters() { return classFilters; } /** * @param pExcludeInner the excludeInner to set */ public void setExcludeInner(boolean pExcludeInner) { excludeInner = pExcludeInner; } /** * @param pCheckInOrEx the checkInOrEx to set */ public void setCheckInOrEx(boolean pCheckInOrEx) { checkInOrEx = pCheckInOrEx; } /** * @param pClassFilters the classFilters to set */ public void setClassFilters(List
              
                pClassFilters) { classFilters = pClassFilters; } /** * @param args */ public static void main(String[] args) { // 自定义过滤规则 List
               
                 classFilters = new ArrayList
                
                 (); classFilters.add("File*"); // 创建一个扫描处理器，排除内部类 扫描符合条件的类 ClassPathScanHandler handler = new ClassPathScanHandler(true, true, classFilters); System.out .println("开始递归扫描jar文件的包：org.apache.commons.io 下符合自定义过滤规则的类..."); Set
                 
                  > calssList = handler.getPackageAllClasses( "com.newcosoft.ilsmp.gos.dataprocess.check.endissue", true); for (Class
                   cla : calssList) { System.out.println(cla.getName()); } System.out.println("开始递归扫描file文件的包：michael.hessian 下符合自定义过滤规则的类..."); classFilters.clear(); classFilters.add("Hessian*"); calssList = handler.getPackageAllClasses("michael.hessian", true); for (Class
                   cla : calssList) { System.out.println(cla.getName()); } }}