JarCastingReflect 1.0.1
====
*Fluent Reflection - Get rid of the messy boiler plate!
Setup
Maven Dependency Setup
Current Release - 1.0.1
<dependency>
<groupId>org.pacesys</groupId>
<artifactId>reflect</artifactId>
<version>1.0.0</version>
</dependency>
Current Snapshot (Development) - 1.0.2-SNAPSHOT
<dependency>
<groupId>org.pacesys</groupId>
<artifactId>reflect</artifactId>
<version>1.0.2-SNAPSHOT</version>
</dependency>
Field Recipes
Finding All Fields
This will return all fields from all super classes (public and private)
List<Field> fields = Reflect.on(someClass).fields().all();
Finding All Fields based on an Annotation
This will find all fields that have been annotated with the specified annotation in the class hierarchy.
List<Field> fields = Reflect.on(someClass).fields().annotatedWith(annotation);
Single Field
Will find a single field based on the specified name
Field f = Reflect.on(someClass).fields().named(fieldName);
Matching based on a Predicate
A predicate will allow you to control what is matched and what should be discarded during inspection. Each field found in the hierarchy will be passed to the predicate to return either a true (matched) or false to discard. The matched list will be returned
Predicate<Field> predicate = new Predicate<Field>() {
public boolean apply(Field field) {
if (field.isEnumConstant() || someOtherEval)
return true;
return false;
}
};
List<Field> fields = Reflect.on(someClass).fields().match(predicate);
Public Only Fields
Finds only public based fields within the class hierarchy
List<Field> fields = Reflect.on(someClass).fields().publicOnly();
Method Recipes
The method finder has two modes in the builder chain. Each mode provides the same chained options.
// Finds static and instance based methods
Reflect.on(someClass).methods().chain //...
// Finds ONLY static methods
Reflect.on(someClass).methods(StaticType.STATIC).chain //...
// Finds ONLY instance methods
Reflect.on(someClass).methods(StaticType.INSTANCE).chain //...
Finding All Methods
This will return all methods from all super classes (public and private)
List<Method> methods = Reflect.on(someClass).methods().all();
Finding Accessors and Mutators
The following call will find all Java Bean based Accessor/Mutator methods for the full class hierarchy
// Map of Name to Method
Map<String,Method> accessors = Reflect.on(someClass).methods().accessors();
// Map of Name to Method
Map<String,Method> mutators = Reflect.on(someClass).methods().mutators();
Finding Methods based on an Annotation
This will find all methods that have been annotated with the specified annotation in the current class only
List<Method> methods = Reflect.on(someClass).methods().annotatedWith(annotation);
This will find all methods that have been annotated with the specified annotation in the class hierarchy (current class and superclasses)
List<Method> methods = Reflect.on(someClass).methods().annotatedWithRecursive(annotation);
Finding a Method by Name
Method m = Reflect.on(someClass).methods().named("getPerson");
Matching Methods based on a Predicate
A predicate will allow you to control what is matched and what should be discarded during inspection. Each method found will be passed to the predicate to return either a true (matched) or false to discard. The matched list will be returned
Predicate<Method> predicate = new Predicate<Method>() {
public boolean apply(Method method) {
if (method equals something)
return true;
return false;
}
};
List<Method> methods = Reflect.on(someClass).methods().match(predicate);
Public Only Methods
Finds only public based methods within the class
List<Method> methods = Reflect.on(someClass).methods().publicOnly();
Calling a Method
The following shows how to easily call a method and get back Generic type T as a result.
// No Arguments - returns T (in example SomeResult)
SomeResult something = Reflect.on(method).against(new Object()).call();
// With Arguments - returns T (in example SomeResult)
SomeResult something = Reflect.on(method).against(new Object()).call(myVarArgs);
Keeping Reflect for many calls
If you have many lookups such as finding Fields, Methods and calling methods it's more efficient to hold onto Reflect while using it against the current class.
Reflect r = Reflect.on(someClass);
Map<String,Method> mutators = r.methods().mutators();
if (mutators.containsKey("name"))
Reflect.on(mutators.get("name")).against(someClassInstance).call("Jeff");
Field f = r.fields().named("myField");
// etc
License
Reflect is licensed under MIT. See License.txt for license. Copyright 2013, Jeremy Unruh