JNI und Cobol

Micro Forcus Cobol DLL aus Java heraus nutzen

Dem Beispiel aus dem Java Tutorial folgend werden wir im Rahmen dieses Artikels eine einfache Kommunikation von Java auf eine Cobol DLL ermöglichen.

Die Entwicklungsumgebung

Für die Entwicklung wurde Micro Focus Net Express 3.1, das J2SDK 1.4.0. Da die generelle Vorgehensweise immer gleich ist können Sie jedoch auch mit einer anderen Net Express oder Java Development Kit Version arbeiten.

Günstig ist es wenn Sie zudem das Java Tutorial bei der Hand haben und dies ergänzend und erweiternd zu dem Artikel nutzen.

Das Java Native Interface [JNI]

Mit dem JNI wird es dem Java Programmierer ermöglicht auch sogenannte Native Codeteile zu nutzen. Dies kann mehrere Gründe haben: sei es die notwendige Performance oder die Wiederverwendung bereits erstellter Komponenten. Um uns nicht ganz so im Regen stehen zu lassen hat uns Sun Microsystem glücklicherweise mit einem eigenen kleinen Kapitel in dem Java Tutorial gesegnet.

Hallo Cobol Welt

Wir werden im folgenden das "Hello World!" Beispiel ("Writing Java Programs with Native Methods") nachvollziehen.

Schritt 1 – Unser Net Express

Net Express bietet für unser kleines Beispiel bereits eine ausreichende Java Unterstützung. Wir werden daher jetzt unser Net Express und das zugehörige Projekt einrichten.

Als erstes legen wir im "NetExpress\Base\Bin\" Verzeichnis sofern noch nicht vorhanden die Datei "Mfj.cfg" an. In dieser muss der Aufruf des Java Compiler stehen, damit wir unsere Java Quelltexte direkt in Net Express kompilieren können. Der Inhalt sollte ähnlich der folgenden Zeile sein:

"d:\programme\java\j2sdk1.4.0\bin\javac.exe -target 1.2 -g –deprecation "

Ein Leerzeichen am Ende ist hier auf jeden Fall empfehlenswert; die Anführungszeichen fallen weg. Die genaue Beschreibung der Parameter entnehmen Sie der Dokumentation Ihres Compilers.

Als nächstes werden wir Net Express noch mit einem kleinen Werkzeug – der Kommandozeile versehen. Dazu öffnen wir den Dialog "Options/Customize..." in unserer Net Express DIE und nehmen die nachfolgenden Einstellungen vor:
Command Line [CMD] aus Net Express aufrufen
Dies ermöglicht uns später eine Kommandozeile mit genau der Umgebung, welche auch unter unserem Net Express Projekt vorliegt zu starten.

Dann endlich legen wir unsere neues Projekt an.
Neues Projekt in Net Express anlegen um von Java Cobol zu nutzen

Schritt 2 – Java Quelltext erstellen

Nun kommen wir auch schon zu dem Punkt, warum Sie zum Anfang die Datei "Mfj.cfg" erstellt haben. Wir fügen nunmehr einen Java Quelltext dem Projekt hinzu. Sofern die Datei noch nicht in der Baumansicht auftaucht fügen Sie diese der Baumansicht hinzu. Der Inhalt des Java Quelltextes ist analog zum Java Tutorial Schritt 1 gehalten:

public class Sender {
  public native void displayCobolWorld();
  static {
    try {
      System.loadLibrary("CobolWriter");
    }
    catch (UnsatisfiedLinkError ule) {
      System.err.println ("Anwendungsfehler beim Laden der DLL "+ule.getMessage());
      System.exit (-1);
    }
  }
  public static void main(final String[] args) {
    try {
      new Sender().displayCobolWorld();
    }
    catch (UnsatisfiedLinkError ule) {
      System.err.println ("Anwendungsfehler beim Aufruf der Methode "+ule.getMessage ());
    }
  }
}
Wie im Tutorial deklarieren wir die Ausgabeoperation als native Methode.

public native void displayCobolWorld(); Im statischen Block sorgen wir dafür, dass unsere DLL namens "CobolWriter.dll" geladen wird. Die Extension müssen wir hierbei weglassen. Hier sehen Sie bereits die kleine Erweiterung zum Tutorial Beispiel – wir fangen unsere Fehler ab.
    try {
      System.loadLibrary("CobolWriter");
    }
    catch (UnsatisfiedLinkError ule) {
      System.err.println ("Anwendungsfehler beim Laden der DLL "+ule.getMessage());
      System.exit (-1);
    }
Der Rest ist das kleine Java 1x1 und bereitet uns keine Schwierigkeiten.

Schritt 3 – Compilieren des Java Quelltextes

Dies bereitet uns keine Probleme, da wenn wir unser Projekt bauen auch gleichzeitig die Java Klassen gebaut werden (entspricht Schritt 2 des Java Tutorials). Über unser neues Werkzeug "CMD" können wir mit dem Aufruf der Java Klasse "java Sender" auch gleich unsere Fehlertoleranz testen.

Schritt 4 – Erstellen des Cobol Quelltextes

Dieser Schritt ist nicht ganz so einfach. Für den Einstieg reicht es jedoch zu wissen, dass die Entrys unserer Cobol DLL in ganz bestimmter Art und Weise aufgebaut sein müssen. Die Schnellansicht auf eine C DLL zeigt uns hier näheres:
Schnellansicht eine Cobol Windows DLL für den Aufruf aus Java
Klar sehen wir hier, dass hier der Aufruf "_Java_C_displayCWorld" exportiert wird. Dies liegt daran, dass das Werkzeug "javah" folgenden C Quelltext erzeugt / erzeugen möchte:

#include <jni.h>
#include "JavaMeetsC.h"
#include <stdio.h>
JNIEXPORT void JNICALL
Java_C_displayCWorld(JNIEnv *env, jobject obj) {
  printf("Hello C World!\n");
  return;
}
Wenn Sie über die entsprechenden zu inkludierenden Header verfügen (z.B. ein installierter C Compiler wie der Visual C++ 6.0 AE von Microsoft) können Sie auch schnell erfahren, wie demnach unser Cobol Modul exportiert werden muss:
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class Sender */
#ifndef _Included_Sender
  #define _Included_Sender
  #ifdef __cplusplus
    extern "C" {
  #endif
  /*
   * Class:     Sender
   * Method:    displayCobolWorld
   * Signature: ()V
   */
  JNIEXPORT void JNICALL Java_Sender_displayCobolWorld (JNIEnv *, jobject);
  #ifdef __cplusplus
    }
  #endif
#endif
Wir sehen der exportierte Einsprungspunkt muss mit "Java_" beginnen, gefolgt von der aufrufenden Klasse "Sender_" und mit dem Namen unserer Operation enden. Dies verrät uns auch das Java Tutorial:
Java MethodenaufrufsyntaxJava Methodenaufrufsyntax Teil 2
Beginnen wir also mir dem Hinzufügen einer Cobol Quelltext Datei mit dem Namen "Java_Sender_displayCobolWorld.cbl". Diese fügen wir unserer Baumansicht hinzu und geben als Zielformat eine Object-Datei (*.obj) an. Das ganze verpacken wir noch in eine DLL, welche wir mit CobolWriter benennen.
Micro Focus Net Express 3.1 Screenshot eines Projekte zum Aufruf von Cobol Modulen aus Java
Und nun kommen wir zum Inhalt.
      $set CASE
       display "Hallo Welt!"
Da Micro Focus es uns sehr einfach macht reichen hier zwei Zeilen aus. Zuerst müssen wir uns der Cobol Besonderheit nicht zwischen Groß- und Kleinschrift zu unterscheiden entledigen. Die Direktive CASE hilft uns hier. Und schliesslich geben wir noch unseren Text aus. Damit haben wir nun endlich den Schritt 4 des Java Tutorials abgehandelt.

Schritt 5 – Compilieren des Cobol Quelltextes

Mit der Namensgebung unserer Quelltextdatei und der Verpackung in einer DLL haben wir hier bereits 99 Prozent erledigen. Einmal neu bauen und die DLL wird erstellt.

Schritt 6 – Anwendung starten

Hier können wir analog zum Java Tutorial ein "java Sender" in unserem Werkzeug CMD nutzen um die Ausgabe "Hallo Welt" zu erhalten.

all rights reserved © Bastie - Sebastian Ritter @: w³: http://www.Bastie.de
Diese Seite ist Bestandteil der Internetpräsenz unter http://www.Bastie.de


Java Cobol Software Resourcen Service Links Über mich Zum Gästebuch Forum