JRuby: Mit Java und Ruby die Entwicklungsarbeit optimieren

EIn Ruby-Interpreter in Java - das kann doch nur Spielerei sein? Keineswegs: Der Artikel zeigt, wie JRuby die Vorteile zweier Programmiersprachen vereint, und liefert Beispielcode, der den Einstieg erleichtert.

JRuby ist eine 100-prozentige Java-Implementierung eines Ruby-Interpreters. Sie weist zwar nicht alle Funktionen von Ruby auf, verfügt aber dennoch über die meisten der eingebauten Klassen dieser Sprache. ZDNet demonstriert, wie JRuby die positiven Eigenschaften von Java und Ruby kombiniert. Außerdem liefert der Artikel einige wichtige Tipps und ein erstes längeres Code-Beispiel.

Es verseht sich von selbst, dass man sich sowohl mit Java als auch mit Ruby auskennen muss, um optimal mit JRuby zu arbeiten. Reine Java-Programmierer sollten also vielleicht erst einmal die einführenden^[1] Artikel^[2] zu Ruby^[3] lesen, die gleichzeitig die Grenzen dessen abstecken, was hier erläutert wird.

Wo bekommt man JRuby?

Um mit JRuby zu arbeiten, empfiehlt es sich zunächst, die aktuelle Version des Archivs jruby-bin über die Codehaus-Website^[4] zu beschaffen. Es enthält alles, was benötigt wird. Dannach muss die Archivdatei an einem beliebigen Ort extrahiert und der Pfad-Variablen your-jruby-dir/bin hinzugefügt werden.

Nun sollte Folgendes ausgeführt werden können:

jruby -v
ruby 1.8.5 (2007-08-23 rev 4201) [ppc-jruby1.0.1]

Erste Arbeitsschritte

Zunächst wird die interaktive Konsole verwendet, die mit diesem Befehl aufgerufen wird:

jirb
irb(main):001:0>

Da es sich bei JRuby um einen Ruby-Interpreter handelt, können beliebige Ruby-Programmzeilen ausgeführt werden.

irb(main):001:0> puts "Hello World" Hello World => nil irb(main):002:0> [1, 2, 3, 4, 5].each { |n| puts n*n } 1 4 9 16 25 => [1, 2, 3, 4, 5]

Das ist soweit keine Überraschung. Doch der wahre Grund, diese Zeilen so auszuführen, statt mit dem nativen Ruby-Interpreter, besteht darin, sich Java zunutze zu machen. Nun kommt das Java-Framework ins Spiel:

irb(main):003:0> require 'java'
=> true

Der Versuch, einfach einige Standardzeilen Java-Code auszuführen, funktioniert jedoch nicht.

irb(main):004:0> System.out.println("Hello world") NameError: uninitialized constant System from (irb):4:in `binding' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:150:in `eval_input' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:70:in `signal_status' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:147:in `eval_input' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:70:in `each_top_level_statement' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:146:in `loop' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:146:in `catch' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:146:in `eval_input' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:70:in `start' from :1:in `catch' from /Users/chris.duckett/tmp/jruby/jruby-1.0.1/lib/ruby/1.8/irb.rb:69:in `start' from :1

Um das Hello world-Beispiel zum Laufen zu bringen, muss man weit zurückdenken. Es geht um ein paar Angelegenheiten, die einem bei Java bereits selbstverständlich geworden sind.

Ein Besuch auf einer API-Seite^[5], die wohl viele seit langem nicht mehr gesehen haben, bringt die Lösung: System ist ja ein Element des java.lang-Pakets, out ist ein Feld von System und println stellt wiederum eine Methode von out dar.

Deshalb ist für einen korrekten Aufruf Folgendes erforderlich:

irb(main):005:0> java.lang.System::out.println("Hello World")
Hello World
=> nil

Um die Sache interessanter zu machen - auch das funktioniert:

irb(main):005:0> java.lang.System.out.println("Hello World")
Hello World
=> nil

Und um zu zeigen, dass man Ruby und Java in derselben Zeile verwenden kann:

irb(main):006:0>  puts java.lang.System::err.println("Hello World")
Hello World
nil
=> nil

Bis jetzt wurde die Java-Methode zur Übergabe von Parametern verwendet. Dank Ruby kann man jedoch die Klammern weglassen.

irb(main):007:0> java.lang.System::out.println "Hello World"
Hello World
=> nil

Ein weiterer Vorteil von Ruby liegt darin, dass man leicht Einblick in Objekte erlangen kann. Die Reflection-API von Java wird dadurch quasi überflüssig.

Um einen Überblick über alle Methoden zu erhalten, muss einfach die methods-Funktion des Objekts aufgerufen werden, so wie man es auch in Ruby tun würde.

irb(main):008:0> java.lang.Math.methods => ["log", "abs", "cosh", "round", "tanh", "IEEEremainder", "max", "log1p", "sqrt", "rint", "pow", "atan", "min", "to_radians", "asin", "expm1", "ulp", "acos", "signum", "sin", "tan", "to_degrees", "toRadians", "floor", "atan2", "ieeeremainder", "ceil", "exp", "cbrt", "hypot", "cos", "log10", "toDegrees", "sinh", "random", "inherited", "new_proxy", "new", "java_class", "singleton_class", "java_class=", "to_java_object", "[]", "new_instance_for", "superclass", "initialize_copy", "allocate", ">", "autoload", "private_instance_methods", "const_defined?", "instance_method", "const_get", "<=>", "<", "include?", "public_class_method", "module_eval", "protected_method_defined?", "included_modules", "constants", "private_class_method", "protected_instance_methods", "class_eval", "trap", "included", "extended", "autoload?", "const_missing", "to_s", "class_variables", "ancestors", "<=", "const_set", "name", "private_method_defined?", "===", "public_instance_methods", "public_method_defined?", "instance_methods", ">=", "method_defined?", "java_kind_of?", "include_class", "object_id", "frozen?", "eql?", "=~", "methods", "to_a", "tainted?", "javax", "taint", "public_methods", "dup", "method", "==", "singleton_methods", "is_a?", "instance_eval", "equal?", "instance_variable_get", "com", "instance_of?", "hash", "inspect", "java", "org", "__id__", "clone", "__send__", "id", "instance_variable_set", "send", "untaint", "class", "protected_methods", "kind_of?", "instance_variables", "display", "extend", "freeze", "private_methods", "nil?", "type", "instance_exec", "respond_to?"]

Auf ähnliche Weise lassen sich auch die Konstanten ausfindig machen:

irb(main):009:0> java.lang.Math.constants
=> ["PI", "E"]

Oder die Vorläufer einer Klasse:

irb(main):011:0> java.lang.Math.ancestors
=> [Java::JavaLang::Math, Java::JavaLang::Object, 
ConcreteJavaProxy, JavaProxy, JavaProxyMethods, Object, Kernel]

Sogar der Typ der Klasse lässt sich so anzeigen:

irb(main):012:0> java.lang.Math.class
=> Class
irb(main):013:0> java.lang.class
=> Module

Das Ausschreiben der vollständigen Namen von Paketen ist ermüdend. Um eine Klasse zu importieren, lässt sich auch die Funktion include_class einsetzen.

irb(main):015:0> include_class java.lang.System
=> Java::JavaLang::System

Die Klasse lässt sich dann genauso verwenden, als hätte man eine Anweisung in Java importiert.

irb(main):016:0> System.out.println("Wir wurden importiert")
Wir wurden importiert
=> nil

Das Importieren einer Klasse schlägt jedoch fehl, wenn versucht wird, eine Klasse zu laden, die im Ruby-Namensraum bereits existiert.

irb(main):014:0> include_class java.lang.Math
(eval):1 warning: already initialized constant Math
=> Java::JavaLang::Math

Die Lösung liegt hier in der Umbenennung der Klasse. In diesem Fall wird aus der Klasse Math die Klasse JMath.

irb(main):017:0> include_class('java.lang.Math')
{|package,name| "J#{name}"}
=> ["java.lang.Math"]

Diese kann dann folgendermaßen eingesetzt werden:

irb(main):018:0> JMath::PI => 3.141592653589793 irb(main):019:0> JMath.class => Class irb(main):020:0> JMath.ancestors => [Java::JavaLang::Math, Java::JavaLang::Object, ConcreteJavaProxy, JavaProxy, JavaProxyMethods, Object, Kernel]

Bisher handelte es sich um ein paar nette Beispiele, aber nichts wirklich Großes. Nun geht es darum, den Code von dieser Seite^[6] zu nehmen und dieselben Ergebnisse mit Ruby zu erzielen.

Einige Änderungen sind dafür erforderlich:

• Konvertieren der Syntax new <Object>(par1,par2) zu <Object>.new(par1,par2)
• Zugriff auf Felder mit der Syntax GridBagConstraints::HORIZONTAL anstelle von GridBagConstraints.HORIZONTAL
• Entfernen des alten Arrays zur Konstruktion der JCombo-Box:

  
  String[] options = {"all", "any"};
  modeCombo = new JComboBox(options);
  
  

  Hierdurch wird die Combo-Box mit einem Ruby-Objekt bestückt, und die JCombo-Box verträgt das nicht. Um das zu umgehen, fügt man die Elemente einzeln hinzu.

  
  modeCombo = JComboBox.new
  modeCombo.addItem "all"
  modeCombo.addItem "any"
  
  

• Die für Java typische, wortreiche Methode zum Verlassen des Programms, wenn das Fenster geschlossen wird, ändert sich von:

  
  addWindowListener(new WindowAdapter() {
  public void windowClosing(WindowEvent e) {
  System.exit(0);
  }
  });
  
  

  zu einem einfachen:

  
  window.defaultCloseOperation = JFrame::EXIT_ON_CLOSE
  
  

• Die main-Methode wird entfernt.

Der vollständige Code lautet somit:

require 'java' include_class(['javax.swing.JFrame','javax.swing.JLabel','javax.swing.JComboBox','javax.swing.JButton','javax.swing.JPanel','javax.swing.JTable','javax.swing.JTextField', 'java.awt.GridBagLayout', 'java.awt.GridBagConstraints']) window= JFrame.new contentPane = window.getContentPane gridbag = GridBagLayout.new contentPane.setLayout gridbag c = GridBagConstraints.new #setting a default constraint value c.fill = GridBagConstraints::HORIZONTAL tagLbl = JLabel.new("Tags") c.gridx = 0 c.gridy = 0 gridbag.setConstraints tagLbl, c contentPane.add(tagLbl) tagModeLbl = JLabel.new("Tag Mode") c.gridx = 0 c.gridy = 1 gridbag.setConstraints(tagModeLbl, c) contentPane.add(tagModeLbl) tagTxt = JTextField.new("plinth") c.gridx = 1 c.gridy = 0 c.gridwidth = 2 gridbag.setConstraints(tagTxt, c) contentPane.add(tagTxt) modeCombo = JComboBox.new modeCombo.addItem "all" modeCombo.addItem "any" c.gridx = 1 c.gridy = 1 c.gridwidth = 1 gridbag.setConstraints(modeCombo, c) contentPane.add(modeCombo) searchBtn = JButton.new("Search") c.gridx = 1 c.gridy = 2 gridbag.setConstraints(searchBtn, c) contentPane.add(searchBtn) resTable = JTable.new(5,3) c.gridx = 0 c.gridy = 3 c.gridwidth = 3 gridbag.setConstraints(resTable, c) contentPane.add(resTable) previewLbl = JLabel.new("Preview goes here") c.gridx = 0 c.gridy = 4 gridbag.setConstraints(previewLbl, c) contentPane.add(previewLbl) window.defaultCloseOperation = JFrame::EXIT_ON_CLOSE window.pack() window.setVisible(true)

Wenn man aus diesem Listing eine Datei macht, lässt sich diese folgendermaßen in JRuby aufrufen:

jruby testwin.rb

Oberflächlich besteht kein Unterschied zwischen der JRuby- und der Java-Version des Codes. Neben der offensichtlichen Performancebeeinträchtigung durch die Verwendung von JRuby besteht ein klarer Vorteil darin, dass Code mit gleicher Funktionalität weit schneller geschrieben werden kann.

Es lässt sich schon jetzt mit Spannung auf die Geschwindigkeitsverbesserungen warten, die sich ergeben werden, wenn JRuby einen JIT-Compiler erhält. Doch in der Zwischenzeit kann man, falls die Geschwindigkeit nicht so wichtig ist, schon einmal das eine oder andere mit JRuby ausprobieren.

URLs in diesem Artikel:
[1] = http://www.zdnet.de/builder/program/0,39023551,39141885,00.htm
[2] = http://www.zdnet.de/builder/program/0,39023551,39142011,00.htm
[3] = http://www.zdnet.de/builder/program/0,39023551,39157473,00.htm
[4] = http://dist.codehaus.org/jruby/
[5] = http://java.sun.com/javase/6/docs/api/java/lang/System.html
[6] = http://www.zdnet.de/builder/program/0,39023551,39157002-2,00.htm