Question

A little background first. I am looking into the possibility of implementing Ruby’s ActiveRecord in Java as cleanly and succinctly as possible. To do this I would need to allow for the following type of method call:

Person person = Person.find("name", "Mike");

Which would resolve to something like:

ActiveRecord.find(Person.class, "name", "Mike");

The plan is to have Person extend ActiveRecord, which would have a static find method with two parameters (column, value). This method would need to know it was called via Person.find and not another domain class like Car.find and call the find(Class, String, Object) method to perform the actual operation.

The problem I am running into is the finding out via which child class of ActiveRecord the static find method (two param) was called. The following is a simple test case:

public class A {
  public static void testMethod() {
    // need to know whether A.testMethod(), B.testMethod(), or C.testMethod() was called
  }
}

public class B extends A { }
public class C extends A { }

public class Runner {
  public static void main(String[] args) {
    A.testMethod();
    B.testMethod();
    C.testMethod();
  }
}

Solutions found so far are load-time or compile time weaving using aspectJ. This would involve placing a call interceptor on the testMethod() in A and finding out what signature was used to call it. I am all for load time weaving but the set up of setting this up (via VM args) is a bit complex.

Is there a simpler solution?

Is this at all possible in java or would need to be done in something like groovy/ruby/python?

Would the approach of using something like ActiveRecord.find for static loads and Person.save for instances be better overall?

Answer 1

You cannot override static methods in Java, so any calls to the static method via a subclass will be bound to the base class at compile time. Thus a call to B.testMethod() will be bound to A.testMethod before the application is ever run.

Since you are looking for the information at runtime, it will not be available through normal Java operations.