Groovy 元编程：metaClass 与 ExpandoMetaClass

Groovy 的元编程能力是其最强大的特性之一。它允许你在运行时动态地修改类的行为，添加新的方法或属性，甚至改变现有方法的功能。这种能力让代码变得更加灵活和强大。本文将详细介绍 metaClass 和 ExpandoMetaClass 这两个核心概念，帮助你掌握 Groovy 元编程的精髓。

一、什么是 Groovy 元编程

元编程（Metaprogramming）是指程序在运行时能够操作自身或修改自身行为的能力。Groovy 作为运行在 JVM 上的动态语言，天然具备这一能力。

在 Groovy 中，每一个类都有一个与之关联的 metaClass 对象。这个 metaClass 包含了该类所有方法的描述信息。通过操作 metaClass，你可以在不修改原始类代码的情况下，动态地为类添加新的方法或属性。这种机制在以下场景中特别有用：

• 为第三方类库添加实用方法，而无需继承
• 在运行时动态改变类的行为
• 实现 AOP（面向切面编程）
• 构建 DSL（领域特定语言）

二、使用 metaClass 动态添加方法

2.1 基本语法

在 Groovy 中，你可以直接通过 metaClass 属性为类添加方法。以下代码展示了最基础的用法：

// 为 String 类添加一个 reverseWords 方法
String.metaClass.reverseWords = {
    delegate.split(' ').reverse().join(' ')
}

def text = "Hello Groovy World"
println text.reverseWords()  // 输出：World Groovy Hello

这段代码中，String.metaClass.reverseWords 在 String 类的 metaClass 中注册了一个新的闭包作为方法。当调用 reverseWords() 时，Groovy 会在 metaClass 中查找该方法并执行。

2.2 添加带参数的方法

你还可以为类添加带有参数的方法，这在处理数据转换或验证时非常方便：

// 为 Integer 类添加阶乘方法
Integer.metaClass.factorial = { n ->
    if (n < 0) throw new IllegalArgumentException("负数没有阶乘")
    if (n == 0 || n == 1) return 1
    (1..n).inject(1) { acc, i -> acc * i }
}

println 5.factorial(5)  // 输出：120

注意，delegate 在闭包中代表方法的调用者对象。当你使用 delegate.split(' ') 时，delegate 就是调用 reverseWords 方法的那个字符串实例。

2.3 添加实例方法与静态方法

元编程不仅可以为实例添加方法，还可以添加静态方法：

// 为 Date 类添加静态工厂方法
Date.metaClass.static.now = { ->
    new Date()
}

def current = Date.now()  // 创建当前时间的 Date 对象
println current

添加静态方法时，需要使用 static 关键字修饰方法名。Groovy 的 metaClass 会识别这个关键字并将方法注册到类的静态方法表中。

三、ExpandoMetaClass 的高级用法

ExpandoMetaClass 是 Groovy 提供的更加强大的元编程工具。标准 metaClass 适合简单的动态方法添加，而 ExpandoMetaClass 支持更复杂的场景，包括方法拦截、构造器定义以及继承链修改。

3.1 使用 ExpandoMetaClass

启用 ExpandoMetaClass 需要先启用相应的编译配置：

// 启用 ExpandoMetaClass
ExpandoMetaClass.enableGlobally()

// 为一个类添加方法
String.metaClass {
    capitalize = { 
        delegate.charAt(0).toString().toUpperCase() + delegate.substring(1) 
    }
    isPalindrome = {
        def rev = delegate.reverse()
        delegate == rev
    }
}

使用闭包语法可以同时添加多个方法，使代码更加简洁。这种方式在需要为一个类批量添加方法时特别有用。

3.2 方法拦截与代理

ExpandoMetaClass 最强大的功能之一是方法拦截。你可以在方法执行前后插入自定义逻辑：

// 拦截 String 的 size 方法
String.metaClass.size = {
    println "调用 size 方法，参数是：${delegate}"
    def result = delegate.length()
    println "size 方法返回：${result}"
    return result
}

def str = "hello"
println "字符串长度：${str.size()}"
```

输出结果如下：

```
调用 size 方法，参数是：hello
size 方法返回：5
字符串长度：5
```

你还可以使用 `replace` 方法完全替换原有方法的实现：

```groovy
// 完全替换 Integer 的加法操作
Integer.metaClass.plus = { Integer operand ->
    // 将加法替换为乘法
    delegate * operand
}

println 3 + 4  // 输出：12，而不是 7
```

这种替换能力在测试或模拟场景中非常有用，可以临时改变类的行为而不影响原始代码。

### 3.3 添加属性

除了方法，`ExpandoMetaClass` 还可以动态添加属性：

```groovy
class Person {
    String name
}

Person.metaClass.nickname = "Default"

// 创建实例并访问新属性
def p = new Person(name: "Alice")
println p.nickname  // 输出：Default

// 修改属性值
p.nickname = "Ali"
println p.nickname  // 输出：Ali
```

动态添加的属性与普通属性一样，具有 getter 和 setter 方法。你可以在运行时为任何对象添加属性，这为数据模型的扩展提供了极大的灵活性。

---

## 四、实际应用场景

### 4.1 为 JDK 类添加实用方法

在实际项目中，经常需要为 JDK 原有类添加一些实用方法：

```groovy
// 为 InputStream 添加一次性读取方法
InputStream.metaClass.readFully = { Charset charset = StandardCharsets.UTF_8 ->
    def buffer = new ByteArrayOutputStream()
    def byteArray = new byte[1024]
    int len
    while ((len = delegate.read(byteArray)) != -1) {
        buffer.write(byteArray, 0, len)
    }
    buffer.toString(charset)
}

// 使用示例
def stream = new ByteArrayInputStream("Hello, Groovy!".bytes)
println stream.readFully()
```

### 4.2 实现简单的 AOP

方法拦截功能可以用于实现简单的日志切面：

```groovy
// 为所有 Service 类的方法添加调用日志
Object.metaClass.invokeMethod = { String name, Object args ->
    println "调用方法：${name}，参数：${Arrays.toString(args)}"
    def result = delegate.metaClass.getMetaMethod(name, *args)?.invoke(delegate, *args)
    println "方法 ${name} 返回：${result}"
    return result
}

class UserService {
    def getUser(id) {
        return "User_${id}"
    }
}

def service = new UserService()
service.getUser(123)

4.3 构建领域特定语言（DSL）

元编程是构建 DSL 的基础。以下是一个简单的 Builder 模式实现：

class HtmlBuilder {
    StringBuilder sb = new StringBuilder()

    def html(Closure closure) {
        sb.append("<html>")
        closure.delegate = this
        closure()
        sb.append("</html>")
        return sb.toString()
    }

    def head(Closure closure) {
        sb.append("<head>")
        closure()
        sb.append("</head>")
    }

    def body(Closure closure) {
        sb.append("<body>")
        closure()
        sb.append("body>")
    }

    def title(String text) {
        sb.append("<title>${text}</title>")
    }
    
    def p(String text) {
        sb.append("<p>${text}</p>")
    }
}

def builder = new HtmlBuilder()
def html = builder.html {
    head { title "我的页面" }
    body { 
        p "欢迎使用 Groovy DSL" 
    }
}

五、注意事项与最佳实践

使用元编程时需要注意以下几点：

命名冲突风险。动态添加的方法可能与类的原有方法或后续添加的方法产生冲突。建议使用独特的前缀或遵循项目约定来命名动态方法，避免意外覆盖重要方法。

性能影响。每次方法调用都会经过 metaClass 的查找过程，这会带来一定的性能开销。对于性能敏感的场景，需要评估元编程的使用是否必要，或者使用缓存策略来优化。

调试困难。动态修改的行为会增加代码的可读性和可调试性难度。确保为动态方法添加充分的文档注释，在团队中建立清晰的使用规范。

内存管理。大量使用 metaClass 可能会导致类加载器问题。确保在使用完毕后适当清理动态添加的方法，特别是在长时间运行的应用中。

六、总结

metaClass 和 ExpandoMetaClass 是 Groovy 元编程的两大核心工具。metaClass 提供了基础的动态方法添加能力，适合简单的场景；而 ExpandoMetaClass 提供了更强大的功能，包括方法拦截、批量定义和静态方法支持。掌握这两个工具的使用，能够让你的 Groovy 代码更加灵活和强大。