La Gaceta de Linux ...¡ haciendo a Linux un poco más divertido !

Un vistazo a Jython

Por Rob Tougher

Traducción al español por José Gregorio del Sol Cobos
el día 20 de Abril de 2004, para La Gaceta de Linux

Este artículo analiza Jython, un proyecto de software que intenta proporcionar integración sólida entre Java y Python. Este artículo requiere una comprensión básica de ambos lenguajes.

Introducción

Hay muchos lenguajes de programación diferentes. The Language List, una completa base de datos de lenguajes de ordenador, pone un número de unos 2500. Tener diferentes lenguajes es ventajoso para los desarrolladores - cada lenguaje tiene características que son particularmente apropiadas para ciertos tipos de problemas. Por ejemplo, cuando estoy transformando XML, XSLT es mi herramienta elegida (éste es un método popular de implementar HTML para sitios web dinámicos). Al programar aplicaciones en el lado del servidor, prefiero lenguajes como Java, C++ y Python. Creo que en principal consejo para los programadores es "emplea la herramienta correcta para la tarea".

Una desventaja notable de la abundancia de lenguajes es la incapacidad (o dificultad extrema) de reutilizar código escrito en un lenguaje con otro lenguaje. Por ejemplo, suponga que tenía escrita una librería de bases de datos en Java, y que quisiera reutilizarla en Python. Podría escribir una capa de pegamento, empleando una tecnología como COM, CORBA, puertos o SOAP, pero la capa consumiría tiempo para hacerla. Estaría bien si esta capa de pegamento ya existiera, preparada para consumirse con poco o ningún esfuerzo gastado.<7p>

Entre en Jython. El objetivo del proyecto Jython es proporcionar integración sin costuras entre Java y Python. El proyecto contiene dos herramientas principales:

Este artículo proporciona una introducción básica a Jython. Primero describiré la instalación, seguido hablaré sobre el intérprete jython, y terminaré con una discusión sobre el compilador jythonc. Utilizaré los siguientes convenios de nombres cuando me refiera a los diferentes intérpretes, compiladores y proyectos:

Instalación

Para usar Jython en sus sistema necesita dos piezas de software: el Java SDK, y la distribución Jython.

Puede obtener el último Java SDK para Linux (1.4.2) en el sitio principal de Java. Sun distribuye el SDK como un solo archivo binario que puede descargar y ejecutar sobre su máquina Linux. Después de que se complete la instalación, el paso que queda es crear una variable de entorno como parte del archivo /.bashrc de la carpeta raíz del usuario: 

#
# Para el sdk 1.4.2
#

export JAVA_HOME=~/apps/j2sdk1.4.2_01
export PATH=~/apps/j2sdk1.4.2_01/bin:$PATH

Observe que también establezco la variable de entorno PATH - lo hago para que pueda acceder a las herramientas de Java de la línea de comandos (java, javac, jar, etc.) desde cualquier directorio.

La última entrega de Jython (2.1) se distribuye desde el sitio principal de Jython. El proyecto Jython proporciona un instalador gráfico escrito en Java y empaquetado como una solo archivo *.class de Java. Cuando uno ejecuta el instalador se le presenta un asistente gráfico de instalación, que te pide especificar el tipo de instalación, aceptar los términos de la licencia, y decir el directorio destino de la instalación. Cuando ésta termina, uno ya está listo para emplear Jython en su máquina. Es útil actualizar las variables PATH y CLASSPATH para que apunten a la recién instalada distribución de Jython. Yo lo hago así en mi archivo ~/.bashrc:

#
# Para Jython
#

export JYTHON_HOME=~/jython-2.1/
export PATH=$JYTHON_HOME:$PATH
export CLASSPATH=$JYTHON_HOME/jython.jar:$CLASSPATH

Para comprobar que la instalación tuvo éxito, escriba "jython" en la línea de comandos:

prompt$ jython
Jython 2.1 on java1.4.2_01 (JIT: null)
Type "copyright", "credits" or "license" for more information.
>>>

Si ve lo de arriba, ha instalado Jython con éxito.

Usando el intérprete de Jython

El intérprete jython es un intérprete de Python implementado al 100 % en Java. Le permite escribir código Python que acceda a las clases de Java.

La última versión estable de jython, entregada en diciembre de 2001, implementa las características de Python 2.1. Sin embargo, Python ya ha alcanzado la versión 2.3. Esto significa que las características de Python únicas a las versiones 2.2 y 2.3 no están disponibles en la actual versión estable de Jython:

Una versión alfa de jython, disponible para descargar en el sitio de Jython, implementa una mezcla de Python 2.1 y 2.2 El grupo Jython determina esta versión alfa como una entrega experimental e inestable que contiene cosas conocidas significantes. En otras palabras, use la versión alfa por su cuenta y riesgo

Además de la falta de las características recientes de Python, jython también carece de algunos módulos de Python en las librerías de su implementación. Por encima de esto, hay poca documentación que describa qué módulos se soportan y cuáles no. Si quiere saber si un módulo está soportado, las FAQ sugieren intentar importar el módulo en cuestión. Si la importación falla, puede intentar copiar sobre el correspondiente módulo *.py de la implementación de CPython. Como último recurso, puede pedir ayuda en las listas de correo públicas.

Mientras que el soporte Python den jython está restringido a la versión 2.1, el soporte Java está completamente actualizado. Puede utilizar cualquier código Java desde el intérprete jython. Esto incluye las librerías 1.4.2 estándares, las escritas por terceros, y sus propias librerías.

Por ejemplo, podría usar el Abstract Window Toolkit de Java (AWT). El AWT es una librería de ventanas que proporciona contenedores para la creación de interfaces (ventanas, botones, áreas de texto, etc.) Usted podría escribir código Python que accediese al AWT, y luego correr ese código usando el intérprete jython.

He aquí un ejemplo de usar la funcionalidad de AWT con Python:

#
# file: AWTTest.jy
#

#
# Importar las clases AWT.
#

from java.awt import Frame
from java.awt import Panel
from java.awt import Button
from java.awt import TextArea
from java.awt.event import ActionListener


#
# Definir la clase TestButtonAction. TestButtonAction
# hereda desde la interfaz Java ActionListener.
#

class TestButtonAction(ActionListener):

        def actionPerformed(self, e):
                textArea.append("Test Button Clicked!\n")


#
# Crear los objetos Marco (Frame), Panel, Botón (Button),
# TextArea y TestButtonAction.
#

frame = Frame("Hello World")
panel = Panel() 
button = Button("Test Button")
buttonAction = TestButtonAction()
textArea = TextArea()


#
# Juntarlo todo y mostrar
# la ventana.
#

button.addActionListener(buttonAction)
panel.add(button)
panel.add(textArea)
frame.add(panel)
frame.pack()
frame.show()

Puede ejecutar esto usando el intérprete jython:

prompt$ jython AWTTest.jy

Ejecutar este código produciría una ventana parecida a la sifuiente:

[screenshot]

El ejemplo crea una ventana y le añade un botón y un área de texto. Cuando aprieta el botón, el texto "Text Button Clicked!" (¡Botón de Texto Apretado!) se anexa a los contenidos del área de texto. El ejemplo muestra unas cuantas características claves de Jython:

Usando el compilador Jythonc

La segunda herramienta que Jython proporciona es jythonc. jythonc compila el código fuente Python a bytecode de Java. Éste se puede ejecutar usando una Máquina Virtual de Java normal.

(El bytecode de java es el lenguaje intermediario que ejecuta la Máquina Virtual de Java. Cuando compilas un archivo fuente de java con javac, la salida de la compilación es un fichero con extensión .class. Éste contiene bytecode de java, que uno puede ejecutar usando la Máquina Virtual de java. Para más información sobre el bytecode y la JVM, eche un vistazo a The Java Virtual Machine Specification ("Especificación de la Máquina Virtual de Java))

jythonc sufre el mismo mal que el intérprete jython en cuanto a las características - la última entrega de jythonc implementa características de Python 2.1. Más aún, la versión alfa de Jython contiene un compilador jythonc que básicamente no ha cambiado desde la última entrega. Parece como si jythonc fuese a estar pegado a la versión 2.1 durante un tiempo.

Al compilar una clase de Python con jythonc, uno necesita proporcionar información extra sobre cada método accesible públicamente en su clase. Esta información incluye el tipo de devolución, los argumentos, los tipos de los argumentos, la cláusula "throws" y la declaración de control de acceso ("private", "public" o "protected"). Esta información se puede proporcionar de dos maneras:

Por ejemplo, usted podría escribir un servlet de Java en Python (los servlets son clases de Java que se ejecutan dentro de contenedores de servlets, como Tomcat y Jetty, y responden a las peticiones de las páginas web). Usted podría crear una clase Python que derivase de HttpServletRequest, compilarla con el compilador jythonc, y ejecutar el bytecode dentro de un contenedor de servlets.

El siguiente es un servlet sencillo escrito en Python:

#
# archivo HelloWorldFromJython.py
#

import os
from javax.servlet.http import HttpServlet


class HelloWorldFromJython(HttpServlet):

        def service(self, request, response):

                response.setContentType("text/html")
                out = response.getOutputStream()
                print >>out, """<html>
                                <head>
                                        <title>Hello World Servlet</title>
                                </head>
                                <body>
                                        <p>Hello World From Jython!</p>
                                        <p>os.getcwd() == """ + str(os.getcwd()) + """</p>
                                </body>
                                </html>"""

Puede ejecutar este ejemplo usando Tomcat. La instalación de Tomcat es directa - sólo requiere descargar la distribución y extraerla a su disco duro. Debería crear una variable de entorno llamada TOMCAT_HOME y establecer su valor al directorio raíz de Tomcat:

#
# Para Tomcat.
#

export TOMCAT_HOME=~/apps/jakarta-tomcat-4.1.27/

El siguiente paso es compilar el servlet de Python con el compilador jythonc (observe que la variable de entorno CLASSPATH necesita ser actualizada para incluir el archivo servlet.jar):

prompt$ export CLASSPATH=$TOMCAT_HOME/common/lib/servlet.jar:$CLASSPATH
prompt$ jythonc --deep HelloWorldFromJython.py

processing HelloWorldFromJython
processing javaos
processing string
processing UserDict
processing copy
processing repr
processing javapath
processing re
processing sre
processing sre_constants
processing sre_compile
processing copy_reg
processing sre_parse

Required packages:
  java.lang
  org.python.core
  java.io
  javax.servlet.http

Creating adapters:

Creating .java files:
  sre_constants module
  javaos module
  sre module
  javapath module
  re module
  string module
  sre_compile module
  copy_reg module
  HelloWorldFromJython module
    HelloWorldFromJython extends javax.servlet.http.HttpServlet
  UserDict module
  sre_parse module
  repr module
  copy module

Compiling .java to .class...

[snip]

El compilador jythonc crea un directorio llamado "jpywork" en su directorio actual. Este directorio contiene el archivo .class de salida de la compilación de jythonc, junto con los archivos de soporte.

El siguiente paso es desplegar los archivos binarios .class al directorio de las aplicaciones web del servidor. Normalmente usted crearía una nueva aplicación web para sus servlets, pero para este ejemplo puede usar la aplicación web "examples" que viene con Tomcat. Cree un nuevo directorio dentro de esa aplicación web y copie allí los archivos de clase:

prompt$ mkdir $TOMCAT_HOME/webapps/examples/WEB-INF/classes/HelloWorldFromJython
prompt$ cp jpywork/*.class $TOMCAT_HOME/webapps/examples/WEB-INF/classes/HelloFromJython/

Ahora que el servlet Python ha sido compilado y desplegado en el servidor Tomcat, y que el archivo jythonc.jar se ha incluido en el directorio lib, puede ejecutar el servidor Tomcat:

prompt$ $TOMCAT_HOME/bin/startup.sh

Using CATALINA_BASE:   /home/robt/apps/jakarta-tomcat-4.1.27
Using CATALINA_HOME:   /home/robt/apps/jakarta-tomcat-4.1.27
Using CATALINA_TMPDIR: /home/robt/apps/jakarta-tomcat-4.1.27/temp
Using JAVA_HOME:       /home/robt/apps/j2sdk1.4.2_01

Debería poder acceder a su servlet Python usando la siguiente URL:

El servlet producirá una salida similar a lo siguiente:

prompt$ wget http://yourmachine:8080/examples/servlet/HelloWorldFromJython/HelloW
orldFromJython

prompt$ cat HelloWorldFromJython

<html>
        <head>
                <title>Hello World Servlet</title>
        </head>
        <body>
                <p>Hello World From Jython!</p>
                <p>os.getcwd() == /home/robt/apps/jakarta-tomcat-4.1.27/bin</p>
        </body>
</html>

Conclusión

Este artículo servía como una introducción al proyecto Jython. Para más información sobre los subproyectos presentados en este artículo, prueba los siguientes enlaces:

 

[BIO PEN]Rob es un desarrollador de software en el área de Nueva York

Copyright © 2003, Rob Tougher. Licencia de copia http://linuxgazette.net/copying.html

Publicado en el Número 97 de Linux Gazette, Diciembre de 2003