Free Form RPG et java

JNI : RPG & Java

Free Form RPG : intégration avec java

Il est possible de déclarer et d'utiliser depuis RPG4 :

des méthodes Java
des objets (retournés par Java ou destinés à être retournés)

Il est aussi possible de déclarer

des fonctions RPG4 devant être utilisées depuis java

Quelques rappels

java est un langage orienté objet
en java un objet est matérialisé par une Classe (CLASS en anglais)
cette classe encapsule (contient et protège)
- des variables, souvent privées c.a.d non visibles de l'extérieur
  - ces variables peuvent être des données élémentaires
    (octet, entier, numérique à virgule flottante, ..)
  - ou bien elle même des objet (String par exemple est un objet)
- des méthodes (ou fonctions) chargée de traiter et/ou de retourner les variables sus nommées.
Une de ces méthodes peut porter le même nom que la classe (on parle alors de constructeur)
elle est chargée de réaliser l'initialisation lors de la création d'une instance de l'objet en mémoire.

Déclarations

D'un objet

Spécif D	D maChaine S O CLASS(*JAVA : 'java.lang.string')
FreeForm	dcl-s machaine object(*JAVA : 'java.lang.String');

D'un constructeur ( New en Java)

Spécif D	D newString PR O EXTPROC(JAVA : 'java.lang.string':CONTRUCTOR)
FreeForm	dcl-pr newstring object EXTPROC(JAVA : 'java.lang.String': CONSTRUCTOR);

D'une méthode (la méthode toString de l'objet Date qui retourne un objet String)

Spécif D	D Date2String PR O CLASS(JAVA : 'java.lang.String') EXTPROC(JAVA : 'java.lang.Date': 'toString')
FreeForm	dcl-pr date2string object(Java : 'java.lang.String) EXTPROC(JAVA : 'java.lang.Date': 'toString') ;

Équivalence des différents types de données :

 +-----------------+------------------+----------------------------------+
 +  Java           +  Free RPG        +  commentaires                    +
 +-----------------+------------------+----------------------------------+
 +   Boolean       +   IND            +  indicateur                      +
 +-----------------+------------------+----------------------------------+
 +   Byte          +   INT(3)         +  un octet binaire                +
 +                 +                  +   (pas de conversion)            +
 +                 +   CHAR(1)        +  un caractère                    +
 +                 +                  +   (conversion ASCII/EBCDIC)      +
 +-----------------+------------------+----------------------------------+
 +   Byte[]        +   CHAR(1) DIM(x) +  tableau d'octets                +
 +-----------------+------------------+----------------------------------+
 +   Short         +   INT(5)         +  entier court (deux octets)      +
 +-----------------+------------------+----------------------------------+
 +   Int           +   INT(10)        +  entier (quatre octets)          +
 +-----------------+------------------+----------------------------------+
 +   Long          +   INT(20)        +  entier long (8 octets)          +
 +-----------------+------------------+----------------------------------+
 +   float         +   FLOAT(4)       +  flottant (4 octets)             +
 +-----------------+------------------+----------------------------------+
 +   double        +   FLOAT(8)       +  flottant (8 octets)             +
 +-----------------+------------------+----------------------------------+
 +   Char          +   UCS2(1)        +  1 octets en UCS-2 (unicode)     +
 +-----------------+------------------+----------------------------------+
 +   Char[]        +   UCS2(n)        +  n octets en UCS-2 (unicode)     +
 +-----------------+------------------+----------------------------------+
 +  un objet       +   OBJECT         +  CLASS(*JAVA : ..)               +
 +-----------------+------------------+----------------------------------+
 +  tableau        +     ?  DIM(x)    +  vous pouvez faire un tableau    +
 +                 +                  +   de n'importe quelle définition +
 +-----------------+------------------+----------------------------------+

La plupart des chaînes sont à taille variable :

pour les variables caractères (UCS-2) utilisez VARUCS2

Pour les tableaux de caractères, indiquez OPTIONS(*VARSIZE)

Appel et passage de paramètres :

il existe deux types de méthode en Java.

1/ les méthodes statiques ou méthodes de classe, elles sont déclarées

Static typeretour nomMethode() {

}

elle ne s'appuient pas sur une instance pour réaliser le traitement,

vous devrez ajouter STATIC, lors du prototypage RPG.

2/ les méthodes qui s'appuient sur une instance (un objet en mémoire)

VOUS DEVREZ AJOUTER un paramètre aux paramètre(s) déclaré(s) dans le prototype: le nom de l'objet instancié.

-> en Java: dat1.toString
-> en RPG : DateversString(dat1)
Exemple de comparaison de deux chaines

**free
ctl-opt dftactgrp(*no) actgrp(*caller) THREAD(*SERIALIZE);

dcl-pr newstring object EXTPROC(*JAVA : 'java.lang.String': *CONSTRUCTOR) ;
*n varchar(30) const;
END-PR;
dcl-pr StrEquals ind EXTPROC(*JAVA : 'java.lang.String': 'equalsIgnoreCase') ;
*n Object(*JAVA : 'java.lang.String') ;
end-pr;

dcl-s machaine1 object(*JAVA : 'java.lang.String');
dcl-s machaine2 object(*JAVA : 'java.lang.String');

// création de deux objets "String"
maChaine1 = newstring('test1');
maChaine2 = newstring('test2');

// méthode equalsIgnoreCase pour les comparer
if StrEquals(maChaine1 : maChaine2) ;
dsply 'identique' ;
else;
dsply 'différents' ;
endif;
*inlr = *on;

et voici ce que montre la fenêtre structure

Pour appeler une méthode java depuis RPG4

Nous l'avons vu, utiliser directement la méthode, ou bien CALLP si la méthode ne retourne pas de valeur (void).

RPG va vérifier si la JVM (machine virtuelle Java, "run-time" java) est démarrée, sinon, il la démarre.

Vous pouvez la démarrer par pgm (et l'arrêter) en utilisant les API JNI.
- Java possède sont propre ramasse-miettes (mécanisme qui permet à la JVM de détruire les objets de la mémoire quand ils ne sont plus utilisés)
  Dans ce cas, Java ne sait plus, et nous devons donc supprimer les instances, nous même, toujours avec les API JNI.
Enfin, si vous utilisez des classes non standard, précisez le CLASSPATH par :

ADDENVVAR ENVVAR(CLASSPATH) VALUE('/mesclasses/:classes/autresclasses.jar')
il faut renseigner JAVA_HOME (toujours variable d'environnement) pour indiquer la version de java à utiliser (suivant les versions installées)
(Toujours avant de lancer le programme RPG)

si vous n'indiquez pas de version particulière, le système utilise par défaut :
- IBM i 5.4 - Classic 1.4.2 64 bit
- IBM i 6.1 - IT4J 5.0 32 bit
- IBM i 7.1 - IT4J 6.0 32 bit
- IBM i 7.2 - IT4J 7.1 32 bit
- IBM i 7.3 - IT4J 8.0 32 bit
  
  Voir http://www-01.ibm.com/support/docview.wss?uid=nas8N1019917
Exemple plus complet
- Ecriture d'une classe dateEnlettres
- Compilation, création d'un fichier jar
- Ajout dans le classpath
- Pgm RPG
- Exécution
Avec un paramètre en entrée
- classe java
- RPG
- Résultat
Il arrive que certaines classes soient des classes internes (des classes dans la classe)

par exemple base64 de java8 https://docs.oracle.com/javase/8/docs/api/java/util/Base64.html

Elles sont alors notées en RPG avec un $

Utilisation

Résultat

A l'inverse, pour lancer une fonction RPG4 depuis une classe JAVA , vous devrez :

1/ coder le prototype avec EXPORT (fonction publique, visible)

2/ créer un programme de service et le placer dans *LIBL.

2/ déclarer votre programme de service en JAVA par :

static                                 
 {                                     
   System.loadLibrary("MONSRVPGM");   
 }                                                          

(static) native boolean verifClient(byte nomDuClient[]);

bien sûr il faut ensuite envoyer des arguments compatibles avec le type attendu, par exemple :

if ( verifClient(str.getBytes() )
- si vous souhaitez un code RPG4 simple, envoyez des types élémentaires (byte, int , etc...)
- si vous souhaitez un code JAVA simple, envoyez des objets et faites la conversion (par exemple String en Bytes) dans le programme RPG4.

Voyez enfin le projet JDBCR4 (utilisant JNI) permettant de d'utiliser un driver JDBC en RPG