A Universal Comparator using reflections

Question

Folks,
<edit purpose="bump" secondaryPurpose="explain stuff a bit better">
Sorry I didn't explain what this thing is... and zero bites in the veiw of several active silver backs means, I presume, that I did something magorly wrong... so...
This class class calls the compare method passing the result of named "getter" method on the two objects to compare. So what? Well... Ummm... It means you can sort by any field of any List (or PriorityQueue, or what-have-you) without having to pre-write a Comparator.... Which is good.
</edit>
I was inspired by a blog entry by ?was it warnerja? which was referenced in a thread which was linked from an off-topic post in a thread I read last ?Thursday? night... and to cut a long storry short... I can't find the blog entry again :(
My implementation is based on [this one by Lone Deranger|http://www.planet-source-code.com/vb/scripts/ShowCode.asp?txtCodeId=3308&lngWId=2] ... which has a couple of problems
1. infinite recursion in the equals method == OutOfStackSpaceException
2. It gets the method defintion every time you call compare == sloooooooooooowwwwwwwwwww.
This version
* is a bit faster
* verifies as much as possible in constructor.
* uses generics to verify (as far as possible) the runtime "compared Class" type.
But I'm pretty sure someone who really knows there generics could improve upon the implementation (or quit possibly the fundamental design). Specifically I'm not in love passing the Class of the compared objects as well as define the generic type. There's GOT to be a better way... I'm just to inexpert/stupid to recognise it... I've probably been staring straight at it for the last two hours.
So.... This thing works... but any suggestions and/or constructive criticism would be welcome ;-) Thanx.
UniversalReflectiveComparator.java
package forums;
import java.util.Comparator;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
public class UniversalReflectiveComparator<T> implements Comparator<T>
  public static String DEFAULT_METHOD_NAME = "toString";
  public static final int ASCENDING = 1;
  public static final int DESCENDING = -1;
  public static int DEFAULT_ORDER = ASCENDING;
  private static final java.lang.Object[] NO_ARGS = null;
  private final String methodName;
  private final Method getterMethod;
  private final int order;
  public UniversalReflectiveComparator(Class classToCompare)
    throws NoSuchMethodException
    this(classToCompare, DEFAULT_METHOD_NAME, DEFAULT_ORDER);
  public UniversalReflectiveComparator(Class classToCompare, String methodName)
    throws NoSuchMethodException
    this(classToCompare, methodName, DEFAULT_ORDER);
  public UniversalReflectiveComparator(Class classToCompare, int order)
    throws NoSuchMethodException
    this(classToCompare, DEFAULT_METHOD_NAME, order);
  @SuppressWarnings("unchecked")
  public UniversalReflectiveComparator(Class classToCompare, String methodName, int order)
    throws NoSuchMethodException
    getterMethod = classToCompare.getMethod(methodName, (java.lang.Class<?>[])null);
    Class returnType = getterMethod.getReturnType();
    if ("void".equals(returnType.getName())) {
      throw new IllegalArgumentException("Cannot compare on the '"+methodName+"' method"
      + " because its return type is void (ie: it does not return a value to compare).");
    if ( !doesImplement(returnType, Comparable.class.getCanonicalName()) ) {
      throw new IllegalArgumentException("Cannot compare on the '"+methodName+"' method"
      + " because its return type '"+returnType.getName()+"' does not implement Comparable.");
    this.methodName = methodName;
    this.order = order;
  @Override
  @SuppressWarnings("unchecked")
  public int compare(T o1, T o2) {
    try {
      Comparable o1attribute = (Comparable) getterMethod.invoke(o1, NO_ARGS);
      Comparable o2attribute = (Comparable) getterMethod.invoke(o2, NO_ARGS);
      return o1attribute.compareTo(o2attribute) * order;
    } catch (Exception e) {
      throw new IllegalStateException("Failed to compare "+clazz(o1)+ " to "+clazz(o2), e);
   * Returns the type and string value of the given object.
   * eg: java.lang.String 'Hello World!'
  private static String clazz(Object object) {
    return object.getClass().getCanonicalName()+" '"+String.valueOf(object)+"'";
   * Returns: Does the given clazz implement the given interfaceName
   * @param clazz the Class to be examined.
   * @param canonicalInterfaceName the full name (with or without generics)
   *  of the interface sought: path.to.Interface[<path.to.GenericType>]
  private static boolean doesImplement(Class clazz, String canonicalInterfaceName) {
    for ( Type intrface : clazz.getGenericInterfaces() ) {
      if ( intrface.toString().startsWith(canonicalInterfaceName) ) {
        return true;
    return false;
UniversalComparatorTest.java
package forums;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
// A simple "Bean" class for testing only.
// Does NOT implement comparable!
class Word {
  private final String word;
  public Word(String word) { this.word=word; }
  public String getWord() {  return this.word; }
  public void noop() { }
  public String toString() { return this.word;  }
  public Word notComparable() { return new Word("notComparable"); }
class UniversalComparatorTest
  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    try {
      List<Word> words = readWords("WordFinder.txt");
      System.err.println("---------------------------------------------------");
      // SUCCESS CASES
                       //short for new UniversalReflectiveComparator<Word>(Word.class,"toString",ASCENDING);
      try {
        Collections.sort(words, new UniversalReflectiveComparator<Word>(Word.class));
        System.out.println(words);
      } catch (Exception e) {e.printStackTrace();}
      System.err.println("---------------------------------------------------");
      try {
        Collections.sort(words, new UniversalReflectiveComparator<Word>(Word.class, "getWord", UniversalReflectiveComparator.DESCENDING));
      } catch (Exception e) {e.printStackTrace();}
      System.out.println(words);
      System.err.println("---------------------------------------------------");
      try {
        Collections.sort(words, new UniversalReflectiveComparator<Word>(Word.class, UniversalReflectiveComparator.DESCENDING));
      } catch (Exception e) {e.printStackTrace();}
      System.out.println(words);
      System.err.println("---------------------------------------------------");
      // FAIL CASES
      try {
        Collections.sort(words, new UniversalReflectiveComparator<Word>(Word.class, "nonExistantMethodName"));
      } catch (Exception e) {e.printStackTrace();}
      System.err.println("---------------------------------------------------");
      try {
        Collections.sort(words, new UniversalReflectiveComparator<Word>(Word.class, "noop"));
      } catch (Exception e) {e.printStackTrace();}
      System.err.println("---------------------------------------------------");
      try {
        Collections.sort(words, new UniversalReflectiveComparator<Word>(Word.class, "notComparable"));
      } catch (Exception e) {e.printStackTrace();}
      System.err.println("---------------------------------------------------");
    } catch (Exception e) {
      e.printStackTrace();
   * reads each line of the given file into a List of strings.
   * @param String filename - the name of the file to read
   * @return an List handle ArrayList of strings containing file contents.
  public static List<Word> readWords(String filename) throws FileNotFoundException, IOException {
    List<Word> results = new ArrayList<Word>();
    BufferedReader reader = null;
    try {
      reader = new BufferedReader(new FileReader(filename));
      String line = null;
      while ( (line=reader.readLine()) != null ) {
        results.add(new Word(line));
    } finally {
      if(reader!=null)reader.close();
    return results;
}Cheers all. Keith.
PS: If you happen to know that blog entry... could you post a link... please.
Edited by: corlettk on 2/11/2008 15:52 - Ooops!
Edited by: corlettk on 2/11/2008 18:20 - You Snobs!
Edited by: corlettk on 2/11/2008 19:00 - Dodgems bump!

Answer 1

Here's the latest installment...
This thing writes, compiles and instantiates and caches the requested implementation of Comparator<?> on-the-fly with the system default javax.tools.JavaCompiler
Some Notes:
* Gee, it's just sooooo easy to invoke the compiler.
* Compilation errors are printed to stdout.
* It takes too long to compile... aprox nine-tenths of a second (0.95 +/- 0.04) for a really simple little class.
* I like the cache... subsequent calls for the same comparator are instant ;-)
* Possible enhancement: oninit: load the cache with .class's from the specified package (a seperate comparators package), so you only have to create each comparator once per release (ie: like JSP's)
* It throws too many distinct exception types... I think it would be better if it threw only one ComparatorGenerationException (but I'm too lazy to fix it now).
* I don't like the "staticness" anymore, especially with a cache involved. Maybe a ComparatorFactoryConfig extends Properties would be the best way to configure the factory? Or maybe a ComparatorSpec class should be passed to the createComparator method... to eliminate all that cumbersome overloading to just to provide defaults. Hmmm.
* The order switch means you can sort both ways using the one generated
* A simillar "nulls first or last" switch would be a good enhancement.
* Camickr's solution also features a case[in]senstive switch... feel free to add it ;-)
* It's still not a scratch on Mr Kirkman's ASM solution (which is aprox 10 times as fast), but it'll definately give the "pure reflection" solution a run for it's money.
* I can imagine a common "front end" for both the "reflective" and "code-gen" solutions... if the list size is less than 10,000 just reflect it, else code-gen.
UniversalOnTheFlyCompiledComparatorFactory.java
package forums;
import java.util.Comparator;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class UniversalOnTheFlyCompiledComparatorFactory
  public static String DEFAULT_METHOD_NAME = "toString";
  public static String SRC_DIR = "C:/java/home/src/";
  public static String PACKAGE = "forums";
  public static final int DESCENDING = -1;
  public static final int ASCENDING = 1;
  public static int DEFAULT_ORDER = ASCENDING;
  private static final java.lang.Class<?>[] NULL_CLASS_ARRAY = null;
  public static Comparator createComparator(Class classToCompare)
    throws NoSuchMethodException, IOException, CompilationException, ClassNotFoundException, InstantiationException, IllegalAccessException
    return createComparator(classToCompare, DEFAULT_METHOD_NAME, DEFAULT_ORDER);
  public static Comparator createComparator(Class classToCompare, String methodName)
    throws NoSuchMethodException, IOException, CompilationException, ClassNotFoundException, InstantiationException, IllegalAccessException
    return createComparator(classToCompare, methodName, DEFAULT_ORDER);
  public static Comparator createComparator(Class classToCompare, int order)
    throws NoSuchMethodException, IOException, CompilationException, ClassNotFoundException, InstantiationException, IllegalAccessException
    return createComparator(classToCompare, DEFAULT_METHOD_NAME, order);
  public static Map<String,Comparator<?>> cache = new HashMap<String,Comparator<?>>();
  @SuppressWarnings("unchecked")
  public static Comparator createComparator(Class classToCompare, String methodName, int order)
    throws NoSuchMethodException, IOException, CompilationException, ClassNotFoundException, InstantiationException, IllegalAccessException
    final String key = classToCompare.getName()+"."+methodName+"_"+order;
    Comparator<?> comparator = cache.get(key);
    if (comparator != null) {
      return comparator;
    final Method getterMethod = classToCompare.getMethod(methodName, NULL_CLASS_ARRAY);
    final Class returnType = getterMethod.getReturnType();
    if ("void".equals(returnType.getName())) {
      throw new IllegalArgumentException("Cannot compare on the '"+methodName+"' method because its return type is void (ie: it does not return a value to compare).");
    if ( !isComparable(returnType) ) {
      throw new IllegalArgumentException("Cannot compare on the '"+methodName+"' method because its return type '"+returnType.getName()+"' does not implement Comparable.");
    final File javaFile = writeComparatorJava(classToCompare, getterMethod, order);
    if ( ToolProvider.getSystemJavaCompiler().run(null, System.out, System.err, javaFile.getName()) != 0 ) {
      throw new CompilationException("Failed to compile comparator file: "+javaFile.getAbsolutePath());
    final String comparatorClassName = PACKAGE+"."+javaFile.getName().replaceAll("\\.java$", "");
    comparator = (Comparator<?>) Class.forName(comparatorClassName).newInstance();
    cache.put(key, comparator);
    return comparator;
  private static File writeComparatorJava(Class classToCompare, Method getterMethod, int order)
    throws IOException, CompilationException
    final String nameOfClassToCompare = classToCompare.getName().replaceAll("^.*(?=\\.)\\.",""); // remove everything before the last .
    final String getterMethodName = getterMethod.getName();
    final String comparatorClassName = nameOfClassToCompare + getterMethodName.replaceAll("^get","").replaceAll("toString","String") + "Comparator";
    final File comparatorClassFile = new File(SRC_DIR+PACKAGE+"/"+comparatorClassName+".java");
    PrintWriter out = null;
    try {
      out = new PrintWriter(new FileWriter(comparatorClassFile));
      out.println("package "+PACKAGE+";");
      out.println("public class "+comparatorClassName+" implements java.util.Comparator<"+nameOfClassToCompare+">");
      out.println("{");
      out.println("  public static final int DESCENDING = -1;");
      out.println("  public static final int ASCENDING = 1;");
      out.println("  public static final int DEFAULT_ORDER = "+order+";");
      out.println("  public final int order;");
      out.println();
      out.println("  public "+comparatorClassName+"() { this(DEFAULT_ORDER); }");
      out.println();
      out.println("  public "+comparatorClassName+"(int order) { this.order = order; }");
      out.println();
      out.println("  // nulls come last");
      out.println("  public int compare("+nameOfClassToCompare+" a, "+nameOfClassToCompare+" b) {");
      out.println("    if (a==null) {");
      out.println("      return b==null ? 0 : -1;");
      out.println("    } else {");
      out.println("      return b==null ? 1 : a."+getterMethodName+"().compareTo(b."+getterMethodName+"()) * order;");
      out.println("    }");
      out.println("  }");
      out.println();
      out.println("}");
    } finally {
      if (out!=null)out.close();
    return comparatorClassFile;
   * Returns: Does the given clazz implement the given interfaceName
   * @param clazz the Class to be examined.
   * @param canonicalInterfaceName the full name (with or without generics)
   *  of the interface sought: path.to.Interface[<path.to.GenericType>]
  private static boolean isComparable(Class clazz) {
    for ( Type i : clazz.getGenericInterfaces() ) {
      if ( i.toString().startsWith("java.lang.Comparable") ) {
        return true;
    return false;
UniversalComparatorTest.java
package forums;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
// A simple "Bean" class for testing only.
// Does NOT implement comparable!
class Word {
  private final String word;
  public Word(String word) { this.word=word; }
  public String getWord() {  return this.word; }
  public void noop() { }
  public String toString() { return this.word;  }
  public Word notComparable() { return new Word("notComparable"); }
class UniversalComparatorTest
  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    try {
      List<Word> words = readWords("WordFinder.txt");
      System.err.println("---------------------------------------------------");
        long start = System.nanoTime();
        try {
          Comparator<Word> wordComparator = UniversalOnTheFlyCompiledComparatorFactory.createComparator(Word.class);
          Collections.sort(words, wordComparator);
          System.out.println(words);
        } catch (Exception e) {e.printStackTrace();}
        long stop = System.nanoTime();
        System.err.printf("took %6.4f seconds%n", (stop-start)/1000000000.0);
        System.err.println("---------------------------------------------------\n");
        long start = System.nanoTime();
        try {
          Comparator<Word> wordComparator = UniversalOnTheFlyCompiledComparatorFactory.createComparator(Word.class);
          Collections.sort(words, wordComparator);
          System.out.println(words);
        } catch (Exception e) {e.printStackTrace();}
        long stop = System.nanoTime();
        System.err.printf("took %6.4f seconds%n", (stop-start)/1000000000.0);
        System.err.println("---------------------------------------------------\n");
    } catch (Exception e) {
      e.printStackTrace();
   * reads each line of the given file into a List of strings.
   * @param String filename - the name of the file to read
   * @return an List handle ArrayList of strings containing file contents.
  public static List<Word> readWords(String filename) throws FileNotFoundException, IOException {
    List<Word> results = new ArrayList<Word>();
    BufferedReader reader = null;
    try {
      reader = new BufferedReader(new FileReader(filename));
      String line = null;
      while ( (line=reader.readLine()) != null ) {
        results.add(new Word(line));
    } finally {
      if(reader!=null)reader.close();
    return results;
}Cheers. Keith.
It's Bed Time ;-)