You are currently browsing the archives for the jruby category


jetty-rackup: rodando aplicações Rack no Jetty

Por conta de um projeto que está pintando no trabalho, que requer o uso de um conector escrito em Java, há umas duas semanas mais ou menos comecei a fazer novos testes com Jython, considerando fortemente uma solução baseada Python. Até publiquei uma aplicação boba usando Flask, só de exemplo, porque googlando não achei nada que não fosse com Pylons ou Django. Mas no final, Jython não pode preencher alguns requisitos e voltamos então para JRuby.

É aqui que entra o tema deste post.

Essa semana andei fazendo algumas contribuições em um projeto open source bem simples, mas igualmente interessante, que é o jetty-rackup.

O objetivo do jetty-rackup é rodar aplicações Rack no Jetty WebServer, sem ter que empacotá-las em arquivos WAR, o que é definitivamente excelente em ambiente de desenvolvimento ou quanto você quer fazer deploy orientado a git pull.

Tutorial de 1 minuto

Bem, para que o jabá seja completo, nada melhor do que um tutorial. Vamos escrever então uma aplicação Sinatra básica – ótima pedida para Web API.

1. Com Sinatra já instalado, crie uma aplicação – app.rb

require 'sinatra'

configure :development do
  Sinatra::Application.reset! # recarrega as rotas
  use Rack::Reloader          # recarrega arquivos
end

get '/?' do
  "hello"
end

get '/:message/?' do |message|
  "hello #{message}"
end

2. Com a aplicação criada, crie o arquivo rackup – config.ru

require 'rubygems'
require 'app'

set :run, false
set :environment, :development

run Sinatra::Application

3. Com o arquivo rackup criado, installe a gem jetty-rackup

$ gem install jetty-rackup

4. Com a gem jetty-rackup instalada, no diretório da aplicação criada, inicie a aplicação

$ jetty-rackup config.ru

5. Finalmente, com tudo pronto, teste com cURL e Apache Benchmark

$ curl http://localhost:9292/

$ ab -n 10000 -c 25 http://localhost:9292/

Voilà!

Agora, rode o último comando algumas vezes e observe a variação crescente de “Requests per second”. JIT Compiler for the win!

Um pouco mais

Se quiser saber como usar bibliotecas Java, no repositório do projeto tem também um exemplo usando classes Java, tanto contidas no diretório WEB-INF/classes quanto em arquivo JAR no WEB-INF/lib.

Divirta-se!

Você pode ter o seu próprio GitHub

Quem é que “não” conhece e adora o GitHub? Com certeza o número de pessoas que respondem “sim” a está pergunta só tem diminuido, porque o GitHub cresce em popularidade e sucesso a cada dia. Também pudera, né?

Bem, mas indo direto ao assunto, a novidade que fiquei sabendo hoje é que agora é possível para qualquer empresa ter sua própria instalação de GitHub.

GitHub:FI é o novo produto que a moçada da Logical Awesome está colocando no mercado. Ele é basicamente o mesmo bom e velho jovem GitHub de sempre, mas instalado na infra-estrutura privada da sua empresa, rodando sobre JRuby + Jetty em vez do clássico Ruby + Mogrel.

Você pode saber mais no post oficial de anúncio dele.

Taí, mais um ponto para o JRuby! \o/

Sua gem funciona bem com JRuby?

Acabei de ler no post Notícias do Front #5 do Fábio Akita uma notícias que me deixou muito feliz:

is it jruby? – recentemente a Brightbox lançou o site is it ruby 1.9?, onde a comunidade poderia testar gems e dizer nesse site se ela é ou não compatível, em seus testes, com o ruby 1.9. Agora foi lançado mais uma com o mesmo objetivo mas desta vez para avaliar a compatibilidade de gems com o jruby. Mais e mais a comunidade está se conscientizando que as gems precisam receber mais tratamento para ficarem compatíveis com múltiplas virtual machines. Isso é muito bom e espero que todos colaborem.

Isto porque sou usuário de JRuby e volta e meia tenho problema com alguma gem que não funciona com ele, por conta de extensões nativas em C.

Então, por caridade, quando fizer uma gem, veja se ela funciona bem com JRuby também. :)

Entrevista com Ola Bini: Ioke, JVM, .NET e mais!

Quem me conhece há algum tempo ou acompanha este meu blog, sabe que eu sou totalmente meio fissurado por linguagens de programação. Sempre estou dando uma olhada em uma aqui e outra ali. Lendo, fuçando…

Mas tem um cara que com certeza é ainda muito mais fissurado em linguagens de programação do que eu - e diferente de mim, manja pra caramba. Esse cara é o Ola Bini, membro do core team do JRuby, consultor da ThoughtWorks, escritor do livro JRuby on Rails, membro do expert group da JSR-292 e criador da linguagem Ioke.

Bem, como não podia deixar de ser, eu resolvi fazer uma pequena entrevista com ele sobre Ioke, linguagens para a JVM e a Microsoft CLR, e uma coisinha ou duas mais. Confira!

Ola Bini e nosso compatriota Fábio Akita

Ola Bini e o nosso patrício Fábio Akita (QCon 2008)

Fale-nos um pouco sobre sua paixão por linguagens de programação. Quando isto começou? O que mais te motivou?

Oh wow. Boa pergunta. Eu não sei quando isto começou. Em algum momento obscuro do passado – muito longe para me lembrar. =)

Eu comecei bem cedo, com Basic no Apple IIc. Fiz muito C e assembler na minha adolecencia, e então, aprendi C++, Java e Lisp.

Penso que minha atual facinação por linguagens começou quanto eu percebi como diferentes linguagens são e como muitas coisas ruins são usadas. Esta percepção levou algum tempo, mas ficou cada vez maior.

Eu comecei com a implementação de outra linguagem há 5-6 anos atrás.

Além de contribuir com o projeto JRuby, você também criou a linguagem Ioke do zero. O que você tem a dizer sobre a JVM com plataforma para outras linguagens (além da linguagem Java)?

Sim. Então, a JVM é uma excelente plataforma para linguagens. Você tem um JIT muito maduro no Hotspot. Você tem garbage collectors fantásticos; e você tem um monte de bibliotecas e ferramentas disponíveis. A parte ruim é que a JVM atualmente está muito amarrada a linguagens que se parecem com Java, no nível do bytecode. É possível contornar isto, e nós estamos trabalhando na JSR292 para dar suporte a invocações dinâmicas na JVM.

Mas atualmente a JVM ainda está um bocado ligada a linguagens como Java. Isto não é necessário a tudo (muitas das tecnologias Java começaram em Smalltalk e Strongtalk).

Você acredita que a linguagem Java está caminhando para se tornar em uma linguagem de infra-estrutura? (Uma linguagem para escrever linguagens e outros componentes críticos de infra-estrutura.)

Espero que sim. Java não é uma boa linguagem para escrever aplicações – ela é realmente muito baixo nível.

Sobre Ioke. O que levou você a começar o projeto desta linguagem? Onde você pensa chegar com ela? O que você planeja para o futuro de Ioke?

Basicamente, a ideia com Ioke é ver o quão expressiva você pode fazer uma linguagem; e isto é o que tenho feito. Isto tem dado características linguísticas bastante avançadas; você pode fazer coisas nela que muitas pessoas inicialmente tem problemas para entender – mas ela permite você escrever código bastante sucinto e legível, que capture suas intenções.

O que acontecerá exatamente no futuro está no ar. Tenho muitas idéias, mas nada concreto no momento.

Recentemente, você também portou a linguagem Ioke para a Microsoft CLR. O que te motivou a fazer isto? O que você pensa sobre a plataform Microsft .NET como plataforma host para novas linguagens?

Sim! Eu fiz isto porque não queria que Ioke fosse somente uma linguagem da JVM. Queria ver como a CLR funcionaria para implementa-la e queria amplicar um pouco a base de usuário. A plataforma .NET é mais ou menos tão boa quanto a JVM. Algumas coisas são piores, outras são melhores.

O que você recomenda a aqueles que gostariam de, como você, serem designers de linguagens para a JVM? Esta recomendação seria mais ou menos a mesma para a plataforma .NET?

Há duas coisas que você precisa fazer. A primeira é ter uma boa idéia de como diferentes linguagens funcionam. Você precisa aprender linguagens de diferentes paradigmas e tentar entender como elas podem ser implementadas. Então, você precisa começar a fazer. Esta é a parte mais importante.

Comece realmente a implementar e ver o que acontece.

Finalmente, sinta-se à vontade para dizer o que quiser sobre Ioke.

Ela é muito “louca”. Ela é expressiva. Ela é muito lenta.

Penso que esta coisa de expressividade vai ser importante no futuro – já que nós estamos fazendo coisas mais e mais avançadas. Texto não escala se não podemos ter uma abstração estrutural (1). Ioke permite isto.

(1) N.T.: O que o Ola Bini quis dizer é que “texto, por si só, não pode ir a um nível superior, não pode evoluir, crescer, se não pudermos ter uma abstração estrutural sobre ele”. :)

Ruby + Rails no mundo Real 2009: Como foi?

Ontem aconteceu aqui em São Paulo o primeiro evento do GURU-SP, com co-participação da Tempo Real Eventos. Eu estive por lá e vou dizer - sob a minha ótica, claro - como é que foi.

Preço

O preço foi bem razoável para quem comprou antecipadamente, R$ 69,00; mas um pouco carinho para quem comprou na hora, R$ 129,00.

Local

O local, em geral, foi bom. Perto do metrô, pra quem foi de condução; estacionamento a R$ 10,00, pra quem foi de carro; opções de almoço perto não faltaram; o auditório acomodou todo mundo; o ar condicionado estava na medida certa; e o coffe-break, apesar de bem simples, também atendeu. No entanto não havia WI-FI. Isso foi realmente decepcionante, porque evento de programação, sem WI-FI pra galera que levou note, é russo.

Palestras

As palestras, sinceramente, me decepcionaram um pouco. Achei que foram muito introdutórias, muito superficiais. O que salvou o dia dos mais experiêntes foi a palestra do Fábio Kung e a do Caffo. Mas, sei lá, talvez tenha sido a estratégia do evento.

O track foi o seguinte:

1. Vinícius Baggio Fuentes: Criando um Instant Messenger usando Rails

XMPP é uma de minha áreas de interesse, então, estava realmente interessado nessa palestra.

O conteúdo estava legal, eu gostei do formato como a palestra foi estruturada, no entanto, acho que o Vinícius estava um pouco inseguro; e isso acabou atrapalhou um pouco em alguns momentos.

2. Hugo Lima Borges: Ruby, Rails e empreendedorismo

Esse é um assunto que tem sido muito recorrente em eventos de Ruby on Rails,  o que, com toda certeza, é um ponto muito positivo. Eu não me lembro de ter visto este tema rolar em eventos de Java, por exemplo. Mas a palestra, em si, achei meio frustrante pela superficialidade como o assunto foi abordado.

(Aliás, Hugo, você já empreendeu seu próprio negócio? Se sim, queria trocar umas figurinhas com você.)

3. Marcelo Castellani: Ruby no desktop

Não era para ser “Integrando Ruby e Java para facilitar a vida”?

Achei legal os comparativos e as dicas de quais toolkits funcionam melhor em cada SO, mas acho que faltou uma porção caprichada de código ao vivo. Código só no slide é um pouco chato. O legal é ver o código no slide, mas rodando no terminal também. Fica a dica.

4. Rodrigo Franco: Outsorcing, ou como trabalhar para empresas gringas

Para quem não sabe, esse cara é o Caffo, fundador da lista Rails-BR, que além de ser veiaco de Rails, também é muito experiente no que se propos a palestrar. Ele trabalhar com outsourcing, se não estou enganado, desde 2004.

Sua palestra foi muito, muito, interessante e todo mundo ficou muito intere$$ado mesmo. :)

A grande dia foi: Quer ser um pinguim com colar de ouro? oDesk.

Mas para isso, antes de mais nada, tenha uma conta ativa no GitHub; um blog que apenas copia notícias de outras fontes, mas que fala do que você pensa e sabe; uma página de portifólio e depoimentos também vai muito bem (segundo o Caffo, é indisponsável).

5. Mauricio Leal: GlassFish on Rails: Escalabilidade e Confiabilidade

Tema interessantíssimo para mim, uma palestra que eu estava realmente ansioso para ver. Acho que foi a que mais me decepcionou.

O Mauricio tem uma boa desenvolvura como palestrante, domina a oratória, mas sua palestra foi mais marketing - a Sun apoia Ruby, Rails e Open Source! - do que uma palestra técnica sobre o GlassFish. Como o próprio Fábio Kung, convidado pelo Mauricio, disse: O GlassFish é muito bom, mas o modo que a Sun tem o vendido à comunidade Ruby tem sido bem desadequada.

6. Carlos Brando: Só imaturos não testam

O Carlos é um cara que fala bem, sabe se expressar e sua palestra foi legal. Foi mais voltada a iniciantes em testes, mas bem legal. Na minha opinião, da próxima vez ele poderia abordar tópicos mais avançados de testes, cenários mais elaborados, etc.

Mas no geral, a palestra foi boa. Rolou até um marketzinho do Remarkable.

7. Willian Molinari: O que é e como funciona o RubyLearning

O RubyLearning é um site bem legal mesmo, ótimo não só pra quem está começando, mas para quem já tem algum conhecimento. Mas uma mini palestra para falar dele, não sei, não achei muito legal não. Acho que um post do tipo FAQ no RubyInside e no GURU-SP seria um apoio muito mais eficiente ao ótimo trabalho que o pessoal do RubyLearning tem feito.

Não posso deixar de dizer que o Willian, apesar de parecer bem jovem, soube conduzir muito bem a apresentação.

8. Fábio Kung: Ruby, muito mais do que reflexivo!

Palestra excepcional. O Kung realmente é um ótimo palestrante - instrutor da Caelum, não podia ser diferente.

A palestra dele abordou temas high level de metaprogramação com Ruby. ParseTree, Flog, roodi, Heckle e Ruby2Ruby foram alguns dos mandraques que ele nos apresentou. Foi o momento hacker do dia.

Ah! Além das ferramentas apresentadas, como o Carlos Brando, ele também fez marketing do seu projeto Rfactor.

Conclusão

Valeu a pena participar do evento, trocar idéia com os camaradas e tudo mais. Apesar dos pontos negativos, o resultado final é que o evento foi legal; e os pontos negativos ficam como um toque, para que o próximo evento seja ainda melhor.

Nos vemos no próximo evento!

De 0 a 100 com JRuby on GlassFish

O objetivo deste post é guiar você em sua primeira viagem com JRuby on GlassFish, partindo do zero e terminando com uma pequena aplicação JRuby on Rails rodando num servidor de aplicações GlassFish.

A idéia aqui não é explanar muito profundamente os produtos e assuntos relacionados, mas proporcionar um começo rápido e deixar fontes de pesquisa onde você poderá se aprofundar à medida que desejar.

Por que trabalhar com essa combinação?

A maioria das pessoas que trabalham com desenvolvimento sério de aplicações corporativas, grandes portais e sistemas complexos, que precisam de integração eficiente com sistemas em alta ou baixa plataforma, sabem que a Plataforma Java é excelente para isso.

A linguagem Java, por sua vez, todos nós também sabemos que é um tanto verbosa, isto é verdade, mas ainda assim é muito poderosa; e a combinação desse poder somado à excelência da plataforma e às inumeras API’s, frameworks e ferramentas,  tem se mostrado ser uma ótima opção para implementar outras linguagens. E é aqui que começa a nossa história com JRuby on GlassFish.

  • JRuby é a combinação da beleza e pragmatismo incontestável da linguagem Ruby, com a robustez e credibilidade da consolidada plataforma Java.
  • GlassFish é um reconhecido servidor de aplicações Java EE, parrudão e totalmente compliant com a especificação Java EE 5.

Usar essa a combinação para prover aplicações Rails é sinônimo de:

  • Ambiente de produção maduro e parrudo
  • Deployment facilitado
  • Ferramentas de monitoramento e gerenciamento de aplicação
  • Transação, mensageria, segurança
  • Integração completamente transparente com qualquer código Java
  • … e muito mais!!!

E ai, está motivado a continuar com esse tutorial?

É fato que JRuby é uma implementação de Ruby muito poderosa, rápida, confiável, thread-safe, etc, etc, etc. Mas não acho que faça muito sentido usar JRuby se você não precisa de integração com código Java, seja de um software legado ou mesmo uma API xyz específica. Se este não é o seu caso, aconselho dar uma olhada na combinação Ruby Enterprise Edition + Passenger (a.k.a. mod_rails) da Phusion.

Mãos à obra!

Antes da primeira coisa a fazer, você precisa se certificar de que possui o requisito mínimo necessário para esse tutorial: Um Java SDK instalado em sua máquina. No meu caso, estou com a versão 1.6.0_07. O ideal é que você tenha ao menos a versão 1.5.0. Caso não tenha, você pode fazer o donwload da versão apropriada ao seu SO e instalar conforme as instruções do produto, ou usar seu gerenciador de pacotes favorito. Você decide!

A primeira coisa a fazer: Instalar o JRuby

1- Baixe aqui a versão do JRuby mais atual (eu estou com a 1.2.0RC2);

2- Descompacte ele no diretório onde você deseja manter sua instalação;

3- Defina as variáveis de ambiênte conforme o exemplo a seguir:

# JRUBY-HOME, CLASSPATH and PATH to JRuby 1.2.0RC2
JRUBY_HOME=/home/leandro/ruby/tools/jruby-1.2.0RC2
CLASSPATH=$JRUBY_HOME/lib/jruby.jar:$CLASSPATH
PATH=$JRUBY_HOME/bin:$PATH
export JRUBY_HOME CLASSPATH PATH

4- Veja se está tudo funcionando, digitando no terminal:

$ jruby --version

A saída deve ser algo mais ou menos assim:

jruby 1.2.0RC2 (ruby 1.8.6 patchlevel 287) (2009-03-06 rev 9369) [i386-java]

Se você teve uma saída semelhante a essa, ótimo, tudo parece estar funcionando perfeitamente. Hora de ir para o próximo passo.

A segunda coisa a fazer: Instalar as gem necessárias

Instalar as gems pode demorar um pouquinho, dependendo de o quaão boa é sua conexão de internet. Tenha paciência! :)

Bem, vamos lá. No terminal…

1- Instale a gem jruby-openssl:

$ jruby -S gem install jruby-openssl

Isso se faz necessário porque o JRuby não suporta o openssl padrão do Ruby. Um pequeno detalhe. :)

-S, pra que isso?

O parâmetro -S serve para dizer ao JRuby que você quer que ele use prioritariamente os scripts que estão em seu diretório bin; ou, em segundo caso, no PATH do sistema.

2- Instale o Rails:

$ jruby -S gem install rails --include-dependencies

Esse comando instalará a versão mais atual do Rails, que no caso deste tutorial é a 2.3.2.

3- Instale o adaptador JDBC:

$ jruby -S gem install activerecord-jdbc-adapter

Este adaptador é genérico e possibilita conectar qualquer banco de dados que suporte JDBC. No entanto, ele faz necessário que você configure uma ou duas coisinhas a mais. Mas como no nosso caso vamos tratalhar com MySQL, vamos instalar também o adaptador JDBC especifico para MySQL. (Aliás, assegure-se de ter MySQL 5 instalado.)

$ jruby -S gem install activerecord-jdbcmysql-adapter

4- Instale o GlassFish v3 GEM:

$ jruby -S gem install glassfish

Pronto! Todas as ferramentas necessárias já estão instaladas. Vamos para o próximo [e mais interessante passo].

A terceira coisa a fazer: Criar uma aplicação

Em seu diretório de trabalho, faça o seguinte:

1- Crie uma aplicação Rails:

$ jruby -S rails jogapp

Como somos todos aficcionados por siglas, mandamos uma aqui: jogapp – JRuby on GlassFish Application. :)

Atenção!

A partir daqui, entre no diretório da aplicação jogapp e execute todos os script neste diretório.

2- Configure o banco de dados development no arquivo config/database.yml:

adapter: jdbcmysql
database: jogapp_development
username: root
password: senhadoroot
hostname: localhost

Lembre-se: Estamos usando uma instalação de MySQL 5 local.

3- Crie um cadastro bizarrão básicão:

$ jruby -S script/generate scaffold contato nome:string telefone:string

4- No terminal do MySQL, criar o banco de dados de desenvolvimento:

mysql> create database jogapp_development;

5- Migrar o esquema de banco de dados [para o banco de desenvolvimento]:

$ jruby -S rake db:migrate

Excelente! Tudo está criado e devidamente configurado. Agora…

A quarta coisa a fazer: Rodar a aplicação

Essa é a parte mais dificil. Prepare-se!

$ jruby -S glassfish_rails

É isso. Aqui na minha máquina, que nem é tão parruda assim, em 1 segundo, o GlassFish está de pé.

Agora você já pode abri seu browser preferido – que certamente não é o IE – apontar para a URL http://localhost:3000 para ver sua aplicação rodando no JRuby on GlassFish.

Dificil, não? :)

Pra finalizar, a quinta e última coisa a fazer: Se divertir!

Basta acessar http://localhost:3000/contatos e mandar bala! :)

Espero que você tenha se divertido até aqui, porque eu tenho me divertido bastante mesmo com essa combinação explosiva.

Como você pôde ver nesse tutorial, não há segredo. É muito trivial colocar uma aplicação para todar no GlassFish. É claro que eu também não mostrei nada de mais, além de usar um adaptado JDBC para tirar proveito dessa  ferramenta lapidadíssima e largamente usada no mercado. Vamos ver se logo, logo, eu escrevo um outro artigo mostrando um truque ou dois bem legal de integração com aplicações Java legadas (EJB, por exemplo).

É isso ai. Comentários são bem-vindos!

Sparrow, um cliente JMS baseado em JRuby

Mês passado comecei a tocar um projeto na CVC Turismo que, entre outras coisas, envolve troca mensagens assíncronas usando JMS. Esse trabalho foi está sendo tão divertido que me inspirou a escrever um post sobre Message-Driven Beans e Transações; e mais recentemente, a começar um novo projeto pessoal.

Sparrow é um cliente JMS implementado sobre JRuby e distribuido como uma Rubygem – hospedada no Github,  é claro. Ele é uma boa opção para quem precisa integrar sistemas Ruby com servidores de aplicações Java EE, provedores de mensageria JMS.

É pá, pum! Quer ver?

require 'rubygems'
require 'sparrow'

# Configuração que tem que ser feita uma única vez
jms_client = Sparrow::JMS::Connection::Client.new do |props|
  props.client_jar_file         = '/oc4j_extended_101330/j2ee/home/oc4jclient.jar'
  props.initial_context_factory = 'oracle.j2ee.naming.ApplicationClientInitialContextFactory'
  props.provider_url            = 'ormi://localhost:23791'
  props.security_principal      = 'oc4jadmin'
  props.security_credentials    = 'welcome'
end

jms_client.enable_connection_factories(
    :queue_connection_factory => 'jms/MyQueueCF'
  )

jms_client.enable_queues(
    :my_queue => 'jms/MyQueue'
  )

# Envio
jms_client.queue_sender(:my_queue).send_text_message('sparrow rocks!') do |msg|
  msg.set_string_property('recipient', 'sparrow-example')
end

# Recebimento
jms_client.queue_receiver(:my_queue).receive_message(
    :timeout  => 5000,
    :selector => "recipient = 'sparrow-example'"
  ) do |msg|

  puts msg.is_text_message?    # true
  puts msg.text                # sparrow rocks!
end

Fácil, não? :)

Se você quiser saber mais sobre o projeto, testá-lo, critica-lo, ou algo assim, por favor, não fique acanhado fique à vontade. E se não for pedir demais, deixe um comentário nesse post, como um feedback, para eu saber o quanto ainda preciso melhorá-lo e evoluí-lo.

Valeu!

Foi lançado o JRuby 1.1.4

Foi lançada a versão 1.1.4 do JRuby. O release notes, além de bugs corrigidos, também destaca:

  • Refatoração massiva da camada de integração com Java
  • 2 a 20x mais rápido em muitas funcionalidades (chamadas, construções, arrays)
  • Muitos bugs de longa data na integração com Ruby/Java
  • Funcionalidades existentes mais consistentes e confiáveis
  • Closures podem ser passadas como interfaces para métodos estáticos e construtores
  • Exceptions Java podem ser ser lançadas/resgatadas diretamente a partir do Ruby
  • Melhorias massivas na eficiência da memória (muito menos GC)
  • Início do suporte ao Ruby 1.9 (disponível com flag –1.9)
  • Complexo/rational nativo
  • Eficiência adicional e performance no trabalho do interpretador
  • Menor vazamento de memória –controle de reparos
  • Subsistemas FFI para chamada de bibliotecas C
  • Módulo syslog do Rubinius está funcionando e incluido
  • Iniciado suporte a API win32
  • Thread pooling melhorado (pelo menos usada em produção agora)
  • Acessos concorrentes a array melhorados
  • 72 casos resolvidos desde JRuby 1.1.3

Fico feliz de ver o JRuby crescendo e amadurecendo.

Este é um projeto promissor. Muito promissor!

Executar JRuby a partir do Java

Nos últimos tempos tenho dedicado boa parte do meu tempo livre estudando JRuby. Tem sido uma verdadeira diversão!

Com o objetivo de compartilhar um pouco do que tenho aprendido, eis aqui este post…

Quer dizer que o osrevni inverso também é verdade?

Muito se fala da capacidade do JRuby de acessar código Java de maneira tão natural quanto o faz com seu próprio código – o que é definitivamente fantástico. Mas não tenho visto muitos exemplos de código Java acessando código JRuby. Por quê? Não sei dizer. Talvez porque não tenham visto tanta utilidade nisso. Essa não é minha opinião, já que tenho interesse em implementar algumas coisas em JRuby e usar a partir do Java.

Uma das coisas que fiz nesses meus estudos sobre usar JRuby a partir de Java foi testar o compilador jrubyc para gerar .class, mas não cheguei bem onde eu queria – até troque umas palavras com Charles Nutter a respeito -, porque o .class gerado por ele não é do tipo que se pode instanciar e usar diretamente num código Java, dada a natureza totalmente dinâmica de Ruby. Nas palavras do próprio Charles:

The code compiled by jrubyc is not a “normal” Java class[…] This is not a Java class you can instantiate and call methods on directly from Java[…].

Como não desisti, tenho algumas alternativas para compartilhar.

OBS.: Para executar os exemplos apresentados é necessário ter jruby.jar no classpath do seu projeto. Quando escrevi este post estava usando a versão 1.0, porque não havia uma versão mais atual na máquina que eu estava usando. Mas agora já atualizei o código para a versão 1.1.3.

Primeira alternativa: JRuby puramente Ruby

No exemplo abaixo, criou uma classe Ruby comum – sem qualquer recurso específico do JRuby – e, logo após, a carrego, instancio e executo seu método a partir do Java.

matematica_apenas_ruby.rb

class MatematicaApenasRuby
  def soma(a, b)
    a + b
  end
end

MatematicaApenasRubyTest.java

public class MatematicaApenasRubyTest {
    public static void main(String args[]) throws Exception {
        List pathsLoad = new ArrayList();
        pathsLoad.add("/Workspace/Ruby/IntegracaoJava/lib/");

        Ruby rubyRuntime = JavaEmbedUtils.initialize(pathsLoad);
        rubyRuntime.getLoadService().load("matematica_apenas_ruby.rb", false);

        Object mat_ruby = rubyRuntime.evalScriptlet("MatematicaApenasRuby.new");
        Integer res_ruby = (Integer)JavaEmbedUtils.invokeMethod(rubyRuntime, mat_ruby, "soma", new Integer[] {3, 2}, Integer.class);

        System.out.println("Soma 3 + 2 invocando diretamente JRuby: " + res_ruby);
    }
}

O que esse código Java faz é bem simples, ele:

1- Inicializa um ambiente de runtime para Ruby, indicando onde estão os arquivos .rb;
2- Executa o script de criação da classe MatematicaApenasRuby;
3- Executa o script de instanciação da classe MatematicaApenasRuby;
4- E, por fim, invoca o método soma passando dois parametros.

Que tal, acho simples? Pois muito bem, continuemos…

Segunda alternativa: JRuby implementando Java

Neste segundo exemplo, o que eu faço é criar uma classe JRuby que estende uma classes Java abstrata, o que facilita ainda mais na hora de usar a partir do Java. Vejamos como fica.

matematica_impl_java.rb

require 'java'

class MatematicaImplJava < Java::IntegracaoPoliglota::Matematica
  def soma(a, b)
    a + b
  end
end

Matematica.java

package integracao.poliglota;

public abstract class Matematica {
    public abstract int soma(int a, int b);
}

MatematicaImplJavaTest.java

public class MatematicaImplJavaTest {
    public static void main(String args[]) throws Exception {
        List pathsLoad = new ArrayList();
        pathsLoad.add("/Workspace/Ruby/IntegracaoJava/lib/");

        Ruby rubyRuntime = JavaEmbedUtils.initialize(pathsLoad);
        rubyRuntime.getLoadService().load("matematica_impl_java.rb", false);

        Object mat_impl_java = rubyRuntime.evalScriptlet("MatematicaImplJava.new");
        Matematica matematica = (Matematica)JavaEmbedUtils.rubyToJava(rubyRuntime, (IRubyObject)mat_impl_java, Matematica.class);

        System.out.println("Soma 10 + 2 usando a interface Java: " + matematica.soma(10, 2));
    }
}

E esta alternativa, gostou? Eu gostei bastante. Porque no meu caso, o que eu quero é poder definir uma interface em Java e implementar com JRuby a la Ruby Way e depois usar no Java. É claro que não estou levando em conta o fator “performance”, só estou considerando o fator “alternativa de implemententação”. Só isso.

Mas vamos lá, o que esse código faz?

1- A classe JRuby estende uma classe Java abstrata, como dito antes;
2- A classe que faz o teste, em linhas gerais, faz um cast do objeto JRuby para a classe Java abstrata;
3- E no final das contas, invoca o método da classe Java.

Será que programação poliglota é o futuro?

Se é ou não é, eu não sei. Mas sei que deixei de ser um arquiteto de uma nota só há muito tempo; e estou muito emplogado com JRuby – ele é o melhor dos dois mundos!

E você, o que acha? Deixe um comentário…

Sírius Software em peso na Rails Summit

Ontem fizemos as inscrições dos consultores da Sírius Software para a Rails Summit Latim America 2008.

E você, vai? A gente se vê por lá…