Creando aplicaciones web con CGI::Application

En este tutorial vamos a aprender a usar el módulo CGI::Application.

El módulo CGI::Application nos brinda una estructura que nos permite escribir aplicaciones web rehúsables. Sencillamente CGI::Application proporiciona una estructura que usa todo lo que funciona de CGI y quita todo lo negativo que hoy en día se pueden encontrar en aplicaciones CGI creadas con Perl.

A través del siguiente tutorial verás que este módulo permite crear aplicaciones web que funcionan en todos lados siempre y cuando se tenga la capacidad de ejecutar Perl y CGI. Incluso, permite crear aplicaciones funcionales que podrían ser distribuidas por medio de CPAN.

Entendiendo CGI::Application

Todas las aplicaciones web consisten de diferente modos de ejecución, por ejemplo, si tuviéramos una aplicación que hace búsquedas en una base de datos, tendría un modo que desplegaría el formulario de búsqueda, otro modo donde se despliegan los resultados, otro modo donde se podrían ver los detalles de una entrada, etc. Todos estos modos de ejecución en su conjunto arman lo que sería nuestra aplicación.

Cada programador tiene una manera distinta de administrar o manejar los modos de ejecución de la aplicación. Lo más común es usar bloques de IF-ELSE para decidir que parte de la aplicación ejecutar.

Por ejemplo, para una aplicación que muestra los resultados de una base de datos, se podría seleccionar que parte ejecutar dependiendo de los parámetros enviados:

   my $query = CGI->new();

   print $query->header();

   if ( my $busqueda = $query->param('busqueda') ) {
       #Hacemos la búsqueda y la desplegamos
   }
   else{
       #Mostramos el formulario de búsqueda
   }

Este tipo de código es lo que da una mala reputación a los CGIs. Tiene una pésima estructura y cualquier cambio que se quiera hacer es sumamente complicado.

CGI::Application nos brinda una excelente solución para administrar y manejar los modos de ejecución de nuestra aplicación.

Creando las facetas de nuestra aplicación

Lenguajes como ASP, Cold Fusion y JSP intentan administrar estos modos de ejecución teniendo un archivo distinto por cada modo de la aplicación. Esto crea la desventaja de que terminas teniendo tantos archivos en tu aplicación como modos de ejecución. Al hacer esto, sacas de contexto los modos al independizar cada parte, pues al final de todo, estos modos de ejecución son parte de la misma aplicación.

CGI::Application ataca el problema desde otro punto de vista al brindar dos funciones básicas.

En primer lugar, CGI::Application designa un único campo de HTML como el "Mode Parameter" (parámetro de Modo). Este Mode Parameter es usado para almacenar el modo de ejecución actual de tu aplicación, cuyo valor es una simple cadena de texto. El Mode Parameter funciona como un policía de tráfico, dirigiendo la ejecución de la aplicación correctamente.

La segunda función, es que CGI::Application asocia cada modo de ejecución como una subrutina de Perl. Cada subrutina, llamada como "Método de Ejecución", contiene la manera en que la aplicación se comporta en cada modo de ejecución. Todos los Métodos de Ejecución se encuentran en un mismo módulo de Perl, al que llamaremos Módulo de la Aplicación.

Tu Módulo de la Aplicación es una subclase de CGI::Application. De hecho, CGI::Application no fue creado para usarse directamente.

Nuestra primera aplicación

Vamos a crear una pequeña aplicación que va a constar de tres modos de ejecución, en el primero mostraremos el formulario de búsqueda, en el segundo mostrará los resultados y en la tercera mostraremos los detalles de cada elemento.

Empecemos creando un nuevo archivo .pm para crear nuestro Módulo de la Aplicación al que llamaremos: "MiPrimeraAplicacion".

En al primera línea vamos a identificar a nuestro módulo:


    package MiPrimeraAplicacion;

Después de ello usaremos la función base que nos permite cargar un módulo pero heredando todas sus funciones. En esta caso el módulo del cual queremos heredar es CGI::Application.


    use base qw( CGI::Application );

El siguiente paso es hacer la inicialización de nuestra aplicación. La inicialización consiste en crear el mapa de nuestra aplicación. El mapa será usado para unir cada modo de ejecución con la subrutina correspondiente.

Piensa en este mapa como la lista definitiva de cosas que tu aplicación puede hacer. Si más adelante quieres agregar más funcionalidades, todo lo que tendrías que hacer es meter una nueva entrada en tu mapa.

Para hacer la inicialización tenemos que crear una función setup():


    sub setup {

    }

Debido a que el módulo CGI::Application está orientado a objetos, entonces nuestro módulo también creará un objeto. Hagamos el setup() de nuestra aplicación de ejemplo:


    sub setup {

        my $self = shift;

        $self->run_modes(
            'modo_1' => 'mostrar_formulario',
            'modo_2' => 'mostrar_resultados',
            'modo_3' => 'mostrar_detalles'
        ); 

        $self->start_mode('modo_1');

        $self->mode_param('accion');

    }

Expliquemos un poco lo que acabamos de hacer. Primero asignamos a la variable $self una instancia de nuestra clase de la aplicación. Después llamamos al método run_modes() que se encarga de crear el mapa. El método recibe un %hash en donde las llaves son el nombre de nuestro modo de ejecución, y el valor es el nombre de la función que queremos llamar en ese modo de ejecución.

Después debemos de asignar nuestro modo de ejecución default, en nuestro caso será el "modo_1" pues queremos mostrar de entrada el formulario de búsqueda.

Finalmente con el método mode_param() asignamos el nombre del Mode Parameter, es decir, ese campo del formulario HTML que nos dice que modo de ejecución es la que se debe de ejecutar. En este caso la llamaremos 'accion'.

Los modos de ejecución

Ahora debemos de crear las subrutinas de los modos de ejecución. Recuerda que cada modo de ejecución está asignado a su subrutina la cual identificamos al crear el mapa.

Las subrutinas de cada modo de ejecución se crean igual que cualquier otra subrutina. Al ser llamada se le envía como primer parámetro una referencia al objeto de la aplicación, y las subrutinas deben de regresar el "output" que queremos desplegar.

Es muy importante que nunca imprimas nada en el STDOUT en tus subrutinas, pues el módulo CGI::Application se encarga de hacer esto con los encabezados adecuados.

En tu aplicación siempre será necesario tener interacción entre los datos enviados por medio de GET o POST a tu CGI. CGI::Application no intenta hacer esto, en su lugar, usa el gran módulo CGI.pm para toda interacción con los querys de tu CGI.

Al llamar el método query() de CGI::Application el módulo te regresará un objeto de tipo CGI.pm que podrás ya usar con normalidad.

Ahora vamos a crear nuestra primer subrutina para el método de ejecución "modo_1. La subrutina la vamos a llamar mostrar_formulario().


    sub mostrar_formulario {

          my $self = shift;

          # Obtener el objeto CGI.pm
          my $q = $self->query();

          $output .= $q->start_html(-title => "Formulario de Búsqueda");
          $output .= $q->start_form();


          $output .= "Buscar en el database: ";
          $output .= $q->textfield(-name => 'database');
          $output .= $q->submit();

          # Ponemos la llamada al siguiente modo de ejecución
          $output .= $q->hidden(-name => 'accion', -value => 'modo_2');
          $output .= $q->end_form();
          $output .= $q->end_html();

          return $output;


    }

Como podrás ver la subrutina es bastante clara. La subrutina del modo de ejecución es llamada en un contexto orientado a objetos ($self). Obtenemos un objeto CGI.pm por medio del método query() de nuestro Módulo de la Aplicación heredado desde el módulo CGI::Application.

En este caso, usamos el mismo objeto de CGI.pm para crear el formulario, pero básicamente lo puedes hacer como quieras, siempre y cuando regreses el resultado usando return(). Recuerda que NO debes de imprimir nada al STDOUT.

Como ves todo es bastante sencillo, quizá lo más "complicado" es que siempre debemos recordar poner un campo "accion" (en este caso es así porque así decidimos llamar a nuestro Mode Parameter) cuyo valor será el modo de ejecución que queremos ejecutar. En este caso como el responsable de mostrar los resultados de la búsqueda es el "modo_2", entonces tenemos que poner ese valor para que se llame a la función mostrar_resultados().

Veamos ahora un ejemplo de como sería nuestra subrutina mostrar_resultados().


    sub mostrar_resultados {

          my $self = shift;

          # Obtener el objeto CGI.pm
          my $q = $self->query();

          # Creamos un hash con todos los parámetros recibidos
          my %Input = $q->Vars;


          my $output = "";
          # Hacemos la búsqueda
          # por ejemplo seleccionar de un database todas las
          # entradas que tengan la palabra puesta por
          # el usuario en $Input{'busqueda'}


          return $output;

    }

Bastante sencilla ¿no?. Ahora cuando mostramos los resultados podremos poner a cada resultado un link parecido al siguiente: 'miaplicacion.cgi?accion=modo_3&id_entrada=232562'.

Así el usuario podrá ver más detalles de cada entrada, recuerda que el modo_3 llama a la función mostrar_detalles() que se encargará de desplegar los detalles de la entrada, quizá buscando por el id enviado en el parámetro 'id_entrada':


    sub mostrar_detalles {

          my $self = shift;

          # Obtener el objeto CGI.pm
          my $q = $self->query();

          # Creamos un hash con todos los parámetros recibidos
          my %Input = $q->Vars;


          my $output = "";
          # Buscamos los detalles de la entrada con id $Input{'id_entrada'}


          return $output;

    }

Los encabezados de HTTP

Por default el módulo CGI::Application imprimirá todo el contenido con el MIME-Type "text/html". Si deseas usar otro MIME-Type, manipular algún cookie, o crear alguna redirección de HTTP, entonces deberás de cambiar los encabezados de HTTP.

Esto lo puedes hacer usando el método heredado header_type() y header_props(). Checa la documentación de CGI::Application para sus detalles.

Nuestro Script CGI

Listo, ya tenemos nuestro Módulo de la Aplicación listo, pero ahora tenemos que hacer el script CGI. Nuestro script CGI será el encargado de ejecutar nuestra aplicación.

En la programación tradicional de CGI, tendríamos un archivo llamado por ejemplo, miaplicacion.cgi que será ejecutado por nuestro servidor y mostrado el resultado. Normalmente este script sería muy grande pues contendría todo el código necesario para ejecutar la aplicación, pero usando CGI::Application todo el código está en nuestro Módulo de la Aplicación.

De esta manera nuestro script CGI estaría realmente vacío, pues de lo único que se encargaría es de cargar un nuevo objeto de MiPrimeraAplicación y listo. Así que vamos a crear un archivo CGI al que vamos a llamar miaplicacion.cgi:


    #!/usr/bin/perl -w

    use strict;
    use MiPrimeraAplicacion;


    my $app = MiPrimeraAplicacion->new();
       $app->run();

Realmente sencillo. Cargamos nuestro objeto MiPrimeraAplicacion y lo ejecutamos.

En nuestra aplicación de prototipo MiPrimeraAplicacion vimos todos los elementos esenciales de una aplicación hecha con CGI::Application.

Nuestro Módulo de la Aplicación lo podemos poner en cualquier lugar de nuestro servidor, siempre y cuando pueda ser accesado por perl y nuestro CGI. Lo más recomendado es que lo pongas en un directorio que no pueda ser accesado por el servidor web.

Conclusiones y Conceptos Avanzados

En este tutorial vimos las bases para que puedas empezar a crear tus aplicaciones usando el excelente módulo CGI::Application. Sin embargo, el módulo nos ofrecer características más avanzadas que podrás aprovechar.

Reutilización del código

Uno de los puntos fuertes que tiene el crear tus aplicaciones cgi con CGI::Application, es que toda la funcionalidad de tu aplicación lo pones dentro de un módulo, siguiendo su estructura y sy lógica. Esto te permite rehusar código de manera sencilla.

En este tutorial no vimos el método cgiapp_init() que te permite inicializar el objeto de tu aplicación con unos parámetros iniciales, así podrías por ejemplo, permitir que ciertas partes de tu aplicación sean accesadas, o que otras se comporten de diferente manera dependiendo de como cargues el objeto desde tu script CGI.

En fin, las posibilidades son tantas como se te ocurran, lo importante es que sigas los linamientos de CGI::Application, y te encontrarás haciendo aplicaciones CGI fáciles de mantener y con excelente portabilidad.

Usando HTML::Template

En todo tipo de aplicación la separación entre lo que cambia y lo que nunca cambia es totalmente importante. Usando templates tenemos la capacidad de separar el diseño del código.

El módulo CGI::Application viene con una sencilla manera de integrar el módulo HTML::Template a nuestra aplicación por medio de los métodos tmpl_path() y load_tmpl(). Para más detalles acerca de ellas, checa la documentación de CGI::Application.

Otros Recursos

El tutorial lo basé en el artículo 'Using CGI::Application' de Jesse Erlbaum que lo puedes encontrar en:
http://www.perl.com/pub/a/2001/06/05/cgi.html

Documentación de CGI::Application
http://search.cpan.org/search?query=CGI%3A%3AApplication&mode=all

Documentación de CGI.pm
http://search.cpan.org/search?query=CGI&mode=all

Como usar el módulo HTML::Template
Usando HTML::Template