Ragam solusi yang terdapat di java sangat menarik dan terlalu sayang untuk tidak dimanfaatkan, namun permasalahannya, bagaimana jika kita sudah memiliki sebuah middleware server yang dibangun dengan delphi? Memportingnya ke java jelas bukanlah sebuah solusi yang mudah karena itu bisa berarti menulis ulang keseluruhan sistem dari awal. Solusi yang paling memungkinkan tentunya adalah menginterfacekan middleware server yang dibuat dengan delphi tersebut dengn Java, dengan kata lain meng-embbed java virtual machine ke dalam middleware server Delphi sehingga memungkinkan kita memanfaatkan java dalam sistem yang kita buat dengan menggunakan Delphi.

Bagaimana Caranya?

Cukup sederhana sebenarnya, komunitas delphi, meskipun tidak sebesar komunitas java, namun tidak pula sekecil yang kita pikirkan. Solusi untuk menginterfacekan Delphi dengan Java dengan memanfaatkan JNI telah tersedia dan bisa dimanfaatkan untuk kebutuhan kita. Matthew Mead telah membuat translasi Java Native Interface Wrapper yang memungkinkan Delphi bisa melakukan interfacing dengan kode-kode yang ditulis dengan java. Yang kita butuhkankan hanyalah mendownload wrapper tersebut.
   

• Download Java Native Interface Wrapper

Kita perlu sedikit melakukan modifikasi pada file JNI.pas, mulai pada baris 89 dengan kode berikut:

  JNI_VERSION_1_5 = JInt($00010005);
  {$EXTERNALSYM JNI_VERSION_1_5}
  JNI_VERSION_1_6 = JInt($00010006);
  {$EXTERNALSYM JNI_VERSION_1_6}

{$DEFINE DYNAMIC_LINKING}

Strukturisasi class yang terdapat dalam wrapper tersebut bisa dikatakan cukup baik, kita hanya perlu memastikan hanya ada satu instance class TJavaVM dalam keseluruhan aplikasi kita. Barangkali akan timbul pertanyaan, middleware umumnya berbasis multithread, dan menggunakan single instance seperti itu tentunya akan beresiko tinggi, atau setidaknya menurunkan performa karena harus melakukan locking dan sinkronisasi setiap akan menggunakannya. Kita tidak perlu kuatir untuk hal ini karena kita tidak akan menggunakan object instance dari TJavaVM secara langsung, melainkan untuk tiap-tiap thread kita membuat satu instance dari class TJNIEnv dengan menggunakan TJavaVM sebagai referer.

Inisialisasi JavaVM

Mari kita lanjutkan dengan membuat inisialisasi TJavaVM pada class utama aplikasi, bisa main class, atau main server object class, bergantung pada bagaimana struktur class yang terdapat dalam middleware yang dibuat.

type
  TServerManager = class(TAbstractLifeCycle)
  ...
  private
    FJavaVM: TJavaVM;
    procedure InitializeVM(FEngine: TJavaVM);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    property JavaVM: TJavaVM read FJavaVM;
  end;

...
const
  CJVM_Path = 'C:\Java\jdk1.6.0_04\jre\bin\client\jvm.dll';

constructor TServerManager.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  ...
  FJavaVM := TJavaVM.Create(JNI_VERSION_1_6, CJVM_Path);
end;

destructor TServerManager.Destroy;
begin
  FJavaVM.Free;
  ...
  inherited Destroy;
end;

procedure TServerManager.InitializeVM(FEngine: TJavaVM);
var
  Options: array [0..4] of JavaVMOption;
  VM_args: JavaVMInitArgs;
  Errcode: Integer;
begin
  Options[0].optionString := '-Djava.class.path=.'; // tambahkan library lain pada classpath jika diperlukan
  VM_args.version := JNI_VERSION_1_6;
  VM_args.options := @Options;
  VM_args.nOptions := 1;
  Errcode := FEngine.LoadVM(VM_args);
  if Errcode < 0 then
    Raise Exception.Create(Format('Error loading JavaVM, error code = %d', [Errcode]));
end;

Pastikan method InitializeVM dipanggil hanya sekali setelah object class utama itu di-create, namun jangan menggabungkannya pada constructor TServerEngine karena bisa menyebabkan memory leakage jika penanganan atas itu keliru.

begin
  FServerManager := TServerManager.Create(Self)
  FServerManager.InitializeVM(FServerManager.JavaVM);
end;

Seperti yang telah disebutkan sebelumnya, sebelum kita mulai melakukan invoking method java dari delphi, kita harus membuat terlebih dulu satu buah instance dari class TJNIEnv untuk tiap-tiap process thread dari middleware tersebut dengan menggunakan object instance TJavaVM sebagai referer.

type
  TServerCommandHandler = class(TBaseCommandHandler)
  ...
  private
    FJNIEnv: TJNIEnv;
    FServerManager: TServerManager;

    procedure SetServerManager(AValue: TServerManager);
  public   

    property JNIEnv: TJNIEnv read FJNIEnv;
    property Servermanager: TServerManager read FServerManager write SetServerManager;
  end;

procedure TServerCommandHandler.SetServerManager(AValue: TServerManager);
begin
   if AValue = FServerManager then
      exit;
   if AValue = nil then
   begin
      if Assigned(FJNIEnv) then
          FreeAndNil(FJNIEnv);
   end else
   begin
      if Assigned(FJNIEnv) then
          FreeAndNil(FJNIEnv);
      FJNIEnv := TJNIEnv.Create(AValue.JavaVM.Env);
   end;
   FServerManager := AValue;
end;

Invoking Java Method dari Delphi

Untuk melakukan pemanggilan atas method Java melalui delphi dari process thread tersebut, kita tinggal menggunakan object instance TJNIEnv yang telah dibuat sebelumnya. Implementasi pada bagian ini sangat beragam, dan bisa menjadi sangat kompleks bergantung pada tipikal task yang dikerjakan di sisi middleware yang dibuat, namun contoh yang paling sederhananya adalah sebagai berikut:

var
  Cls: JClass;
  Mid: JMethodID;
  JStr: JString;
begin
  Cls := FJNIEnv.FindClass('FunctionTest');
  if Cls = nil then
    LogAndRaise('Can''t find class: FunctionTest');
  Mid := FJNIEnv.GetStaticMethodID(Cls, 'sayHello', '(Ljava/lang/String;)Ljava/lang/String;');
  if Mid = nil then
    LogAndRaise('Can''t find method: sayHello');

   // Call the static method
  JStr := FJNIEnv.CallStaticObjectMethod(Cls, Mid, ['Hello World']);

  // Convert the returned JString to a Delphi string
  DataMessage.Reply(FJNIEnv.JStringToString(JStr));
end;

Kode java yang akan dipanggil dalam hal ini adalah sebagai berikut:

public class FunctionTest{

  public static String sayHello(String inputHello)
  {
    String hello = "Hello World";
    return hello;
  }
}

Seberapa begitu menarikkah Jython ini dibanding CPython? Perlu diketahui, CPython saat ini memiliki kelemahan jika digunakan dalam mesin-mesin berbasis multi-core karena keberadaan GIL membuatnya secara internal hanya satu thread yang aktif dieksekusi (meski sebenarnya ada beberapa thread yang berjalan bersamaan), akibatnya tentu saja hanya 1 CPU yang bisa termanfaatkan. Sebenarnya hal ini bisa sedikit banyak diminimalisir dengan memporting kode-kode yang bersifat kritikal ke dalam extenstion module yang dibuat dengan native language, namun besar kecilnya manfaat sangat bergantung pada bagaimana model kerja kode dalam python yang dieksekusi, begitu juga dengan membuat process instance, dan beberapa solusi lainnya. Saya tidak ingin panjang lebar membahas lebih jauh tentang ini, Guido punya alasan yang kuat dan benar yang mendasari kenapa GIL tetap harus dipertahankan setidaknya di Python300 nanti.

Jython dalam hal ini menawarkan fitur yang menjadi keterbatasan CPython saat ini, mendukung multithread dengan memanfaatkan fitur threading dalam JVM dan mentransformasi python code menjadi java byte code sehingga secara logika tingkat performanya lebih kurang setara seperti halnya kode Java aslinya. Namun demikian, tidak berarti Jython berada di atas segala-galanya atas CPython, karena dikembangkan dengan menggunakan Java sebagai basis, otomatis memiliki kelemahan atas kompatibilitas dengan extension module yang banyak menggunakan native language sebagai pendukungnya.

Sejauh ini implementasi yang saya gunakan dengan memanfaatkan CPython sudah cukup memuaskan, skalabilitas implementasi masih bisa dieksplorasi secara lebih jauh seiring dengan masih adanya opsi-opsi yang bisa dipilih terkait dengan isue ini, namun demikian Jython tetap menarik untuk dieksplorasi, sebagai alternatif paling akhir apabila memang tidak ada lagi pilihan untuk itu guna meningkatkan skalabilitas platform system yang ada saat ini.