Spring 获取一个包和子包下面所有的类

from:http://www.iteye.com/topic/203267

 

参考spring2.5里面的component-scan功能,提炼出这样一个工具类,此类依赖spring但不依赖spring容器,请注意此类搜索不到jdk的包如java.lang

Java代码

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