Java Native Interface

I přesto, že nám platforma virtuálního stroje Javy poskytuje velmi bohaté běhové prostředí, nelze se zcela vyhnout situacím, kdy nám její možnosti nestačí. Toto prostředí s sebou totiž nese i hranice, které v programu není možné překročit. Základní rys virtuálního stroje, který nám zajišťuje nezávislost na platformě nižší úrovně, se tak někdy může stát spíše omezujícím faktorem. Typicky k tomuto dochází, pokud potřebujeme:

• Používat specifické rysy konkrétního operačního systému.
• Komunikovat s hardwarovými zařízeními.
• Využít v naší aplikaci starší, nativní kód nebo naopak v nativním kódu přistupovat k aplikaci běžící uvnitř JVM.

V prvním případě se jedná především o situace, kdy chceme uživateli poskytnout komfort, na který je zvyklý z nativních aplikací, zejména grafické uživatelské rozhraní daného operačního systému.

Bez JNI se také neobejdeme, pokud chceme využívat některá specifická hardwarová zařízení, např. čtečky čárových kódů nebo karet, které nejsou přístupná skrz virtuální stroj a pro které výrobce neposkytuje javovské rozhraní.

Stejně tak je pro nás virtuální stroj nepříjemnou komplikací, pokud potřebujeme komunikovat s již existující nativní aplikací, kterou není možné přepsat do jazyka běžícího nad JVM.

Dalším důvodem pro použití tohoto rozhraní může být také fakt, že nativní kód zkompilovaný pro danou platformu se vykonává rychleji, JNI tedy můžeme využít pro zpracování náročných výpočtů, komplikovaných grafických operací, apod.

Možnost volání nativního kódu je v Javě už od jejího vzniku. Ve verzi Javy 1.0 bylo implementováno rozhraní NMI – Native Method Interface, které umožňovalo spuštění kódu napsaného v jiném jazyce. Toto rozhraní využívalo i mnoho vlastních tříd Javy, především z balíčků java.io a java.net. NMI však mělo několik nevhodných vlastností, kvůli kterým nebylo možné nativní knihovny používat na různých virtuálních strojích[1].

Ve verzi Javy 1.1 se proto objevilo nové rozhraní JNI, které tyto nedostatky odstranilo. Na rozdíl od NMI ho podporují všechny virtuální stroje a nativní knihovny je možné používat s různými virtuálními stroji bez rekompilace. Ve verzích Javy 1.2 a 1.4 pak bylo toto rozhraní výrazným způsobem rozšířeno, změny však zachovávají zpětnou kompatibilitu.

Java Native Interface představuje obousměrné spojení mezi nativním kódem a kódem napsaným v Javě. Rozhraní je tedy možné využít dvěma způsoby:

• Prvním z nich je volání nativního kódu z javovské aplikace. V aplikaci vytvoříme tzv. nativní metodu, kterou pak voláme stejným způsobem, jako jakoukoliv jinou metodu napsanou v Javě. Nicméně ve skutečnosti je prostřednictvím JNI spuštěna metoda, jejíž implementace je napsaná v jiném jazyce a je uložená v nativní knihovně.
• Druhou možností je pak spuštění virtuálního stroje přímo v nativní aplikaci. V nativním kódu vytvoříme propojení na knihovnu, která implementuje virtuální stroj Javy, a pomocí JNI v něm pak můžeme spouštět části aplikace napsané v Javě. Pokud bychom programovali např. internetový prohlížeč v jazyce C++, pomocí JNI bychom v něm takto mohli spouštět applety.

Pokud se rozhodneme využívat JNI pro volání nativních funkcí z kódu napsaného v Javě, je třeba mít na paměti, že to s sebou nese jisté důsledky:

• Především tímto ztrácíme jeden ze základních benefitů jazyka Java, a to podpora nezávislosti na platformě. I když část aplikace napsaná v Javě bude stále přenositelná, nativní knihovny bude nutné znovu přeložit pro každé hostitelské prostředí.
• Dalším výrazným negativem je také fakt, že Java umí být typově bezpečná, zatímco některé nativní jazyky, jako např. C nebo C++, ne. Z tohoto důvodu je nutné věnovat aplikacím využívajícím JNI zvláštní pozornost. Drobná chyba v implementaci nativní metody může způsobit pád celé aplikace. Navíc tyto chyby bývá obvykle velmi těžké ladit nebo reprodukovat.
• Kromě toho rozhraní JNI také neposkytuje žádné prostředky pro automatické uvolňování nepotřebných zdrojů z paměti. Pokud nativní kód alokuje nějaké prostředky, nese také zodpovědnost za jejich uvolnění ve chvíli, kdy již nejsou dále potřebné.

Aby bylo možné z kódu napsaného v Javě zavolat funkci nativní knihovny, je nutné udělat několik kroků[2]. Celý proces je možné shrnout v následujících bodech:

1. Vytvoření javovské třídy, která deklaruje nativní metodu.
2. Přeložení této třídy do byte kódu.
3. Vytvoření hlavičkového souboru se signaturou příslušné metody pro její následnou implementaci.
4. Implementace metody např. v jazycích C, C++, apod.
5. Zkompilování této implementace do nativní knihovny.

Dále jsou tyto kroky podrobněji rozebrány.

public class HelloWorld {
    private native void sayHello();

    public static void main(String[] args) {
        System.loadLibrary("library");
        new HelloWorld().sayHello();
    }
}

javac HelloWorld.java

javah -jni HelloWorld

JNIEXPORT void JNICALL Java_HelloWorld_sayHello
  (JNIEnv *, jobject);

#include <jni.h>
#include <stdio.h>
#include "HelloWorld.h"

JNIEXPORT void JNICALL
Java_HelloWorld_sayHello(JNIEnv *env, jobject obj) {
    printf("Hello World!\n");
    return;
}

gcc -fPIC \
  -I/usr/lib/jvm/java-6-sun-1.6.0.15/include/ \
  -I/usr/lib/jvm/java-6-sun-1.6.0.15/include/linux/ \
  java_Talker.c -shared -o libtalker.so

System.loadLibrary("talker");

Pro smysluplné využití JNI je nutné nativním metodám předávat parametry a získávat návratové hodnoty. Aby toto bylo možné, JNI definuje pro všechny datové typy v Javě jejich ekvivalenty, které je pak možné v nativních metodách používat. Je nutné zde rozlišit, zda se jedná o primitivní nebo objektové datové typy. S ekvivalenty primitivních datových typů lze pracovat přímo. Jejich výčet je v následující tabulce:

Objektové datové typy jsou předávány jako ukazatele na vnitřní datové struktury virtuálního stroje. Uspořádání těchto struktur ale zůstává nativnímu programu skryto. Jediný způsob, jak s těmito daty smysluplně manipulovat, je skrze metody, které poskytuje rozhraní JNI. Ty jsou přístupné přes ukazatel JNIEnv. Toto platí kromě běžných objektů také pro všechna pole a textové řetězce.

public class Talker {
    private native void sayIt(String text);
  
    public static void main(String[] args) {
        System.loadLibrary("library");
        new Talker().sayIt("Saying 'Hello World!' is boring...");
    }
}

JNIEXPORT void JNICALL Java_Talker_sayIt
  (JNIEnv *, jobject, jstring);

#include <jni.h>
#include <stdio.h>
#include "Talker.h"

JNIEXPORT void JNICALL
Java_Talker_sayIt(JNIEnv *env, jobject obj, jstring text) {
    const char *str;
    str = env->GetStringUTFChars(text, NULL);

    if (str == NULL) {
        return; /* Chyba při alokaci paměti */
    }

    printf("%s", str);
    env->ReleaseStringUTFChars(text, str);
    return;
}