I don't have a library for you but if you get a random generator, then maybe this class can come in handy:
public class BeanMethodIterator implements Iterable<Method> {
private static final int MODIFIER_FILTER = (Modifier.PUBLIC | Modifier.STATIC);
private static final int MODIFIER_EXPECTED = Modifier.PUBLIC;
/**
* Indicator to filter getter or setter methods.
*/
public enum Filter {
/** Only getter methods. */
GETTERS(new Transform<Method, Boolean>(){
public Boolean transform(Method input) {
return (input.getName().startsWith("get") ||
input.getName().startsWith("is"))
&& input.getParameterTypes().length == 0;
};
}),
/** Only setter methods. */
SETTTERS(new Transform<Method, Boolean>(){
public Boolean transform(Method input) {
return input.getName().startsWith("set") &&
input.getParameterTypes().length == 1;
};
}),
/** Getter and setter methods. */
BOTH(new Transform<Method, Boolean>(){
public Boolean transform(Method input) {
return Filter.SETTTERS.condition.transform(input) ||
Filter.GETTERS.condition.transform(input);
};
});
private Transform<Method, Boolean> condition;
private Filter(Transform<Method, Boolean> condition) {
this.condition = condition;
}
};
/**
* Iterate parent methods also?
*/
public enum Scope {
PARENTS_ALSO() {
@Override
protected Method[] getMethods(Class<?> c) {
return c.getMethods();
};
},
THIS_CLASS_ONLY() {
@Override
protected Method[] getMethods(Class<?> c) {
return c.getDeclaredMethods();
}
};
protected abstract Method[] getMethods(Class<?> c);
}
private final Filter filter;
private final Scope scope;
private final Class<?> theClass;
/**
* Constructor.
*
* @param theClass
* @param what
*/
public BeanMethodIterator(Class<?> theClass, Filter what, Scope scope) {
this.filter = what;
this.theClass = theClass;
this.scope = scope;
}
/**
* Constructor.
*/
public BeanMethodIterator(Class<?> theClass) {
this(theClass, Filter.BOTH, Scope.PARENTS_ALSO);
}
/**
* Tells if a method is public
* @param method
* @return
*/
private static boolean isPublic(Method method) {
return (method.getModifiers() & MODIFIER_FILTER) == MODIFIER_EXPECTED;
}
/**
* {@inheritDoc}
* @see java.lang.Iterable#iterator()
*/
public Iterator<Method> iterator() {
final Method[] methods = this.scope.getMethods(this.theClass);
return new Iterator<Method>() {
int index = 0;
public boolean hasNext() {
while (index < methods.length) {
if (isPublic(methods[index]) && filter.condition.transform(methods[index]))
return true;
index++;
}
return false;
}
public Method next() {
if (!hasNext())
throw new NoSuchElementException();
return methods[index++];
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public static void main(String[] args) {
for (Method m: new BeanMethodIterator(Date.class, Filter.GETTERS, Scope.THIS_CLASS_ONLY)) {
System.out.println(m.getName());
}
}
}
/**
* Represents a function that takes one input and returns a transformation of that input value i.e.
* a transformation. The name Transform is used because it is shorter.
*
* @author Hannes de Jager
* @since 01 Sep 2008
*/
interface Transform<I, O> {
/**
* Invokes the function, performing the transformation, to produce an interpreted value.
*
* @param input the input value.
* @return The computed result.
*/
public O transform(I input);
}