Metaprogramming and Dynamic Features

16. Metaprogramming and Dynamic Features

Groovy is well-known for its powerful metaprogramming and dynamic features, which allow you to modify and extend the behavior of classes and objects at runtime. These features enable you to write flexible and expressive code.

Dynamic Typing:

One of the key dynamic features of Groovy is its dynamic typing. In Groovy, you don't have to declare the data type of a variable explicitly; the data type is determined at runtime.

def message = "Hello, World!"
message = 42 // Legal in Groovy

In this example, 'message' starts as a string but can be assigned an integer value later because Groovy determines the data type dynamically.

Adding Methods Dynamically:

Groovy allows you to add methods to classes or objects dynamically using metaprogramming.

class Person {
    String name
}

def person = new Person(name: "Alice")

// Adding a greet() method dynamically
person.metaClass.greet = {
    "Hello, ${delegate.name}!"
}

println(person.greet()) // Output: Hello, Alice!

In this example, we add a 'greet()'method to the 'person'object dynamically, and it can access the 'name'property of the object.

Expando Objects:

Groovy provides'Expando'objects, which are dynamic objects that allow you to add properties and methods on the fly.

def person = new Expando()
person.name = "Bob"
person.sayHello = {
    "Hello, ${name}!"
}

println(person.sayHello()) // Output: Hello, Bob!

Here, we create an'Expando'object 'person' and add a'name'property and 'sayHello'method dynamically.

Method Missing and Property Missing:

Groovy introduces the'methodMissing' and 'propertyMissing'methods, which are invoked when a method or property is not found.

class MyDynamicClass {
    def propertyMissing(String name) {
        "Property '$name' is missing."
    }

    def methodMissing(String name, args) {
        "Method '$name' with arguments $args is missing."
    }
}

def dynamicObject = new MyDynamicClass()

println(dynamicObject.someProperty) // Output: Property 'someProperty' is missing.
println(dynamicObject.doSomething(42, "Groovy")) // Output: Method 'doSomething' with arguments [42, Groovy] is missing.

In this example, we define the'propertyMissing'and 'methodMissing'methods to handle missing properties and methods dynamically.

Category Methods:

Groovy allows you to add methods to existing classes using categories. Categories are a form of metaprogramming that temporarily extends the behavior of classes.

class StringUtilities {
    static String reverse(String str) {
        return str.reverse()
    }
}

use (StringUtilities) {
    def reversed = "Groovy".reverse()
    println(reversed) // Output: yvorG
}

// Outside the category, the original behavior is restored
def original = "Groovy".reverse()
println(original) // Output: yvoorG