# Cobol-Aufruf aus Java



## Meifer (31. Aug 2009)

Hallo,

also ich hab zur Zeit ein kleines Problem. Also erstmal die Ausgangslagemomentan: Momentan haben wir ein bestehendes Projekt in AcuCobol und VB, dieses soll schritt-für-schritt in Java umgeschrieben werden. Um die Kommunikation in AcuCobol, VB und Java zu ermöglichen benutzen wir Sockets, diese funktionieren auch einigermaßen so wie sie sollen, allerdings ist dies extrem langsam. 

Also habe ich mir gedacht ich könnte die Kommunikation wie in VB und AcuCobol gestalten, da diese erheblich schneller ist. Und zwar bietet AcuCobol eine Schnittstelle zwischen Cobol und anderen Sprachen (steht so zumindest in der Dokumentation). Dort in der Doku gab es auch ein Beispiel mit VB ist bei unserem Projekt ähnlich umgesetzt worden. Hier mal der Link dazu: LinK

Nun habe ich versucht mit JNA ebenfalls auf diese Befehle zugreifen zu können. Dies hat auch mit AcuInitialize wunderbar funktioniert, habe schon innerlich Freudensprünge gemacht. Dann ging es weiter mit AcuCall, im ersten Augenblick ging dies auch, allerdings hab ich im Nachhinein doch einen Fehler festgestellt. Denn die Parameter (param1 bis param14) haben im Cobol-Programm nicht den Inhalt, den ich in Java übergeben habe. Der Inhalt kommt in Cobol immer gleich an, egal was ich in Java übergebe. Und zwar hat param1 den Wert 471, param2 472 usw...

Jetzt bin ich mit meinem Latein am Ende und schreibe gerade meinen ersten Foreneintrag meines Lebens, wo ich etwas gefragt habe  (auch etwas gutes).

Naja habts ihr vielleicht eine Idee oder sogar ne Lösung für das Problem?


----------



## Marco13 (31. Aug 2009)

Habe mit JNA noch nicht selbst was gemacht (nur mal drübergeschaut), und mit COBOL noch viel weniger (nur davon gehört - aber heute braucht man wohl keine Lochkarten mehr, um das zu programmieren  ) - aber hast du schon versucht (oder in Erwägung gezogen) das ganze direkt mit JNI aufzurufen? Also, vielleicht hat noch jemand eine Idee, woran das beschriebene Verhalten liegen kann, und du solltest vielleicht noch ein bißchen warten, bevor du dich da drauf stürzt (JNA kann sowas soweit ich weiß schon _deutlich_ einfacher und bequemer machen), aber als "Fallback" kann man ja nach sowas wie "calling cobol from java jni" suchen, da findet man einigermaßen ausführliche Anleitungen über COBOL and JNI


----------



## Meifer (31. Aug 2009)

Auf jedenfall schon mal, danke ich hatte schon an JNI und auch schon an Jacob gedacht, allerding hatte ich nur mäßigen Erfolg, aber die Seite, die du mir gegeben hast, weckt neue Hoffnungen in mir 

MFG
Meifer


----------



## Marco13 (31. Aug 2009)

Hmja, aber _eigentlich_ sollte es mit JNA ja funktionieren - vielleicht hat noch jemand eine Idee _dazu_, bevor du dich jetzt in die Tiefen von JNI stürzt...


----------



## Henry_L (1. Sep 2009)

Hi

Wir lösen das ganze über JNI. 

Unsere Software ist in Java geschrieben. Unsere "alten" Herzstücke sind noch COBOL Programme. Diese haben wir in DLLs gepackt uns rufen sie aus Java über C-Wrapperklassen auf.

Wenn Du ein Beispiel brauchst kann ich Dir eine kleine Datei senden.

Gruß
Henry


----------



## Meifer (1. Sep 2009)

Hi,

also danke für das Angebot, wenn es dir nichts ausmacht, würde ich gerne darauf zurückgreifen, weil ich mir das nur bedingt vorstellen kann.

mfg


----------



## Henry_L (2. Sep 2009)

Hier ein kleines stark dezimiertes Beispiel.

TestDialog.java:


```
package test;
...

public class TestDialog extends ... {

  ...
  
  //eingabe/ausgabe array
  byte[] cblInput=new byte[496];

  //Deklaration fuer die nativen Methoden
  public native boolean loadDialog();
  public native boolean cancelDialog();
  public native boolean callDialog(byte[] cblInput);

  ...

  //Konstruktor
  public TestDialog(TEST parent) {

    ...

    //laden von TestDialog.dll
    try {
      System.loadLibrary("TESTWRAP");
    }
    catch(UnsatisfiedLinkError ue) {
      ...
      return;
    }
    catch(SecurityException se) {
      ...
      return;
    }
    
    ...
    
  }
  
  ...
  
  //mache etwas
  protected void ausfuehren() {

    //eingabe array mit blanks initialisieren
    for(int i=0;i<cblInput.LEN;i++)
      cblInput[i]=(byte)' ';
    
    //fuelle daten fuer die uebergabe
    ...
    
    //daten an cobol senden
    if(!callDialog(cblInput)) {
   	  ...
      return;
    }

     //daten aus cobol weiterverarbeiten
     tfield1.setText(new String(cblInput,intOffset,intLength));
     ...
  }

  //beenden
  protected void beenden() {

    //TestDialog.dll freigeben
    cancelDialog();

    ...
  }

  //events
  public void actionPerformed(ActionEvent e) {
    if(e.getSource()==button1) {
	ausfuehren();
    }
    else if(e.getSource()==button2) {
	beenden();
    }
  }
}
```

TESTWRAP.h:

```
#include <jni.h>

JNIEXPORT jboolean JNICALL Java_test_TestDialog_loadDialog (JNIEnv *, jobject);
JNIEXPORT jboolean JNICALL Java_test_TestDialog_cancelDialog (JNIEnv *, jobject);
JNIEXPORT jboolean JNICALL Java_test_TestDialog_callDialog (JNIEnv *, jobject, jbyteArray);
```

TESTWRAP.c:

```
//dll wrapper fuer native aufruf von TestDialog.dll

#include <windows.h>
#include <string.h>
#include "TESTWRAP.h"

typedef void (*TSTPROC)(LPCTSTR);

//instanz der dll und funktionsadressen
HINSTANCE tstinst=NULL;
TSTPROC tstproc=NULL;

//uebergabe array
jbyte *tsteinaus; //496 bytes

//TestDialog.dll laden und funktionsadresse holen
JNIEXPORT jboolean JNICALL Java_test_TestDialog_loadDialog(JNIEnv *env,jobject obj)
{
 if (tstinst != NULL) //damit beim evtl. mehrfachaufruf nicht mehrfach geladen wird
 return TRUE;
 tstinst=LoadLibrary("COBOL.DLL");
 if (tstinst)
 {
  tstproc=(TSTPROC)GetProcAddress(tstinst,"COBOL");
  if (!tstproc)
  {
   //dll freigeben und zurueck
   FreeLibrary(tstinst);
   tstinst=NULL;
   return FALSE;
  }
  return TRUE;
 }
 return FALSE;
}

//TestDialog.dll freigeben
JNIEXPORT jboolean JNICALL Java_test_TestDialog_cancelDialog(JNIEnv *env,jobject obj)
{
 if (!tstinst)
 return FALSE;
 if (!FreeLibrary(tstinst))
 return FALSE;
 tstinst=NULL;
 tstproc=NULL;
 return TRUE;
}

//TestDialog.dll aufrufen
JNIEXPORT jboolean JNICALL Java_test_TestDialog_callDialog(JNIEnv *env,jobject obj,jbyteArray arr)
{
 if (!tstproc)
 return FALSE;
 //array elemente zuweisen
 tsteinaus=(*env)->GetByteArrayElements(env,arr,0);
 if (!tsteinaus) //action nur wenn kein nullzeiger
 return FALSE;
 //action
 (tstproc)(tsteinaus);
 //freigeben
 (*env)->ReleaseByteArrayElements(env,arr,tsteinaus,0);
 //alles ok zurueck
 return TRUE;
}
```

Die TESTWRAP.h und TESTWRAP.c musst Du zu einer DLL kompilieren. 

Wichtig ist hier, dass der Name immer gleich ist (also überall übereinstimmt).

Java:   loadDialog
          cancelDialog
          callDialog
          (loadDialog,... = Funktion für C)

C:       Java_test_TestDialog_loadDialog
          Java_test_TestDialog_cancelDialog
          Java_test_TestDialog_callDialog
          (test = package, TestDialog = Klasse)

Falls Du nch Fragen hast. Melde Dich einfach.


----------

