Jython: Python sobre la JVM Luis Alberto Pérez Septiembre de 2011

Introducción ● ¿Qué es Jython? ● Estado: Jython (March 3, 2011) ● Algunos proyectos: ● drools ● django-jython ● the grinder ●...

Jython!! filestoread = ["/tmp/foo.txt", "/tmp/bar.txt"] for fname in filestoread: f = open(fname, 'w') f.write("una linea\n") f.write("otra linea\n") f.close() f = open(fname,'r') print("lineas de %s: %s" % (fname, f.readlines())) f.close()

Diferencias entre CPython y Jython ● Cpython ● Escrito en C ● Compila a.pyc ● Usa extensiones escritas en C ● GIL (Global Interpreter Lock) ● Python Garbage Collection ● Jython ● Escrito en Java ● Compila a.class ● Extensible usando Java ● Multihilo gracias a Java ● Java Garbage Collection

Ventajas y usos de Jython ● Aprovechar el extenso ecosistema Java ● Uso de plugins escritos en jython para applicaciones java como como una buena forma de extensibilidad ● Aprovechar la flexibilidad y elegancia de Python para implementar partes de sistemas Java. ● Jython en servidores de aplicaciones J2EE ● Testing de sistemas Java

Instalación ● Instalaremos jython sobre java 6. ● dex.html ● ● Los ejercicios y ejemplos que se obtienen de github están preparados para ser importados como proyectos de PyDev ●

Aprovechando Java... JythonUsingJava/basicexamplejava.py ● from java.security import MessageDigest from java.lang import String def calc_md5(text): md5 = MessageDigest.getInstance("md5") md5.update(text) return jarray_to_hex_s(md5.digest()) #Aqui reside la única complejidad def jarray_to_hex_s(jarray_): """Convertir un array de bytes java en una representacion hexadecimal del mismo""" return "".join(["%02X" % (x & 0xFF) for x in jarray_.tolist()])

Usando Swing desde Jython SwingExample/swingexample.py ● from javax.swing import * from javax.swing import JButton from javax.swing import JFrame def hello(event): print "Hello. I'm an event." def test_swing(): frame = JFrame("Hello Jython") button = JButton("Pulsar", actionPerformed = hello) frame.add(button) frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) frame.setSize(200, 100) frame.show()

Limitaciones ● No se pueden usar extensiones de python en c (aún) ● No se puede heredar de multiples clases Java (sí se puede de multiples clases python o multiple interfaces java) ● Acceso a métodos privados y protegidos de clases java → ver FAQ de jython ● Bug en leaks en reinicio de apps Jython en serv. de aplicaciones debido a problema con classloaders

A tener en cuenta ● null en java es transformado a None en jython ● java.util.Date.getTime() devuelve seconds from the epoch en lugar de milliseconds ● El concatenado de strings "a" + "b" es menos eficiente que en CPython: mejor usar join. ● Jython un único tipo string. > 2.5 -> strings y unicode strings del mismo modo que en cpython ● Dado que el sistema de garbage collection en java es diferente, conviene ser cuidadoso al liberar recursos

Usando Java desde Jython

● Como ya hemos visto, basta con importar y usar ● Acceso a propiedades estilo 'JavaBeans' sin usar getters y setters ● Conversiones de tipos ● Atención a los arrays de Java ● Herencia de clases Java from java.security import MessageDigest md5 = MessageDigest.getInstance("md5") md5.update(“calculatemymd5”)

Acceso a propiedades JavaBean JythonUsingJava/.../HighSchool.java public class HighSchool { private String name; private String city; private int numberOfStudents; public HighSchool(String name, String city){ this.name = name; this.city = city; } public String getName() { System.out.println("Getting name!"); return name; } public void setName(String name) { this.name = name; } JythonUsingJava/.../jproperties.py hschool = HighSchool("instituto1", "Zaragoza", numberOfStudents=100) print("%s in %s for %i students" % (hschool.name, hschool.city, hschool.numberOfStudents)) hschool.numberOfStudents = 200 print(hschool.numberOfStudents)

Conversiones al pasar parámetros

Conversiones en valores devueltos

Atención al paso de arrays ● El método Java recibe un wrapper de la lista Jython ● Si el método Java modifica el contenido del array, los cambios no se reflejan en la lista Jython. ● Para ello se necesita usar la jarray.array arr = jarray.array('i', [1, 2, 3]) #creamos un array de java jyarr = arr.tolist() #obtener lista jython a partir del array ● El primer parámetro de jarray.array() es el indicador del tipo java del array:

Heredando de clases Java JythonUsingJava/.../subclassing.py class ExtendedHighSchool(HighSchool): def __init__(self, name, city, address): HighSchool.__init__(self, name, city) self.address = address eh = ExtendedHighSchool("Centro 1", "Zaragoza", "Independencia, 2") print(eh.address)

Emulando clases Jython en Java import java.util.Vector; public class CustomContainer { private Vector data; public CustomContainer() { data = new Vector(); } // Implement the len() operator. public int __len__() { return data.size(); } // Implement the append() method. public int append(String item) { data.add(item); return 1; }... } ● Se puede emular comportamiento de estructuras típicas de jython (ej: len(vector)) implementando métodos especiales ● special-method-names

Ejercicios: ● La estructura de los ejercicios está ya predefinida, con proyectos ya listos para ser importados en PyDev ● Los ficheros de la estructura ya definida están por completar o vacíos. Soluciones en el directorio exerc_solutions ● 01_ExtendingString → Emulando comportamiento típico de listas para la clase String de Java

Extendiendo clases Jython desde Java ● Es posible extender clases Jython desde Java. Algunas clases interesantes: ● PyDictionary ● PyInteger ● PyList ● PyString ● PyStringMap ● PyTuple

Integrando Jython en Java

● Usando el PythonInterpreter directamente ● Jython factory objects ● JSR 223 (JSE 6 scripting project) ● jythonc (deprecado) ● Plyjy ● JSE7 Soporte de la JVM para lenguajes dinámicos (aka InvokeDynamic)

Usando PyInterpreter examples/JavaUsingJython/.../embedded PythonInterpreter interp = new PythonInterpreter(); nterp.exec("import sys"); interp.exec("print sys"); interp.set("intvar", new PyInteger(10)); interp.exec("print type(intvar)"); interp.exec("x = intvar + 2"); PyObject x = interp.get("x"); int javaint = x.asInt(); Integer javainteger = (Integer) x.__tojava__(Integer.class); System.out.println("x: " + javaint); PyObject localvars = interp.getLocals(); localvars.__setitem__("var1", new PyString("hello!")); interp.set("localvars", localvars); interp.exec("print(var1)");

PyInterpreter: ClassLoader personalizado PyDictionary table = new PyDictionary(); RestrictedClassLoader classLoader = new RestrictedClassLoader(); PySystemState state = new PySystemState(); state.setClassLoader(classLoader); PythonInterpreter interp = new PythonInterpreter(table, state); ● PyInterpreter permite, a traves de PySystemState, usar un classloader propio para la carga de clases Jython

Jython con Java Scripting Engine examples/JSEScriptingJython ● ● Jython-engine.jar y jython.jar en classpath ScriptEngineManager mgr = new ScriptEngineManager(); ScriptEngine eng = mgr.getEngineByName("python"); System.out.println("eng: " + String.valueOf(eng)); eng.put("var1", new Integer(257)); eng.eval("print 'var1: %s' % var1"); eng.eval("import sys"); eng.eval("print sys.version");

Objetos factoría Jython examples/JavaUsingJython/.../factory package es.neodoo.jythoncourse.factory; public interface HighSchoolType { public String getName(); public String getCity(); public void setName(String name); public void setCity(String city); } from es.neodoo.jythoncourse.factory import HighSchoolType class HighSchool(HighSchoolType): def __init__(self, name, city): self._name = name self._city = city def getName(self): return self._name def getCity(self): return self._city def setName(self, name): self._name = name def setCity(self, city): self._city = city

Objetos factoría Jython (II) examples/JavaUsingJython/.../factory package es.neodoo.jythoncourse.factory; import org.python.core.PyObject; import org.python.core.PyString; import org.python.util.PythonInterpreter; public class HighSchoolFactory { private PyObject jyHighSchoolClass; public HighSchoolFactory() { PythonInterpreter interpreter = new PythonInterpreter(); Interpreter.exec("from highschool import HighSchool"); jyHighSchoolClass = interpreter.get("HighSchool"); } public HighSchoolType create(String name, String city) { PyObject highschoolObj = jyHighSchoolClass.__call__(new PyString(name), new PyString(city)); return (HighSchoolType) highschoolObj.__tojava__(HighSchoolType.class); }

Objetos factoría Jython (III) ● La creación del interprete jython es cara ● Si el número de clases jython con el que interactuar es alto, usar una factoría por cada tipo puede ser costoso. Usar una factoría genérica. ● plyjy - ● Implementación de factorías genéricas usando PyInterpreter y PySystemState

Ejercicios: ● 02_DicAccessFromJava → Emulando acceso como diccionario para una clase Java ● 03_ExtendingStringFromJava → Mismo ejercicio que 01_ExtendingString, pero implementandolo como clase Java ● Ejercicio adicional: Crear una clase jython que implemente una calculadora de números imaginarios con operaciones típicas (sumar, restar, multiplicar, dividir), implementar una factoría Java y hacer uso de la clase implementada desde Java. En este caso no se ofrece el proyecto PyDev ya preparado, el alumno deberá configurarlo.

Usando bases de datos en Jython

● ZxJDBC ● DBI 2.0 ● Interface a JDBC – zxJDBC.connect – zxJDBC.lookup → lookup JNDI de conexiones gestionadas por contenedor JEE. ● SqlAlchemy ( ● No todas las bases de datos que soporta en cpython tienen dialecto para zxJDBC (a día de hoy hay soporte para Oracle, PostgreSQL y MySQL) ● Hibernate (Java) ● Crear entidades y mappings en Java, hacer uso del api de hibernate y de las entidades desde Jython ● Persistencia con DJango

ZxJDBC examples/ZxJDBC from __future__ import with_statement from com.ziclix.python.sql import zxJDBC jdbc_url = "jdbc:hsqldb:mem" username = "SA" password = "" driver = "org.hsqldb.jdbcDriver" stmt = "create table testadata (id integer, name varchar(50))” with zxJDBC.connect(jdbc_url, username, password, driver) as conn: with conn: with conn.cursor() as c: result = c.execute(stmt) ● Usaremos Hypersonic (RDBMS 100% Java) para el ejemplo. BD en memoria → Solo necesitamos un.jar!

Ejercicios ● 04_SwingCalculator → Implementar una calculadora en Swing desde jython ● 05_SeamPersistence → Modificar una aplicación Seam para que haga uso de jythony zxJDBC para realizar la persistencia, en lugar del mecanismo de hibernate que utiliza

Referencias ● ● ● ● ● 03.html