How does Groovy register Closure Listener on JButton - groovy

Question

I'm learning Groovy and I've seen this example:
button = new JButton('Push me!')
button.actionPerformed = { event ->
println button.text
}
There is no actionPerformed field/method on JButton....
Could someone explain how Closure is being registered by Groovy on actionPerformed ?

Answer 1

TL;DR
JButton metaclass registers 31 listeners methods (one of them is actionPerformed) and whenever you call button.actionPerformed = { event -> } Groovy executes a method like setProperty(object, field, value) which checks if there is a listener registered with a given field name - if does, it executes registered listener method (javax.swing.AbstractButton.addActionListener(java.awt.event.ActionListener) in this case).
Detailed explanation
Groovy uses MOP (metaobject protocol) for a dynamic runtime environment. It means that Groovy does not call methods directly like in Java, but uses this additional layer instead. It allows changing class behavior at a runtime.
Whenever we try to set a class field/property value like
button.actionPerformed = { event -> println "Clicked!" }
Groovy calls proper setProperty method. In case of a setting a property for class like JButton, following setProperty method gets called:
https://github.com/apache/groovy/blob/GROOVY_2_4_X/src/main/groovy/lang/MetaClassImpl.java#L2602
/**
* <p>Retrieves a property on the given receiver for the specified arguments. The sender is the class that is requesting the property from the object.
* The MetaClass will attempt to establish the method to invoke based on the name and arguments provided.
*
* <p>The useSuper and fromInsideClass help the Groovy runtime perform optimisations on the call to go directly
* to the super class if necessary
*
* #param sender The java.lang.Class instance that is mutating the property
* #param object The Object which the property is being set on
* #param name The name of the property
* #param newValue The new value of the property to set
* #param useSuper Whether the call is to a super class property
* #param fromInsideClass Whether the call was invoked from the inside or the outside of the class.
*/
public void setProperty(Class sender, Object object, String name, Object newValue, boolean useSuper, boolean fromInsideClass) {
checkInitalised();
//----------------------------------------------------------------------
// handling of static
//----------------------------------------------------------------------
boolean isStatic = theClass != Class.class && object instanceof Class;
if (isStatic && object != theClass) {
MetaClass mc = registry.getMetaClass((Class) object);
mc.getProperty(sender, object, name, useSuper, fromInsideClass);
return;
}
// .....
//----------------------------------------------------------------------
// listener method
//----------------------------------------------------------------------
boolean ambiguousListener = false;
if (method == null) {
method = listeners.get(name);
ambiguousListener = method == AMBIGUOUS_LISTENER_METHOD;
if (method != null &&
!ambiguousListener &&
newValue instanceof Closure) {
// let's create a dynamic proxy
Object proxy = Proxy.newProxyInstance(
theClass.getClassLoader(),
new Class[]{method.getParameterTypes()[0].getTheClass()},
new ConvertedClosure((Closure) newValue, name));
arguments = new Object[]{proxy};
newValue = proxy;
} else {
method = null;
}
}
// ......
}
It goes to the block responsible for checking listener methods. Swing related classes register their listener methods so you can add a listener method like:
button.actionPerformed = { event -> .... }
instead of
button.addActionListener(new ActionListener() {
#Override
void actionPerformed(ActionEvent actionEvent) {
}
})
And here is the list of all 31 registered listeners:
Keys are the names of listeners and values are method objects that receives a closure set to a property. Of course it finds a listener method for a key actionPerformed - it gets a reference to a method
public void javax.swing.AbstractButton.addActionListener(java.awt.event.ActionListener)
and it passes a closure
{ event ->
println button.text
}
to it.
When these listeners like actionPerformed get registered to a metaclass?
Metaclass object gets initialized whenever you call a class constructor. Groovy in this case calls
org.codehaus.groovy.runtime.callsite.AbstractCallSite.callConstructor(Object receiver, Object arg1, Object arg2)
https://github.com/apache/groovy/blob/GROOVY_2_4_X/src/main/org/codehaus/groovy/runtime/callsite/AbstractCallSite.java#L245
If you follow call stack you will find these two major checkpoints:
at some point dynamic call constructor method reaches CallSiteArray.createCallConstructorSite() method that creates a metaclass object https://github.com/apache/groovy/blob/GROOVY_2_4_X/src/main/org/codehaus/groovy/runtime/callsite/CallSiteArray.java#L86
MetaClassImpl.initialize() method calls addProperties() which sets up metaclass with e.g. listeners https://github.com/apache/groovy/blob/GROOVY_2_4_X/src/main/groovy/lang/MetaClassImpl.java#L3303
Inside MetaClassImpl.addProperties() Groovy lists all listener methods using BeanInfo class and registers all found listeners https://github.com/apache/groovy/blob/GROOVY_2_4_X/src/main/groovy/lang/MetaClassImpl.java#L3343
The full call stack to this MetaClassImpl.addProperties() method from IntelliJ IDEA debugger window looks like this:
You can set a breakpoint at any of these lines if you would like to dig even deeper. Hope it helps.