Groovy 3 and the new Groovy Meta Object Protocol in examples

Unless otherwise indicated, these slides are © 2013-2014 Pivotal Software, Inc. and licensed under a
Creative Commons Attribution-NonCommercial license: http://creativecommons.org/licenses/by-nc/3.0/1
Groovy 3
the new Meta Object Protocol
in examples
Creative Commons Attribution-NonCommercial license: http://creativecommons.org/licenses/by-nc/3.0/
Jochen Theodorou, GoPivtoal Germany GmbH
@JochenTheodorou

… in certainly not enough examples
Creative Commons Attribution-NonCommercial license: http://creativecommons.org/licenses/by-nc/3.0/
Jochen Theodorou, GoPivtoal Germany GmbH
@JochenTheodorou

What cannot go forward
goes backwards.
Johann Wolfgang von Goethe
(1749-1832), German Poet
Translation by Jochen Theodorou
“

Goals:
■ Metaclass as Persistent Collection and Realms
● Better multi threading performance
● Allowing different versions of metaclasses for same class
■ Only internal metaclasses
● no „extends MetaClassImpl“ any more, instead like ExpandoMetaClass for everything
● Delegation instead of Inheritance
■ MOP Methods
● Names and Signatures change to avoid conflicts with normal methods
● GroovyObject becomes a marker interface or is removed
● All methods then optional and in different variants
● No exception controlled MOP any more
■ Others
● All operators available for meta programmings
● Based on invokedynamic and ClassValue (Java 7 becomes minimum)

MOP Methods
= in class defined methods to control MOP

Overview:
■ Uncached:
● Difficulty: I did hear of Groovy
● methodMissing, methodIntercept, propertyMissing, propertyIntercept
■ Cached 1:
● Difficulty: Me, want more. Now!
● cacheMethodMissing, cacheMethodIntercept, cachePropertyMissing,
cachePropertyIntercept
■ Cached 2:
● Difficulty: I know what I do! Give me the full program!
● cacheMethodTarget, cachePropertyTarget

MOP Methods – A Groovy Builder
Groovy 1 and Groovy 2

Groovy Builder in Groovy 1/2
class XmlBuilder {
def out
def methodMissing(String name, args) {
out << "<$name>"
if(args[0] instanceof Closure) {
args[0].delegate = this
args[0].call()
} else {
out << args[0].toString()
}
out << "</$name>"
}
}
def xml = new XmlBuilder(out:System.out)
xml.html {
head {
title "Hello World"
}
body {
p "Welcome!"
}
}
console output:
<html><head><title>Hello World</title></head><body>Welcome!
</body></html>

class XmlBuilder {
def out
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
xml.html {
head {
title "Hello World"
}
body {
p "Welcome!"
}
}
console output:
</body></html>
called if no method
can be found for call

class XmlBuilder {
def out
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
xml.html {
head {
title "Hello World"
}
body {
p "Welcome!"
}
}
console output:
</body></html>
name = name of call
args = arguments of call

class XmlBuilder {
def out
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
} //implcit return !//implcit return !
}
xml.html {
head {
title "Hello World"
}
body {
p "Welcome!"
}
}
console output:
</body></html>The result of the call is the
result of methodMissing

Groovy 3 Uncached

Groovy Builder in Groovy 3 - Uncached
class XmlBuilder {
def out
MopResult methodMissing(String name, args) {
out << "<$name>"
If (args[0] instanceof Closure) {
args[0].call()
} else {
}
out << "</$name>"
return MopResult.VOID
}
}
xml.html {
head {
title "Hello World"
}
body {
p "Welcome!"
}
}

Groovy Builder uncached - before and after
class XmlBuilder {
def out
def methodMissing
(String name, args) {
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
class XmlBuilder {
def out
MopResult methodMissing
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}

class XmlBuilder {
def out
def methodMissing
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
class XmlBuilder {
def out
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
MopResult contains the
result of the call

class XmlBuilder {
def out
def methodMissing
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
class XmlBuilder {
def out
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
it can also transport errors
or that there is no result (VOID)

Groovy 3 Cached
return how to get a result, instead of the result itself

Ein Groovy Builder in Groovy 3 - Cached
class XmlBuilder {
def out
def methodMissing
(String name, args)
{
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
class XmlBuilder {
def out
void cacheMethodMissing
(GroovyCall call, String name)
{
call.chain {out << "<${name}>"}
if(call[0].isAssignableTo(Closure))
{
call[0].chain
{it.delegate = this}
call[0].execute()
} else {
call[0].execute "toString"
}
call.chain {out << "</${name}>"}
}
}

class XmlBuilder {
def out
def methodMissing
(String name, args)
{
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
class XmlBuilder {
def out
{
{
call[0].chain
call[0].execute()
} else {
}
}
}
since there is no result
we return void

class XmlBuilder {
def out
def methodMissing
(String name, args)
{
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
class XmlBuilder {
def out
{
{
call[0].chain
call[0].execute()
} else {
}
}
}
GroovyCall is created for
each uncached call

class XmlBuilder {
def out
def methodMissing
(String name, args)
{
out << "<$name>"
args[0].call()
} else {
}
out << "</$name>"
}
}
class XmlBuilder {
def out
{
{
call[0].chain
call[0].execute()
} else {
}
}
}
No argument objects here,
only their rutime classes

Some more details:
■ We provide a high-level API to let you express how to get to a result, not what the
result is – This allows caching in the first place
■ The to be cached method called can go through cacheMethodMissing more than
once. Reasons for that can be type changes for the arguments or the receiver
■ If you want to react different to different values of the same type, caching might be
not for you. (example: provide the method to be called as additional argument
instead)

Groovy 3 MethodHandles

Ein Groovy Builder in Groovy 3 – MethodHandles
class XmlBuilder {
def out
private final MethodHandle outField = LOOKUP.findGetter....
void cacheMethodTarget
{
call.chain(
GroovyInvoker.bind(outField,"leftShift","<${name}>"))
if (call.arg(0).isAsignableTo(Closure)) {
call.arg(0).chain(
GroovyInvoker.setProperty("delegate",this))
call.arg(0).execute()
} else {
call.arg(0).execute "toString"
}
call.chain(
GroovyInvoker.bind(outField,"leftShift","</${name}>"))
}
}

Some Explanations:
■ Target is to produce a MethodHandle
■ GroovyCall high-level API is helping you here and can be mixed with MethodHandles
■ Of course the MethodHandles-API from Java7 is efficient and powerful, but also
difficult to understand and handle – for example because types have to match
exactly
■ Ultimately (and only for the most crazy people) we want to provide a way to give
your own bootstrap method and then design yourself what you do with the call. This
way you could for example completely emulate Javalogik and also speed (of course
there is still an overhead through invokedynamic)

MOP Methods – Dynamic Finder
Groovy 1 und Groovy 2

Dynamic Finder in Groovy 1/2
class GORM {
// an array of dynamic methods that use regex
def dynamicMethods = [...]
def methodMissing (String name, args) {
def method = dynamicMethods.find { it.match(name) }
if (method) {
GORM.metaClass."$name" = { Object[] varArgs ->
method.invoke(delegate, name, varArgs)
}
return method.invoke(delegate, name, args)
}
else throw new
MissingMethodException(name, delegate, args)
}
}

class GORM {
if (method) {
}
}
else throw new
}
}
adds a meta method to metaClass
for each missing method

class GORM {
if (method) {
}
}
else throw new
}
}
makes the metaClass
stay in memory

The metaclass is in Groovy 1 and 2 actually linked to an instance, but has to be
saved in a global structure. That might use SoftReferences to avoid memory
problems, still garbage collection doesn't like such actions.

Groovy 3 Uncached

Dynamic Finder in Groovy 3
class GORM {
MopResult methodMissing (String name, args) {
if (method) {
}
return MopResult.of (GroovyInvoker.invoke
(method, delegate, name, args))
}
else return MopResult.ERROR
}
}

class GORM {
if (method) {
}
}
}
}
makes the metaClass
stay in memory

class GORM {
if (method) {
}
}
}
}
but not longer than the
class GORM

Groovy 3 Cached

class GORM {
void cacheMethodMissing (GroovyCall call, String name)
{
if (method) {
call.chain (method, delegate, name)
}
else call.error()
}
}
metaClass stays unchanged

Metaclass Versions and Views

Recover old version of a metaclass
class A{}
A.metaClass.foo = {->1}
assert new A().foo() == 1
def oldMetaClass = A.metaClass.freeze()
oldMetaClass.restore()

class A{}
handler for the meta class
Instead of the meta class itself

class A{}
make handler keeping
current meta class version

class A{}
set meta method

class A{}
restore old metaclass version

Some explanations:
■ Before Groovy 3 we always mutate the metaclass
● Recovering an old state is difficult
● Isolating changes almost impossible
■ In Groovy 3 the metaclass is a persistent collection which you can reference by a
handler
● Handler can be set to always give the actual meta class
● Or to “freeze” to keep the actual version and then maybe restore later
In the long term this might actually allow to serialize meta class states

Usage of Realms
class A{}
realm {
}

Usage of Realms
class A{}
realm {
}
create sub realm

Usage of Realms
class A{}
realm {
}
set new meta method

Usage of Realms
class A{}
realm {
}
assert new A().foo() == 1only visible in subrealm

Usage of Realms
class A{}
realm {
} // end of realm
return to parent realm

Some Explanations:
■ A Realm is a set of metaclases separated from the normal program (or parent realm)
at the point of call
■ Changes inside the Realm stay in the Realm and its subrealms
■ Exiting a Realm means to discard all changes done in the Realm
Thought Usage:
● Libraries can isolate code and protect it from outside changes
● Lexicographic Categories

And as always,
there is by far not enough time
:(

Groovy 3 and the new Groovy Meta Object Protocol in examples

Recommended

Recommended

More Related Content

Similar to Groovy 3 and the new Groovy Meta Object Protocol in examples

Similar to Groovy 3 and the new Groovy Meta Object Protocol in examples (20)

More from GR8Conf

More from GR8Conf (20)

Recently uploaded

Recently uploaded (20)

Groovy 3 and the new Groovy Meta Object Protocol in examples