Introdução ao Jython

O que é Jython?

Jython é a união entre o Java e o Python, devemos aqui fazer uma separação entre a linguagem de programação Java e a plataforma Java.

Primeiro temos a linguagem (um C++ que não deu certo) que possui certas características. Podemos citar por exemplo a orientação a objetos e o fato de Java não ser compilada de forma a gerar um binário nativo (características em comum com o Python). É ai que entra a plataforma Java, todos que conhecem o Java sabem que a propaganda do Java é "Compile once, run many" algo como compile uma vez rode em qualquer lugar. Java funciona assim porque ele não roda diretamente em contato com a plataforma nativa e sim em cima de uma máquina virtual que cria uma camada com API's padronizadas. Bom se é assim eu preciso usar "aquela linguagem " para programar para Java?

• Na verdade hoje ja existem varias linguagens para a plataforma Java (Ruby, Perl e um tclsh ainda incompleto) e de todas estas linguagens a que consegui ir mais fundo na integração com a plataforma Java foi com Python (Python tem acesso a todos os recursos da plataforma Java e a todas as bibliotecas, além de possuir a capacidade de "compilar" o bytecode resultante. O resultado final não é totalmente indepedente do Jython porque ele estende um pouco as classes nativas do Java, mas é possível incluir todas as dependecias em um jar com cerca de 83KB, dependendo do que é usado).

As vantagens do Jython

• 1 - Velocidade de desenvolvimento: Python é uma linguagem de desenvolvimento rápido (cerca de 8 vezes mais rápido que em linguagem Java). 2 - Praticidade: Você não precisa compilar o código Jython pra testá-lo. Isto torna a depuração muito mais rápida. Depois de terminado o processo você utiliza o compilador Jythonc para compilar o programa, para incluir as biliotecas do Jython existe a opção do freeze. 3 - Tempo de aprendizado: É muito mais rápido que no caso da linguagem Java (até por esta ser derivada do C++ que tradicionalmente não é uma linguagem fácil).

Pondo a mão na massa

Instalação

Aqui nós cobriremos apenas a instalação do pacote binário, mas como o Jython é distribuido seguindo uma licença bem liberal você pode compilar ele do fonte. Não é nescessario, já que a plataforma Java é unificada.

Download

Em http://www.jython.org/download.html você encontrará as versões mais recentes do Jython.

Baixe uma versão atualizada da VM do Java (dhuu!!). Jython funciona a partir da versão 1.1. Nos meus testes ele não rodou em nada mais velho que a versão 1.2. Estou utilizando o 1.4 no meu Linux mas os programas rodam igualmente bem em um 1.3 (instalado em OS/2).

A instalação é simples. Simplesmente execute o .class:

java jython-????

e siga as instruções da interface gráfica de instalação.

O primeiro programa em Python no Java

Vamos fazer um Hello world! rapidinho:

Execute o Jython (normalmente existe um script pra isso no diretório onde você instala o Jython).

Jython 2.1 on java1.4.1 (JIT: null)
Type "copyright", "credits" or "license" for more information.

>>>from javax.swing import *
>>>
>>> janela = JFrame('Teste')
>>> label = JLabel('Ola mundo!')
>>> janela.getContentPane().add(label)
>>> janela.setBounds(20,20,200,200)
>>> janela.setVisible(1)

E temos o nosso Hello world!.

Trabalhando com classes "Java Puro-Sangue"

Primeiro vamos criar uma classe em Java. Vamos utilizar um painel com um rótulo:

   1 /**
   2  * Painel com uma caixa de texto e um label.
   3  * 
   4  * Um objeto muito usado
   5  * @version 0.0.1
   6  */
   7 
   8 import java.awt.*;
   9 import javax.swing.*;
  10 
  11 public class lentry extends JComponent {
  12     private JLabel label;
  13     private JTextField texto;
  14 
  15     public lentry(String rotulo) {
  16         label = new JLabel(rotulo);
  17         texto = new JTextField();
  18         setLayout(new GridLayout(2,2));
  19         add(label);
  20         add(texto);
  21     }
  22 
  23     public String getText() {
  24         return this.texto.getText();
  25     }
  26 
  27     public void setText(String te) {
  28         this.texto.setText(te);
  29     }
  30 }

Bom o próximo passo é compilar o arquivo:

javac lentry.java

Com o .class em mãos vamos utilizá-lo no Jython. Aqui vai um exemplo simples:

   1 from javax.swing import *
   2 from java import awt
   3 
   4 # importando a nossa classe Java
   5 import lentry
   6 
   7 class teste(JFrame):
   8    def __init__(self, rotulo='Teste'):
   9       JFrame.__init__(self, rotulo)
  10       teste = lentry('Rotulo')
  11       self.setLayout(awt.BorderLayout())
  12       self.getContentPane().add(teste)
  13       self.setBounds(20,20,200,300) # define o tamanho da janela
  14       self.setVisible(1)
  15 
  16 if __name__=="__main__":
  17    janela = teste()

Aqui vemos algumas diferenças básicas entre o Python e o Java. Basicamente não importa como foi feito o objeto o efeito final para uso dele é o mesmo (aquilo que os pythonistas já estão acostumados mas no quesito importação nós vamos ver a diferença: Java trata cada arquivo como uma classe, já para Python um arquivo pode conter várias classes. Também não é nescessário que a classe tenha o mesmo nome do arquivo). Por isso quando vamos importar algo escrito em Java (the lang) a importação é feita do modo simples:

import nome_do_objeto

Para todos os outros efeitos nem mesmo o programador será capaz de dizer se esta usando um modulo "Puro-Sangue" ou um módulo feito em Python.

Observação: A maneira como o Python trata os arquivos em relação aos objetos é o principal motivo pelo qual os seus programas feitos no Jython não são totalmente independentes do Jython uma vez compilados as classes criadas neles são primariamente objetos do Python, embora possam ser usados no Java.

Utilizando o Jython no Java

Este exemplo veio do site do Jython, me foi enviado por alguem da lista, não me lembro quem e infelizmente eu perdi o e-mail. Primeiro vamos criar a seguinte classe em Python:

   1 #------------------------------------
   2 # WelcomeFrame.py
   3 #-----------------------------------
   4 
   5 import javax.swing as swing
   6 import java.awt as awt
   7 import java.lang as lang
   8 
   9 def exit(event):
  10    lang.System.exit(0)
  11 
  12 class WellcomeFrame(swing.JFrame):
  13    names = ["Groucho", "Chico", "Harpo"]
  14    quotes = {"Groucho": "Say the secret word", "Chico": "Viaduct?", "Harpo": "HONK!"}
  15 
  16    def __init__(self, title="Welcome to Jython", size=(200, 200)):
  17       "@sig public WelcomeFrame(String title, java.awt.Dimension size)"
  18       self.title = title
  19       self.windowClosing = exit
  20       self.contentPane.layout = awt.FlowLayout()
  21       self.field = swing.JTextField(preferredSize=(200,20))
  22       self.contentPane.add(self.field)
  23       buttons = [self.createButton(each) for each in self.names]
  24       for eachButton in buttons:
  25          self.contentPane.add(eachButton)
  26       self.pack()
  27 
  28    def buttonPressed(self, event):
  29       self.field.text = self.quotes[event.source.text]
  30 
  31    def createButton(self, name):
  32       "@sig public javax.swing.JButton createButton(String name)"
  33       return swing.JButton(name, preferredSize=(100,20),actionPerformed=self.buttonPressed)
  34 
  35    def addQuote(self, marxBrother, quote):
  36       "@sig public void addQuote(String marxBrother, String quote)"
  37       self.quotes[marxBrother] = quote
  38 
  39 if __name__ == '__main__':
  40    WelcomeFrame().show()

Feito isso passamos ao passo 2: Compilar o código acima.

Para isso utilizamos o jythonc, que faz parte do pacote do Jython:

# jythonc WellcomeFrame.py

As outras opções do compilador do Jython serão discutidas em um capítulo mais a frente, você também pode ler mais sobre ele na documentação do Jython. Por enquanto isso deve bastar, o Jythonc cria um subdiretório na pasta corrente chamado jpywork, dentro dele encontraremos as classes que usaremos, são duas, uma é a classe NomedaClasse.class e a outra NomedaClasse$_PyInner.class.

A primeira contêm um proxie Java para o objeto Python a segunda contêm o objeto Python propriamente dito. É bom lembrar que como o Python trata os objetos de maneira distinta do Java não é possível o acesso direto do Java aos objetos criados em Python, embora o acesso do Python aos objetos do Java seja direto.

Obviamente você não precisa obrigatoriamente do $_PyInner.class pode-se usar no lugar dele o código Python puro ou a versão bytecompiled dele. Depois de copiar as duas classes pro diretório onde vamos trabalhar criaremos um objeto em Java que extende o objeto que criamos no Python:

// ------------------------------------
// FrameUser.java
// ------------------------------------

import javax.swing.JButton;


public class FrameUser {
   public static void main(String[] argv) {
      WellcomeFrame f = new WellcomeFrame("From Java");
      JButton newButton = f.createButton("Zeppo");
      f.addQuote("Zeppo", "Hello");
      f.getContentPane().add(newButton);
      f.pack();
      f.show();
   }
}

Em seguida vamos compilar o código acima. Mas antes disso temos que configurar o {{{CLASSPATH

Eu uso o Java 1.4.1 que normalmente não usa CLASSPATH para acessar suas própias bibliotecas somente para acessar bibliotecas que não estejam no diretorio $JAVA_HOME/jre/lib/ext. Eu não utilizo as bibliotecas do Jython neste diretorio, se você utiliza pode pular este passo.

$ export CLASSPATH=LugarOndeEstaOJython/jython.jar:.  # configura no Linux (Shell Bash)

O passo seguinte é compilar o fonte:

$ javac FrameUser.java

Uma vez compilado é só rodar o programa, com o CLASSPATH acima configurado ele roda sem problemas.

Acessando banco de dados com o Jython

O Jython é bastante democrático em relação ao acesso à bancos de dados. Pode-se utilizar o acesso do Java, para quem esta mais acostumado ao Java. E quem esta passando do PythonC ao Jython? Utiliza-se o zxJDBC, ele cria um objeto com interface semelhante à do Python para acesso a banco de dados.

Eu fiz testes com o PostgreSQL e o MySQL, em ambos os casos o acesso foi perfeito. Aqui vai um pequeno exemplo de como fazer o acesso com o zxJDBC. Para para maiores informações leia a documentação que vem junto com o Jython (ela é bastante completa e não é nosso interesse aprofundar aqui}.

   1 from com.ziclix.python.sql import zxJDBC
   2 
   3 #-----------------------------------------------
   4 # d->URI to database
   5 # u->user
   6 # p->password
   7 # v->java class driver
   8 
   9 d, u, p, v = "jdbc:mysql://localhost/mysql", "rodrigo", None, "com.mysql.jdbc.Driver"
  10 
  11 # do python connect
  12 db = zxJDBC.connect(d,u,p,v)
  13 
  14 cursor = db.cursor()
  15 cursor.execute("show tables")
  16 ret = cursor.fetchone()
  17 print(ret[0])
  18 db.close()

Extenções do Python ao Java

O Python cria uma série de extenções ao Java. Primeiro as do próprio PythonC, já que a grande maioria delas funciona bem no Jython. Quem não conhece bem estas extenções eu recomendo primeiro uma visita ao PythonC.

Nós trataremos aqui de dois exemplos:

• 1 - Usar o PAWT para configurar o layout dos nossos objetos. 2 - Usar o PAWT para trabalhar com eventos.

O segundo item é importante já que o método de eventos de Java é bastante deficiente (ele trabalha com um listener centralizado onde o programador deve checar os eventos e objetos e depois executar a chamada apropriada).

Obs.: PAWT significa Python AWT e é a versão Python para a biblioteca AWT do Java. Essa biblioteca contêm os pacotes de Layout e eventos do Python além de "atalhos" para outras coisas de maior uso no dia a dia. Para usar Swing você deve importá-la como pawt.swing).

Configurando layout no Jython usando o Pawt.GridBag

Uma das maneiras mais usadas para se configurar layout no Java manualmente é o GridBag. Ele permite que se estipulem tamanhos diversos para widgets baseando-se na proporção da tela, o que permite conservar a aparência da janela não importando o tamanho da mesma. O único problema do GridBag é que ele é um pouco complicado e não muito intuitivo de se usar. Um exemplo do uso de GridBag pode ser visto no seguinte código retirado do manual do Java:

import java.awt.*;
import java.util.*;
import java.applet.Applet;

public class GridBagEx1 extends Applet {

   protected void makebutton(String name,
                             GridBagLayout gridbag,
                             GridBagConstraints c) {
      Button button = new Button(name);
      gridbag.setConstraints(button, c);
      add(button);
   }

   public void init() {
      GridBagLayout gridbag = new GridBagLayout();
      GridBagConstraints c = new GridBagConstraints();

      setFont(new Font("Helvetica", Font.PLAIN, 14));
      setLayout(gridbag);

      c.fill = GridBagConstraints.BOTH;
      c.weightx = 1.0;
      makebutton("Button1", gridbag, c);
      makebutton("Button2", gridbag, c);
      makebutton("Button3", gridbag, c);

      c.gridwidth = GridBagConstraints.REMAINDER; //end row
      makebutton("Button4", gridbag, c);

      c.weightx = 0.0;                  //reset to the default
      makebutton("Button5", gridbag, c); //another row

      c.gridwidth = GridBagConstraints.RELATIVE; //next-to-last in row
      makebutton("Button6", gridbag, c);

      c.gridwidth = GridBagConstraints.REMAINDER; //end row
      makebutton("Button7", gridbag, c);

      c.gridwidth = 1;                //reset to the default
      c.gridheight = 2;
      c.weighty = 1.0;
      makebutton("Button8", gridbag, c);

      c.weighty = 0.0;                  //reset to the default
      c.gridwidth = GridBagConstraints.REMAINDER; //end row
      c.gridheight = 1;               //reset to the default
      makebutton("Button9", gridbag, c);
      makebutton("Button10", gridbag, c);

      setSize(300, 100);
   }

   public static void main(String args[]) {
      Frame f = new Frame("GridBag Layout Example");
      GridBagEx1 ex1 = new GridBagEx1();

      ex1.init();

      f.add("Center", ex1);
      f.pack();
      f.setSize(f.getPreferredSize());
      f.show();
   }
}

O mesmo código em Python ficaria assim:

   1 from java.awt import *
   2 from pawt import GridBag
   3 from java.awt import GridBagConstraints as GB #layouts mais simples nem precisam disto
   4 from java.lang.System import exit
   5 
   6 class janela(Frame):
   7    def __init__(self):
   8       self.bag = GridBag(self)
   9 
  10          # Criacao dos botoes
  11          botao1 = Button('Button1', actionPerformed=self.sair)
  12          botao2 = Button('Button2', actionPerformed=self.sair)
  13          botao3 = Button('Button3', actionPerformed=self.sair)
  14          botao4 = Button('Button4', actionPerformed=self.sair)
  15          botao5 = Button('Button5', actionPerformed=self.sair)
  16          botao6 = Button('Button6', actionPerformed=self.sair)
  17          botao7 = Button('Button7', actionPerformed=self.sair)
  18          botao8 = Button('Button8', actionPerformed=self.sair)
  19          botao9 = Button('Button9', actionPerformed=self.sair)
  20          botao10 = Button('Button10', actionPerformed=self.sair)
  21 
  22          # Definicao do layout
  23          self.bag.add(botao1, weightx=0.0, weighty=0.0)
  24          self.bag.add(botao2, weightx=0.0, weighty=0.0)
  25          self.bag.add(botao3, weightx=0.0, weighty=0.0)
  26          self.bag.addRow(botao4, weightx=0.0, weighty=0.0)
  27          self.bag.addRow(botao5, fill='HORIZONTAL')
  28          self.bag.add(botao6, gridwidth=GB.RELATIVE, fill='HORIZONTAL')
  29          self.bag.addRow(botao7)
  30          self.bag.add(botao8, fill='BOTH', gridheight=2)
  31          self.bag.addRow(botao9, fill='HORIZONTAL')
  32          self.bag.addRow(botao10, fill='HORIZONTAL')
  33          #
  34          self.setBounds(200,200,280,170)
  35 
  36       def sair(self,evt):
  37          exit(0)
  38 
  39 if __name__=="__main__":
  40    janela().show()

Não é simplesmente uma questão de simplicidade do código. O metódo também é bem mais intuitivo que o do Java. Para a maioria dos programas você não precisará nem dos GridBagConstraints que eu importei aqui.

Os métodos padrão são:

• 1 - add() - adiciona no espaço vago seguinte (normalmente na mesma linha, a menos que o weigthy tenha sido setado com valor maior que 0 suas opções são: weightx - Peso na horizontal, weighty - Peso na vertical, gridwidth - Largura horizontal da celula, gridheight - Largura vertical da célula e fill - completa o espaço. Tem três padrões: HORIZONTAL, VERTICAL e BOTH.

  2 - addRow() - o mesmo que o anterior só que ocupa sempre o espaço restante na linha, o próximo objeto ocupará sempre a próxima linha.

Trabalhando com eventos

Em Java você trabalha com eventos da seguinte forma (o código esta em Python):

   1 class action(awt.event.ActionListener):
   2    def actionPerformed(self,event):
   3       java.lang.System.exit(0)
   4 
   5 button = awt.Button("Close Me!")
   6 button.addActionListener(action())

Quem programa em Java sabe o quanto essa implentação pode se tornar infinitamente complexa. A meu ver a maneira de tratar os eventos constitui a maior falha do Java. Bom, e o Python?

Em Python nós escreveriamos assim:

   1 def exit(event):
   2     java.lang.System.exit(0)
   3 
   4 button = awt.Button("Close Me!", actionPerformed=exit)

Existem alguns eventos controlados pelo Python. O mais utilizado é o nosso já conhecido actionPerformed. Outra forma de configurar eventos é:

   1 obj.keyPressed = funcao
   2  
   3 def funcao(event):
   4     pass

Uma lista completa dos eventos mapeáveis desta forma pode ser conseguida num manual Java :), ja que praticamente todos os eventos do Java podem ser mapeados desta forma. O código a seguir mostra como mapear as teclas pressionadas em uma caixa de texto:

   1 from javax.swing import *
   2 from java import awt
   3 
   4 def alert(panel,message):
   5    result = JOptionPane.showMessageDialog(panel,message);
   6 
   7 class KeyChek(JFrame):
   8    def __init__(self):
   9       self.setBounds(200,200,200,70)
  10       self.getContentPane().setLayout(awt.GridLayout(2,1))
  11       self.label = JLabel('Digite algo:')
  12       self.texto = JTextField()
  13       self.panel = self.getContentPane()
  14       self.panel.add(self.label)
  15       self.panel.add(self.texto)
  16       self.texto.keyPressed = self.textoKeyPressed
  17 
  18    def textoKeyPressed(self, evt):
  19       tecla = evt.getKeyChar()
  20       alert(self.panel, 'Voce pressionou %c' % (tecla))
  21 
  22 if __name__=="__main__":
  23    KeyChek().show()

Compilando Fontes para Classes Java reais

Este texto foi extraído e traduzido na íntegra do Manual do Jython.

Na sessão sobre uso do Jython em Java nós vimos como criar .class com o jythonc. Lá nós conseguimos utilizar as classes geradas no Java, mas ela ainda conservava as dependências do próprio Jython e do seu codigo fonte original em Python.

Isto é nescessário para escrever Servlets, Beans e Applets. Existem duas ferramentas importantes para isto e elas vem junto com o Jython. A primeira que nós já conhecemos é o jythonc. O jythonc gera código real Java e depois compila este código para criar classes Java "reais".

Abaixo temos uma tabela com as opções do jythonc:

Para poder criar classes Java reais o módulo Python deve conter uma classe com o mesmo nome do módulo e esta classe deve extender uma classe ou interface Java. A classe gerada será uma subclasse daquilo que você extendeu.

Compilado métodos Python para métodos Java

Normalmente métodos Python compilados não são acessíveis do Java. Simplesmente não existe informação suficiente a respeido dos métodos Python para escrever um método Java compatível. Existem duas maneiras de fazer isto:

• Overriding / Implementando um método Java.
  • Assim a assinatura do método será usada para criar uma classe Java real. Isto inclui tipo de retorno, privacidade, argumentos, tipos de argumentos e throws.
• Adicionando uma assinatura java ao docstrings do metodo.

  • Existe uma convenção especial no método docstring que permite a criação de um método Java. A assinatura deve começar com "@sig" e todas as classes em Java devem ser escritas com o nome completo (com excessão daquelas que fican no java.lang). Exemplo:

   1 def setExpression(self, e):
   2    "@sig public void setExpression(java.lang.String e)"

Exemplos

Para compilar os applets que vem de demonstração no Jython em uma maquina com Windows:

c:\jython\Demo\applet> jythonc --core --deep --jar appletdemo.jar *.py

Para criar um esqueleto que permita uma classe Python ser usada como um java.awt.Component no Java:

/usr/local/jython-2.1/demo$ jythonc Graph.py

Para gerar um bean:

/usr/local/jython-2.1/Demo/bean$ jythonc --deep --bean f2c.jar conversion.FahrenheitToCelsius

Freezing modules

Aqui temos a segunda ferramenta. Na verdade ela é executada pelo próprio jythonc, e consiste no "congelamento do módulo". A aplicação congelada pode ser tratada como qualquer aplicação feita em Java.

Existem algumas diferenças entre uma aplicação Jython e uma "congelada":

• Propriedades diferentes
• sys.argv[0]
• Não se pode carregar módulos Jython não congelados.

Uma comparação entre o Python/Java/PythonC

Aqui vamos fazer uma comparação entre estas linguagens. A linguagem C será colacada como parâmetro, afinal é a origem de todas as outras e para a maioria dos analistas (eu inclusive) o padrão maxí. Os dados de performance foram obtidos a partir de testes feitos. Os programas de testes continham a seguinte estrutura:

• Uma interface grafica com 22 elementos simples (caixas de texto e botões)

• PythonC -foram feitos dois programas um com o Tk e o outro com o wx a performance do Tk é ligeiramente superior mas como o wx contêm mais objetos mantive apenas o teste com este na análise.

• Java - foram feitos dois. Um com Swing outro com o AWT. A diferença de performance é desprezível. Tem certeza disso? Eu tenho a sensação de que Swing é *muito* mais lenta que AWT - OsvaldoSantanaNeto

• Jython - idem para o Java.

• C/C++ - Foi usado o wx apenas, mas a performance do C++ é superior demais e resolvi dispensar os testes com outros toolkits.

Dados:

Segundo os dados do Jython newspaper o Java é 1,7 vezes mais lento que o PythonC e o Jython é 0,8 vezes mais lento que o Java. Meus testes confirmam os dados do Jython mas neles o Java foi cerca de 2,5 vezes mais lento.

* Embora a portabilidade do C/C++ passe por recompilção do código e o programador tenha que se importar em manter o código portável não existe plataforma que não possua um compilador C/C++ e na verdade mesmo as funções que dependem do sistema operacional são relativamente parecidas e podem ser portadas usando o famoso #ifdef QQOS. Já o Java hoje roda em um número menor de plataformas que o Python embora seu objetivo principal seja a portabilidade. Tem certeza disso? Seria melhor exibir os fatos aqui. -- OsvaldoSantanaNeto

** O Java tem, hoje, um número ligeiramente maior de bibliotecas que o Python mas como não se integra ao C/C++ (Se integra sim. -- OsvaldoSantanaNeto) isso o limita. Já o Jython tem quase todas as extensões do Python mais as do Java ou seja só perde para a linguagem C.

*** Como o Python se integra a bibliotecas feitas em C/C++ o seu limite se expansão é praticamente infinito o que o coloca em posição de vantagem.

Seria bom que você reavaliasse toda essa seção do seu texto. Me parece que existem incoerências nos resultados e, em se tratando de comparar linguagens, é bom tomar bastante cuidado. Caso contrário você pode levantar a ira dos Lemmings da Sun e nesta situação apenas dados reais e bem palpáveis, sem marketing é que poderá 'derrotá-los'. -- OsvaldoSantanaNeto

Non-disclosure: O editor do site (WikiMaster) não confirma nem nega os dados levantados nesse trabalho. -- OsvaldoSantanaNeto

Copyright deste texto

Todo material e exemplos deste texto que cujos autores não foram nominalmente cidados foi escrito por RodrigoCesarHerefeld. Este manual foi escrito na intenção de ser útil e não possui qualquer garantia. Ele pode ser copiado e distrubuído, na forma impressa ou digital desde que os autores sejam nominalmente citados e este copyright seja mantido.

RodrigoCesarHerefeld

Editado e formatado: Osvaldo Santana Neto