Skriptsprachen für Java

Jacl, Jython, JRuby

Jacl

  1. Einführung

    2. Jacl steht für "Java Command Language" und ist ein in Java geschriebener Tcl Interpretierer ohne eine Toolkit (Tk) Implementierung. Der Entwickler, der den Tcl-Interpretierer 1997 in Java als Student geschrieben und veröffentlicht hat, war Ioi Lam. Doch inzwischen arbeitet vor allem Mo DeJong von RedHat an Jacl, welches zum Tcl/Java-Projekt gehört. Die aktuelle Version ist 1.4.0, die am 21.08.2006 erschienen ist. Die bedeutendste Erweiterung der aktuellen Version ist der "Tcl to Java Compiler" (TJC), welcher ein Tcl Skript in Java-Byte-Code konvertiert, der dann direkt in der JVM ausführbar ist. Dadurch kann ein von TJC kompiliertes Programm 10 bis 20 mal schneller ausgeführt werden, als beim Interpretieren. Der TJC kann in zwei Arten benutzt werden, entweder in Laufzeit oder im Stapelbetrieb.

    Zur offiziellen Homepage

  2. Anwendungsbeispiele

    1. Tcl Befehle in Java

      2. In unserem ersten Beispiel geben wir die aktuelle Zeit mit der Nutzung von Tcl wieder. Dafür nutzen wir den Tcl Interpretierer. In diesem Fall werden Befehle in Form von Strings in der Methode eval interpretiert. Bei einem Fehler würde eval eine TclException werfen. Ein Syntaxfehler wäre ein möglicher Fehler. Zum Schluß löschen wir den Interpretierer.

      //Importiert den Jacl Interpreter

      import
       tcl.lang.Interp;
      //Importiert die TclException

      import
       tcl.lang.TclException;

      public class
       Time_As_Code {
      //Gibt die aktuelle Zeit mit Hilfe von Tcl aus

      public static void
       main(String []args)
      try
       {
      //Jacl Interpretierer erzeugen

      Interp jacl =
      new
       Interp();
      //eval = führt den String im Interpreter aus

      jacl.eval(
      "set x {Zeit: }"
      );
      jacl.eval(
      "set y [clock format [clock seconds] -format %k:%M:%S]"
      );
      jacl.eval(
      "puts [append z $x $y]"
      );
      //Interpreter löschen

      jacl.dispose();
      } 
      catch
       (TclException e) {
      System.out.println(
      "TclException: "
       + e.getMessage());
      }
      }
      }

      Diese Art der Implementierung von Tcl ist nicht gerade benutzerfreundlich und sehr unelegant. Wie man es besser machen kann, sehen wir nun im nächsten Beispiel.

    2. Tcl Datei in Java

      3. Wir lagern nun den Tcl Code in einer Tcl-Datei aus.

      Tcl Datei: time.tcl

      set
       x {Zeit: }
      set
       y [clock format [clock seconds] -format %k:%M:%S]
      puts
       [append z $x $y]

      Nun führen wir die Skriptdatei mit dem Tcl Interpretierer in Java aus. Falls die Datei nicht existiert, wird eine TclException geworfen. So kommen wir auch gleich zur Interaktion zwischen Java und Tcl. In diesem Beispiel holen wir uns nach der Ausführung der Datei die Variable "x", welche in der Datei benutzt wurde, in die Java Welt mit Hilfe der Methode getVar. Nachdem ändern wir die Variable "x" im Tcl Interpretierer.

      Java Code:

      //Importiert den Jacl Interpreter

      import
       tcl.lang.Interp;
      //Importiert die TclException

      import
       tcl.lang.TclException;

      public class
       Time_As_File {
      //Gibt die aktuelle Zeit mit Hilfe von Tcl aus

      public static void
       main(String []args)
      try
       {
      //Jacl Interpretierer erzeugen

      Interp jacl =
      new
       Interp();
      //eval("source Pfad/File") = evalFile("Pfad/File")

      jacl.eval(
      "source C:/Skripte/Jacl/time.tcl"
      );
      //Hier könnte man noch weiter mit den Variablen arbeiten, wie z.B:

      System.out.println(
      "Wert von X ausgeben:"
       + jacl.getVar(
      "x"
      , 0).toString());
      System.out.print(
      "Neuen Wert von X setzen und ausgeben:"
      );
      jacl.eval(
      "set x {Jacl ist toll!!!}"
      );
      System.out.println(jacl.getVar(
      "x"
      ,0).toString());
      //Interpreter löschen

      jacl.dispose();
      }
      catch
      (TclException e) {
      System.out.println(
      "TclException: "
       + e.getMessage());
      }
      }
      }

      So könnte man vor der Ausführung eines Skriptes, die im Sktipt benötigten Variablen als Parameter und Rückgabewert nutzen.

    3. Java Objekte in Tcl

      4. In den beiden vorigen Beispielen ging ich auf die Interaktion der Tcl Variablen in der Java Welt ein. Nun werde ich Ihnen zeigen, wie hingegen Tcl mit Java Elementen arbeitet. Dazu gibt man erst einmal package require java ein. Nun stehen in Tcl eine Reihe neuer Befehle im namensraum "java" zur Verfügung.

      In diesem Beispiel wird in Tcl ein String-Objekt aus Java erzeugt. Dieses Objekt kann auf die Methoden der String Klasse zugreifen, wie z.B. toString(), length(),...

      Legende zur Verdeutlichung:

      Kommentar

      Tcl-Befehle

      Java-Elemente

      Java-Methoden

      Tcl Datei: StringObjectInTcl.tcl:

      #Java Package benutzen

      package require java

      #String Objekt erzeugen

      set
       instance [
      java::new String
       
      "A Java String"
      ]
      #Methodenaufrufe

      puts
       
      "toString-Aufruf '[$instance
      toString
      ]'"

      puts
       
      "length-Aufruf '[$instance
      length
      ]'"

      puts
       
      "charAt-Aufruf(3) '[$instance
      charAt
       3]'"

      #So könnte man instance auf "null" setzen

      #set instance [java::null]

      if
       [ 
      java::isnull
       $instance ] {
      puts
       
      "instance ist leer!"

      } 
      else
       {
      puts
       
      "instance ist nicht leer!"

      }
      java::try
       {
      #Hier wird eine StringIndexOutOfBoundsException geworfen

      puts
       
      "charAt-Aufruf '[$instance
      charAt
       -1]'"

      #So könnte man eine Exception direkt werfen

      #java::throw [java::new Exception "Koennte ja ein Fehler sein..."]

      } 
      catch
       { StringIndexOutOfBoundsException e } {
      puts
       stderr 
      "StringIndexOutOfBoundsException_Jacl: '[$e 
      getMessage
      ]'"

      } 
      catch
       { Exception e } {
      puts
       stderr 
      "Exception_Jacl: '[$e 
      getMessage
      ]'"

      }
      unset
       instance

  3. package require Java

    4. Hier eine kleine Auflistung wichtiger Kommandos des Java-Pakets:

    Kommando Aufgabe
    java::new Klassenname Argumente erzeugt neue Java-Objekte
    java::call Klassenname Methodenname Argumente ruft statische Methoden auf
    java::field Klasse/Objekt Feldname [Wert] fragt oder setzt Objektattribute
    java::instanceof Java-Objekt Klassenname wie "instanceof" in Java
    java::null gibt das Java-Objekt "null" zurück
    java::isnull Objekt testet Java-Objekt gegen "null"
    java::throw Throwable wirft eine Java-Exception
    java::try Skript catch {Klassenname Variable} Skript finally Skript Das Äquivalent zu Javas Try/Catch/Finally-Konstrukt
    java::import Klassen/Paketname Das Äquivalent zu Java "import"

    Eine Liste aller Befehle des Paketes finden Sie hier

  4. Tcl Blend

    5. Eine weitere Tcl-Java-Kopplung ist Tcl Blend. Es verbindet den in C implementierten Tcl-Interpreter und die JVM über ihre Java Native Interface (JNI). Tcl Blend besitzt den vollen Umfang von Tcl und Tk, jedoch vor dem Einsatz von Tcl Blend steht ein größerer Kompilierungsaufwand als in Jacl bevor. Daher ist Jacl die einfachere Alternative. Die Java-spezifischen Tcl-Funktionen sind bei Jacl und Tcl Blend identisch, beide verwenden das "java"-Paket.

  5. Fazit

    6. Vorteile:

    Nachteile:

Autor: Michael Kaluza