Groovy Metaprogramming: Categories (I)

Groovy nos ofrece un amplio conjunto de técnicas de metaprogramación: Categories, Interceptors, metaclases, etc. A lo largo de una serie de posts analizaremos en detalle algunas de las características anteriores: comencemos por las Categories.

En muchas ocasiones es necesario que alguna clase que no está bajo nuestro control disponga de métodos adicionales. Gracias a las Categories, Groovy introduce esta funcionalidad en el lenguaje (la ha tomado prestada de Objective-C). El propio lenguaje incorpora alguna Category como DOMCategory o ServletCategory, de la cual vamos a ver algún sencillo ejemplo.

El principal objetivo de ServletCategory persigue que los atributos de objetos que implementan el Servlet API puedan ser tratados como properties dado que no siguen las convenciones establecidas por JavaBeans.

En el ejemplo de GroovyServlet visto en un post anterior (Groovlets), analizamos cómo nuestros scripts Groovy podían actuar como servlets, permitiéndonos realizar accesos mediante properties contra el objeto de la request. Para conseguir ésto, desde el código Java, se invoca a GroovyCategorySupport de un modo similar al siguiente:

Closure closure = new Closure(gse) {
   public Object call() {
       try {
           return ((GroovyScriptEngine) getDelegate()).run(scriptUri, binding);
       } catch (ResourceException e) {
           throw new RuntimeException(e);
       } catch (ScriptException e) {
           throw new RuntimeException(e);
       }
   }
};
GroovyCategorySupport.use(ServletCategory.class, closure);

Gracias al código anterior podríamos acceder mediante su nombre a diversos componentes como la session o la request:

if (session.count == null) session.count = 1;

en lugar de acceder a través del API:

if (session.getAttribute("count") == null) then session.setAttribute("count", 1);

Con este pequeño ejemplo hemos visto qué son y cómo podemos utilizar las Categories proporcionadas por el lenguaje pero . . . ¿Cuáles son los pasos a seguir si deseamos crear nuestras propias Categories?
Asentemos los conocimientos que hemos adquirido en esta entrada para generar nuestras propias construcciones en el siguiente post :).

Hasta pronto!

Groovlets

Me imagino que la gente dedicada al desarrollo web estará acostumbrada al concepto de servlet, y posiblemente, hayan escrito muchos de ellos.

Voy a mostraros una forma sencilla de escribir y configurar servlets en el lenguaje Groovy. Esta funcionalidad compilará nuestros archivos .groovy en el bytecode correspondiente, cargará la clase, y la cacheará, hasta que se produzca un cambio en el archivo groovy inicial.

El primer paso que vamos a dar es añadir el soporte para los Groovlets, para lo que necesitaremos añadir en el archivo web.xml de la aplicación web el siguiente fragmento de código:

<servlet><servlet-name>Groovy</servlet-name>

<servlet-class>groovy.servlet.GroovyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Groovy</servlet-name>
<url-pattern>*.groovy</url-pattern>
</servlet-mapping>

Ahora estamos en disposición de escribir un servlet en el lenguaje Groovy (llamemoslo hello.groovy). Veamos un ejemplo sencillito:

if (!session) {
  session = request.session(true)
}

if (!session.counter) {
      session.counter = 1
}

html.html {    // utilizamos del MarkupBuilder 
               // para construir una página tonta de respuesta
  head {
      title("Esto es un Groovy Servlet")
  }
  body {
    p("Bienvenido, ${request.remoteHost}: ${session.counter}! ${new Date()}")
  }
}


// incrementamos el contador en la sessionsession.counter = session.counter + 1

En el servlet (groovlet) anterior existen una serie de variables implícitas tales como, request, response, context, application, session, params, headers, out, sout y html.

Un paso adicional de configuración, sumamente importante, para poner nuestro groovlet en marcha, consiste en incluir las dependencias necesarias. La opción más sencilla es incluir el archivo groovy-all-XXX.jar en el directorio WEB-INF/lib de la aplicación web.

Si, por ejemplo, colocamos los archivos .groovy en el raiz de nuestra aplicación el servlet de groovy se encargará de compilar los archivos. En el caso de tomcat podríamos editar el archivo tomcat/conf/server.xml del siguiente modo:

<Context path="/groovy" docBase="c:/groovy-servlet-base"/>

Podríamos acceder al archivo creado anteriormente mediante la siguiente ur:l http://localhost:8080/groovy/hello.groovy


Hasta pronto,
Migue

Groovy Metaclass

One of my favourites Groovy´s features is its MOP architecture. It allow us introducing new methods at runtime thanks to the metaClass.

We can define a new class

class SampleClass {

// class field

def propertyOne

// one sample Closure

def closureOne = {

println "I´m the closure one"

}

}

Now we add a new method at runtime

SampleClass.metaClass.runtimeAddedMethod = {

println "I´m runtimeAddedMethod"

}

Declare a new instance an test all the methods

def instance = new SampleClass()

Call to the closure declared in class definition

instance.closureOne()

Call to the method added at runtime

instance.runtimeAddedMethod()

We add a method to the "instance" too

instance.metaClass.instanceRuntimeAddedMethod = {

println "I´m the method added at runtime to a single instance"

}

instance.instanceRuntimeAddedMethod()

Bye!!