Skip to end of metadata
Go to start of metadata

Groovy gives us a wide variety of choices for meta-programming. We've looked at Categories and Interceptors, which change the behavior of objects within a selected block and current thread only, in other tutorials. In this tutorial, we'll learn about more ways of meta-programming in Groovy.

Intercepting Method Calls and Property Accesses

We can add a special method called 'invokeMethod' to a class definition that executes calls to undefined methods:

If our class implements GroovyInterceptable, invokeMethod is called for all method invocations whether they exist or not:

We can get and set properties using special method names:

When there's a field of some name, refering to that name still considers it to be a property unless the syntax .@ is used:

We can call methods and access properties directly, both statically and dynamically, from within the class using various syntaxes:

If we add such 'invokeMethod', 'getProperty', or 'setProperty' methods to an object using Expando or Category syntax, they act just like normal methods. Not many supplied classes have 'invokeMethod' and such defined. For such cases, we need to use MetaClasses.


We've seen how classes behave with the default MetaClass:

We can create our own MetaClass which wraps around the existing one. DelegatingMetaClass provides the infrastructure for this, so we only need extend it with our own logic. We can do so on an instance-by-instance basis:

Or we can do so on a class-wide basis:

Classes we define ourselves return a MetaClass when accessing the metaClass property, but many Groovy-supplied classes don't. There's only one instance of a MetaClass in such cases:

When we use Groovy-supplied classes without their own MetaClass, both already-created and newly-created classes are affected by changes to the MetaClass:

Other methods besides invokeMethod are available on the MetaClass:

For example, making the constructor return an instance of something other than what we called the constructor on:


There's some easy-to-use facilities available through the MetaClass, known as ExpandoMetaClass, to which we can add properties and methods easily:

We can also add properties and constructors:

We can also add methods for supplied Groovy classes, ones we don't define ourselves:

We can override MetaClass class methods such as 'invokeMethod' and 'getProperty' using ExpandoMetaClass's easy syntax:

  • No labels