Reflections工具包

工作中配合Google Guice的使用，用到了Reflections工具包，记录一下，备忘。

项目地址： http://code.google.com/p/reflections/

从官方文档上，我们可以了解到它是一个用于Java运行时元数据分析，本着注解搜寻的精神。

用途：

Reflections scans your classpath, indexes the metadata, allows you to query it on runtime and may save and collect that information for many modules within your project.


Using Reflections you can query your metadata such as:

get all subtypes of some type
get all types/methods/fields annotated with some annotation, w/o annotation parameters matching
get all resources matching matching a regular expression

UseCases:

Java代码

1. some useful use cases below:
3. bootstrap in a multi module environment
4. collect pre scanned metadata
5. serialize Reflections into a java source file, and use it to statically reference java elements
6. query the store directly, avoid definition of types in class loader
7. find resources in your classpath (for example all properties files)
8. optional parallel scanning
9. bootstrap in a multi module environment
10. In a multi module project, where each module is responsible for it's properties, jpa entities and maybe guice modules, use Reflections to collect that metadata and bootstrap the application
12. Reflections reflections = new Reflections(new ConfigurationBuilder()
13. .addUrls(ClasspathHelper.forPackage("your.package.here"),
14. ClasspathHelper.forClass(Entity.class),
15. ClasspathHelper.forClass(Module.class))
16. .setScanners(new ResourcesScanner(),
17. new TypeAnnotationsScanner(),
18. new SubTypesScanner()));
20. Set<String> propertiesFiles = reflections.getResources(Pattern.compile(".*\\.properties"));
21. Properties allProperties = createOneBigProperties(propertiesFiles);
23. Set<Class<?>> jpaEntities = reflections.getTypesAnnotatedWith(Entity.class);
24. SessionFactory sessionFactory = createOneBigSessionFactory(jpaEntities, allProperties);
26. Set<Class<? extends Module>> guiceModules = reflections.getSubTypesOf(Module.class);
27. Injector injector = createOneBigInjector(guiceModules);
28. collect pre scanned metadata
29. first configure your project's parent pom in the build.plugins section with Reflections, like this
31. <plugin>
32. <groupId>org.reflections</groupId>
33. <artifactId>reflections-maven</artifactId>
34. <version>0.9.8</version>
35. <executions>
36. <execution>
37. <goals>
38. <goal>reflections</goal>
39. </goals>
40. <phase>process-classes</phase>
41. </execution>
42. </executions>
43. </plugin>
44. than, on runtime, collect these pre saved metadata and instantiate Reflections
46. Reflections reflections =
47. isProduction() ? Reflections.collect() : new Reflections("your.package.here");
48. of course, saving the scanned metadata can be done without maven, by simply calling the save method
50. public static void main(String[] args) {
51. //from time to time, I run this main to regenerate saved metadata for Reflections
52. new Reflections(new ConfigurationBuilder()
53. .setUrls(ClasspathHelper.forPackage("my.project.prefix"))
54. .setScanners(/*whatever*/))
55. .save("src/main/resources/resource1-reflections.xml");
57. new Reflections(new ConfigurationBuilder()
58. .setUrls(ClasspathHelper.forPackage("my.project.prefix.model"))
59. .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("my.project.prefix.model")))
60. .setScanners(new TypesScanner(), new TypeElementsScanner())
61. .setSerializer(new JavaCodeSerializer()))
62. .save("src/main/java/my.project.prefix.model.MyModelStore");
63. }
64. serialize Reflections into a java source file, and use it to statically reference java elements
65. Reflections reflections = new Reflections(new ConfigurationBuilder()
66. .filterInputsBy(new FilterBuilder().include("model.package"))
67. .setScanners(new TypesScanner(), new TypeElementsScanner())
68. .setUrls(asList(ClasspathHelper.forPackage("model.package"))));
70. String filename = System.getProperty("user.dir") + "/src/test/java/model.package.reflections.MyModelStore";
71. reflections.save(filename, new JavaCodeSerializer());
72. replace "model.package" with your model's package prefix
74. this serializes types and types elements into interfaces respectively to fully qualified name, for example: