分享java类的扫描代码

1.按照指定包扫描
2.按照指定注解类过滤

1. package com.bswan;
   
2. 
   
3. import java.io.IOException;
   
4. import java.lang.annotation.Annotation;
   
5. import java.util.HashSet;
   
6. import java.util.LinkedList;
   
7. import java.util.List;
   
8. import java.util.Set;
   
9. 
   
10. import org.apache.log4j.Logger;
    
11. import org.springframework.beans.factory.BeanDefinitionStoreException;
    
12. import org.springframework.context.ResourceLoaderAware;
    
13. import org.springframework.core.io.Resource;
    
14. import org.springframework.core.io.ResourceLoader;
    
15. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    
16. import org.springframework.core.io.support.ResourcePatternResolver;
    
17. import org.springframework.core.io.support.ResourcePatternUtils;
    
18. import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
    
19. import org.springframework.core.type.classreading.MetadataReader;
    
20. import org.springframework.core.type.classreading.MetadataReaderFactory;
    
21. import org.springframework.core.type.filter.AnnotationTypeFilter;
    
22. import org.springframework.core.type.filter.TypeFilter;
    
23. import org.springframework.util.ClassUtils;
    
24. import org.springframework.util.SystemPropertyUtils;
    
25. 
    
26. import core.plugin.table.Table;
    
27. import core.route.Controllers;
    
28. @SuppressWarnings({ "rawtypes", "unchecked" })
    
29. public class ClassScaner implements ResourceLoaderAware {
    
30.     /**
    
31.      * log
    
32.      */
    
33.     private static Logger logger = Logger.getLogger(ClassScaner.class);
    
34.      
    
35.     private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    
36. 
    
37.     private final List<TypeFilter> includeFilters = new LinkedList<TypeFilter>();
    
38. 
    
39.     private final List<TypeFilter> excludeFilters = new LinkedList<TypeFilter>();
    
40. 
    
41.     private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(
    
42.             this.resourcePatternResolver);
    
43. 
    
44.     public ClassScaner() {
    
45. 
    
46.     }
    
47. 
    
48.     public void setResourceLoader(ResourceLoader resourceLoader) {
    
49.         this.resourcePatternResolver = ResourcePatternUtils
    
50.                 .getResourcePatternResolver(resourceLoader);
    
51.         this.metadataReaderFactory = new CachingMetadataReaderFactory(
    
52.                 resourceLoader);
    
53.     }
    
54. 
    
55.     public final ResourceLoader getResourceLoader() {
    
56.         return this.resourcePatternResolver;
    
57.     }
    
58. 
    
59.     public void addIncludeFilter(TypeFilter includeFilter) {
    
60.         this.includeFilters.add(includeFilter);
    
61.     }
    
62. 
    
63.     public void addExcludeFilter(TypeFilter excludeFilter) {
    
64.         this.excludeFilters.add(0, excludeFilter);
    
65.     }
    
66. 
    
67.     public void resetFilters(boolean useDefaultFilters) {
    
68.         this.includeFilters.clear();
    
69.         this.excludeFilters.clear();
    
70.     }
    
71. 
    
72.     public static Set<Class> scan(String basePackage,Class<? extends Annotation>... annotations) {
    
73.         ClassScaner cs = new ClassScaner();
    
74.         for (Class anno : annotations){
    
75.             cs.addIncludeFilter(new AnnotationTypeFilter(anno));
    
76.         }
    
77.         return cs.doScan(basePackage);
    
78.     }
    
79. 
    
80.     public static Set<Class> scan(String[] basePackages,Class<? extends Annotation>... annotations) {
    
81.         ClassScaner cs = new ClassScaner();
    
82.         for (Class anno : annotations){
    
83.             cs.addIncludeFilter(new AnnotationTypeFilter(anno));
    
84.         }
    
85.         Set<Class> classes = new HashSet<Class>();
    
86.         for (String s : basePackages){
    
87.             classes.addAll(cs.doScan(s));
    
88.         }
    
89.         return classes;
    
90.     }
    
91. 
    
92.     public Set<Class> doScan(String basePackage) {
    
93.         Set<Class> classes = new HashSet<Class>();
    
94.         try {
    
95.             String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + ClassUtils.convertClassNameToResourcePath(SystemPropertyUtils.resolvePlaceholders(basePackage))+ "/**/*.class";
    
96.             System.out.println(packageSearchPath);
    
97.             Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
    
98.             for (int i = 0; i < resources.length; i++) {
    
99.                 Resource resource = resources[i];
    
100.                 System.out.println(resource.getFilename());
     
101.                 if (resource.isReadable()) {
     
102.                     MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
     
103.                     if ((includeFilters.size() == 0 && excludeFilters.size() == 0)|| matches(metadataReader)) {
     
104.                         try {
     
105.                             classes.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
     
106.                         } catch (ClassNotFoundException e) {
     
107.                             logger.error(e.getMessage());
     
108.                         }
     
109.                     }
     
110.                 }
     
111.             }
     
112.         } catch (IOException ex) {
     
113.             throw new BeanDefinitionStoreException(
     
114.                     "I/O failure during classpath scanning", ex);
     
115.         }
     
116.         return classes;
     
117.     }
     
118. 
     
119.     protected boolean matches(MetadataReader metadataReader) throws IOException {
     
120.         for (TypeFilter tf : this.excludeFilters) {
     
121.             if (tf.match(metadataReader, this.metadataReaderFactory)) {
     
122.                 return false;
     
123.             }
     
124.         }
     
125.         for (TypeFilter tf : this.includeFilters) {
     
126.             if (tf.match(metadataReader, this.metadataReaderFactory)) {
     
127.                 return true;
     
128.             }
     
129.         }
     
130.         return false;
     
131.     }
     
132.      
     
133.     public static void main(String[] args) {
     
134.         Set<Class> set = ClassScaner.scan("com.bswan", Table.class,Controllers.class);
     
135.         for (Class class1 : set) {
     
136.             System.out.println(class1.getName());
     
137.         }
     
138.     }
     
139. 
     
140. }扫描指定package下所有的类

141. 思路：
     有的web server在部署运行时会解压jar包，因此class文件会在普通的文件目录下。如果web server不解压jar包，则class文件会直接存在于Jar包中。对于前者，只需定位到class文件所在目录，然后将class文件名读取出即可；对于后者，则需先定位到jar包所在目录，然后使用JarInputStream读取Jar包，得到class类名。网站推广

     实现：
     这是从写好的项目代码中直接copy出来的，如果要运行这段代码，需要把所有的Logger.debug改成System.out.println()

     ?

     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 156 157 158 159 160 161 162 163 164

     <code class = " hljs java" > /**   * This scanner is used to find out all classes in a package.   * Created by whf on 15-2-26.   */ public class ClasspathPackageScanner implements PackageScanner {      private Logger logger = LoggerFactory.getLogger(ClasspathPackageScanner. class );        private String basePackage;      private ClassLoader cl;        /**       * Construct an instance and specify the base package it should scan.       * @param basePackage The base package to scan.       */      public ClasspathPackageScanner(String basePackage) {          this .basePackage = basePackage;          this .cl = getClass().getClassLoader();        }        /**       * Construct an instance with base package and class loader.       * @param basePackage The base package to scan.       * @param cl Use this class load to locate the package.       */      public ClasspathPackageScanner(String basePackage, ClassLoader cl) {          this .basePackage = basePackage;          this .cl = cl;      }        /**       * Get all fully qualified names located in the specified package       * and its sub-package.       *       * @return A list of fully qualified names.       * @throws IOException       */      @Override      public List<string> getFullyQualifiedClassNameList() throws IOException {          logger.info( "开始扫描包{}下的所有类" , basePackage);            return doScan(basePackage, new ArrayList<>());      }        /**       * Actually perform the scanning procedure.       *       * @param basePackage       * @param nameList A list to contain the result.       * @return A list of fully qualified names.       *       * @throws IOException       */      private List<string> doScan(String basePackage, List<string> nameList) throws IOException {          // replace dots with splashes          String splashPath = StringUtil.dotToSplash(basePackage);            // get file path          URL url = cl.getResource(splashPath);          String filePath = StringUtil.getRootPath(url);            // Get classes in that package.          // If the web server unzips the jar file, then the classes will exist in the form of          // normal file in the directory.          // If the web server does not unzip the jar file, then classes will exist in jar file.          List<string> names = null ; // contains the name of the class file. e.g., Apple.class will be stored as "Apple"          if (isJarFile(filePath)) {              // jar file              if (logger.isDebugEnabled()) {                  logger.debug( "{} 是一个JAR包" , filePath);              }                names = readFromJarFile(filePath, splashPath);          } else {              // directory              if (logger.isDebugEnabled()) {                  logger.debug( "{} 是一个目录" , filePath);              }                names = readFromDirectory(filePath);          }            for (String name : names) {              if (isClassFile(name)) {                  //nameList.add(basePackage + "." + StringUtil.trimExtension(name));                  nameList.add(toFullyQualifiedName(name, basePackage));              } else {                  // this is a directory                  // check this directory for more classes                  // do recursive invocation                  doScan(basePackage + "." + name, nameList);              }          }            if (logger.isDebugEnabled()) {              for (String n : nameList) {                  logger.debug( "找到{}" , n);              }          }            return nameList;      }        /**       * Convert short class name to fully qualified name.       * e.g., String -> java.lang.String       */      private String toFullyQualifiedName(String shortName, String basePackage) {          StringBuilder sb = new StringBuilder(basePackage);          sb.append( '.' );          sb.append(StringUtil.trimExtension(shortName));            return sb.toString();      }        private List<string> readFromJarFile(String jarPath, String splashedPackageName) throws IOException {          if (logger.isDebugEnabled()) {              logger.debug( "从JAR包中读取类: {}" , jarPath);          }            JarInputStream jarIn = new JarInputStream( new FileInputStream(jarPath));          JarEntry entry = jarIn.getNextJarEntry();            List<string> nameList = new ArrayList<>();          while ( null != entry) {              String name = entry.getName();              if (name.startsWith(splashedPackageName) && isClassFile(name)) {                  nameList.add(name);              }                entry = jarIn.getNextJarEntry();          }            return nameList;      }        private List<string> readFromDirectory(String path) {          File file = new File(path);          String[] names = file.list();            if ( null == names) {              return null ;          }            return Arrays.asList(names);      }        private boolean isClassFile(String name) {          return name.endsWith( ".class" );      }        private boolean isJarFile(String name) {          return name.endsWith( ".jar" );      }        /**       * For test purpose.       */      public static void main(String[] args) throws Exception {          PackageScanner scan = new ClasspathPackageScanner( "cn.fh.lightning.bean" );          scan.getFullyQualifiedClassNameList();      }   }</string></string></string></string></string></string></string></code>

     上面的代码中用到了StringUtils类，如下：

     ?

     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

     <code class = " hljs java" > public class StringUtil {      private StringUtil() {        }        /**       * "file:/home/whf/cn/fh" -> "/home/whf/cn/fh"       * "jar:file:/home/whf/foo.jar!cn/fh" -> "/home/whf/foo.jar"       */      public static String getRootPath(URL url) {          String fileUrl = url.getFile();          int pos = fileUrl.indexOf( '!' );            if (- 1 == pos) {              return fileUrl;          }            return fileUrl.substring( 5 , pos);      }        /**       * "cn.fh.lightning" -> "cn/fh/lightning"       * @param name       * @return       */      public static String dotToSplash(String name) {          return name.replaceAll( "\\." , "/" );      }        /**       * "Apple.class" -> "Apple"       */      public static String trimExtension(String name) {          int pos = name.indexOf( '.' );          if (- 1 != pos) {              return name.substring( 0 , pos);          }            return name;      }        /**       * /application/home -> /home       * @param uri       * @return       */      public static String trimURI(String uri) {          String trimmed = uri.substring( 1 );          int splashIndex = trimmed.indexOf( '/' );            return trimmed.substring(splashIndex);      } }</code>