El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Metaprogramación

Siguiente ►
►

La metaprogramación es una característica poderosa de Groovy que permite a los desarrolladores escribir código que puede modificar, generar o manipular otros fragmentos de código en tiempo de ejecución. Esto puede ser extremadamente útil para crear DSLs (Domain-Specific Languages), simplificar tareas repetitivas y aumentar la flexibilidad del código.

Conceptos Clave de la Metaprogramación

  1. MetaClass: Cada clase en Groovy tiene una MetaClass asociada que permite modificar su comportamiento en tiempo de ejecución.
  2. ExpandoMetaClass: Una versión extendida de MetaClass que facilita la adición de métodos y propiedades dinámicamente.
  3. Method Missing: Permite interceptar llamadas a métodos que no existen.
  4. Property Missing: Permite interceptar accesos a propiedades que no existen.
  5. Category: Permite añadir métodos a clases existentes de manera temporal.

Ejemplos Prácticos

  1. Modificación de MetaClass

Podemos añadir métodos a una clase existente utilizando MetaClass.

class Person {
    String name
}

Person.metaClass.sayHello = { -> "Hello, my name is $name" }

def p = new Person(name: 'John')
println p.sayHello()  // Output: Hello, my name is John

Explicación:

  • Creamos una clase Person con una propiedad name.
  • Usamos metaClass para añadir un método sayHello a la clase Person.
  • Creamos una instancia de Person y llamamos al nuevo método sayHello.

  1. Uso de ExpandoMetaClass

ExpandoMetaClass permite una mayor flexibilidad al modificar clases.

ExpandoMetaClass.enableGlobally()

class Car {
    String model
}

Car.metaClass.startEngine = { -> "Engine started for $model" }

def car = new Car(model: 'Tesla')
println car.startEngine()  // Output: Engine started for Tesla

Explicación:

  • Habilitamos ExpandoMetaClass globalmente.
  • Añadimos un método startEngine a la clase Car.
  • Creamos una instancia de Car y llamamos al método startEngine.

  1. Method Missing

Interceptar llamadas a métodos que no existen.

class DynamicMethods {
    def methodMissing(String name, def args) {
        return "Method $name called with arguments $args"
    }
}

def dm = new DynamicMethods()
println dm.someMethod(1, 2, 3)  // Output: Method someMethod called with arguments [1, 2, 3]

Explicación:

  • Definimos una clase DynamicMethods con un método methodMissing.
  • methodMissing intercepta cualquier llamada a métodos no definidos y devuelve un mensaje.

  1. Property Missing

Interceptar accesos a propiedades que no existen.

class DynamicProperties {
    def propertyMissing(String name) {
        return "Property $name does not exist"
    }
}

def dp = new DynamicProperties()
println dp.someProperty  // Output: Property someProperty does not exist

Explicación:

  • Definimos una clase DynamicProperties con un método propertyMissing.
  • propertyMissing intercepta cualquier acceso a propiedades no definidas y devuelve un mensaje.

  1. Uso de Category

Añadir métodos a clases existentes de manera temporal.

class StringCategory {
    static String shout(String str) {
        return str.toUpperCase() + "!!!"
    }
}

use(StringCategory) {
    println "hello".shout()  // Output: HELLO!!!
}

Explicación:

  • Definimos una categoría StringCategory con un método shout.
  • Usamos la categoría temporalmente con use para añadir el método shout a la clase String.

Ejercicios Prácticos

Ejercicio 1: Añadir Métodos Dinámicamente

Instrucciones:

  1. Crea una clase Book con una propiedad title.
  2. Usa MetaClass para añadir un método getTitleLength que devuelva la longitud del título.

Solución:

class Book {
    String title
}

Book.metaClass.getTitleLength = { -> title.length() }

def book = new Book(title: 'Groovy Programming')
println book.getTitleLength()  // Output: 18

Ejercicio 2: Interceptar Métodos Faltantes

Instrucciones:

  1. Crea una clase Calculator.
  2. Implementa methodMissing para manejar métodos de operaciones matemáticas básicas (add, subtract, multiply, divide).

Solución:

class Calculator {
    def methodMissing(String name, def args) {
        switch (name) {
            case 'add':
                return args[0] + args[1]
            case 'subtract':
                return args[0] - args[1]
            case 'multiply':
                return args[0] * args[1]
            case 'divide':
                return args[0] / args[1]
            default:
                throw new MissingMethodException(name, Calculator, args)
        }
    }
}

def calc = new Calculator()
println calc.add(5, 3)       // Output: 8
println calc.subtract(5, 3)  // Output: 2
println calc.multiply(5, 3)  // Output: 15
println calc.divide(6, 3)    // Output: 2

Conclusión

La metaprogramación en Groovy es una herramienta poderosa que permite a los desarrolladores modificar y extender el comportamiento de las clases en tiempo de ejecución. Con MetaClass, ExpandoMetaClass, methodMissing, propertyMissing y Category, puedes crear soluciones flexibles y dinámicas que simplifican el desarrollo y mantenimiento del código. Asegúrate de practicar estos conceptos con los ejercicios proporcionados para consolidar tu comprensión.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados