Metaprogramming Basics

Analogy categoryAnalogies

What Is Metaprogramming?

Metaprogramming is the ability of a program to inspect or modify its own structure and behavior while it is running, rather than only at compile time. Groovy exposes this power through its Meta Object Protocol (MOP): every Groovy object implements the GroovyObject interface, which routes method calls and property access through a MetaClass that can be inspected and altered dynamically.

🏏

Cricket analogy: Metaprogramming is like a coach who can rewrite a player's technique manual mid-match based on how the bowler is performing, rather than the player being locked into a fixed, pre-season-only training plan.

methodMissing and propertyMissing

When Groovy cannot resolve a method call against any declared or inherited method, it falls back to invoking methodMissing(String name, args) if the class defines one, passing the attempted method name and arguments. The analogous propertyMissing(String name) hook fires when an undeclared property is accessed, letting a class handle arbitrary, unforeseen calls dynamically instead of failing immediately — the foundation of many Groovy DSLs and proxy objects.

🏏

Cricket analogy: Implementing methodMissing(String name, args) is like a team having a "super-sub" policy — if a scorer calls for a specialist role like spinBowl() that isn't on the fixed roster, the super-sub steps in and handles it dynamically rather than the match being abandoned.

groovy

class DynamicProxy {
    def methodMissing(String name, args) {
        println "Intercepted call to '${name}' with args: ${args.toList()}"
        return null
    }

    def propertyMissing(String name) {
        println "No such property '${name}', returning default"
        return "N/A"
    }
}

def obj = new DynamicProxy()
obj.doSomethingWeird(1, 2)      // Intercepted call to 'doSomethingWeird' with args: [1, 2]
println obj.mysteryField        // No such property 'mysteryField', returning default

// Runtime method injection via ExpandoMetaClass
String.metaClass.shout = { -> delegate.toUpperCase() + "!" }
println "hello".shout()         // HELLO!

ExpandoMetaClass and Runtime Method Injection

ExpandoMetaClass lets you inject brand-new methods or properties onto an existing class at runtime without subclassing it, even for classes you don't own — famously, even final JDK classes like String, using syntax such as String.metaClass.shout = { -> delegate.toUpperCase() + "!" }. Because this modifies the shared MetaClass, the new behavior typically becomes available to every instance of that class across the running application, not just one object.

🏏

Cricket analogy: Using String.metaClass.shout = { -> delegate.toUpperCase() + "!" } to bolt a new behavior onto every String instance is like the ICC suddenly granting every fielder on the ground the ability to review a decision, not just the designated captain — a global capability injected after the rules were originally set.

ExpandoMetaClass changes made via someClass.metaClass.newMethod = {...} are typically global for that class within the running application (or even JVM-wide for many core types), so changes made in one part of a large codebase can silently affect unrelated code elsewhere. Use scoped Categories when the change should not leak application-wide.

Scoped Metaprogramming with Categories

Groovy Categories offer a scoped alternative to global metaClass edits: you define a plain class with static methods whose first parameter is the type being extended, then activate it temporarily with use(MyCategory) { ... }. Any added behavior is only visible inside that block, which avoids the risk of one part of a large codebase silently changing behavior for unrelated code elsewhere.

🏏

Cricket analogy: Wrapping a change in a use(BattingCategory) { ... } block is like a net-practice session where a batsman is allowed to try an unconventional switch-hit technique only within that one practice session, with everything reverting to standard technique once the session ends.

Categories are typically defined as plain classes with static methods whose first parameter is the receiver type (for example, static String shout(String self)), then activated temporarily with use(MyCategory) { ... }, keeping metaprogramming changes local to that block.