Question

I ran into a problem using java objects in jython today because jython is trying to be intelligent and automatically creates properties for (simple) getter/setter methods – For each method a field with the leading get/set removed and the next letter converted to lowercase is created:

//java code
class MyClass {
    public List<Thing> getAllThings() { ... }
    public List<Thing> getSpecificThings(String filter) { ... }
    public void setSomeThing(SomeThing x) { ... }
    [...]
}

#jython code
obj = MyClass()
hasattr(obj, "allThings") #-> True
hasattr(obj, "specificThings") #-> False because getSpecificThings has a param
hasattr(obj, "someThing") #-> False BUT
"someThing" in dir(obj)   #-> True

The last line summarizes my problem here – the result of dir contains these fields (even when executed on obj.class instead of obj). I need a list of all methods callable on the object, which for my objects basically is the result of dir without these properties and filtered to exclude everything inherited from java.lang.Object and things starting with an underscore (the purpose of this is to automagically convert some python classes to java equivalents, e.g. dicts to Maps). In theory I could use __dict__ which doesn’t contain them, but this would mean I’d have to recursively evaluate the base classes’ __dict__s too, which I would like to avoid. What I am currently doing is seeing if the attribute actually exists and then check if it has an argslist attribute (meaning it is a method), which is true for every dir entry except for the generated properties:

for entry in dir(obj):
    #skip things starting with an underscore or inherited from Object
    if entry.startswith("_") or entry in dir(java.lang.Object): continue
    #check if the dir entry is a fake setter property
    if not hasattr(obj, entry): continue
    #check if the dir entry has an argslist attribute (false for getter props)
    e = getattr(obj, entry)
    if not hasattr(e, "argslist"): continue
    #start actual processing of the entry...

The problem with this approach is that the objects in question are interfaces to beans and a getSomething method typically fetches data from a database, so the getattr call for a property makes a roundtrip to the DB which can take multiple seconds and waste tons of memory.

Can I stop jython from generating these properties? If not, does anybody have an idea how I can filter out the properties without accessing them first? The only thing I could think of was checking if dir contains a method named get/set<property>, but this seems hackish and could generate false positives, which must be avoided.

Answer 1

The answer was easier than anticipated. While a hasattr of the property is True for an object instance, it is False for the objects class if the get-method in question is not static – the class doesn’t have the property as you can’t execute the method on it. The updated loop now looks like this:

for entry in dir(obj):
    #skip things starting with an underscore or inherited from Object
    if entry.startswith("_") or entry in dir(java.lang.Object): continue
    #check if the dir entry is a fake property
    if not hasattr(obj.class, entry): continue
    #check if the dir entry has an argslist attribute (false if not a method)
    e = getattr(obj, entry)
    if not hasattr(e, "argslist"): continue
    #start actual processing of the entry...