2.4 Zugriff auf Java Objekte

NEXT | PREVIOUS | CONTENT

JNI stellt eine große Anzahl von Zugriffsfunktionen auf lokale und globale Referenzen zur Verfügung. Deshab kann es von vielen JVMs unterstützt werden.

Funktionsdeklaration	Inline-Deklaration für C++
`jint (JNICALL PushLocalFrame) (JNIEnv env, jint capacity);`	`jint PushLocalFrame(jint capacity) { return functions->PushLocalFrame(this,capacity); }`
`jobject (JNICALL PopLocalFrame) (JNIEnv env, jobject result);`	`jobject PopLocalFrame(jobject result) { return functions->PopLocalFrame(this,result); }`
`jobject (JNICALL NewGlobalRef) (JNIEnv env, jobject lobj);`	`jobject NewGlobalRef(jobject lobj) { return functions->NewGlobalRef(this,lobj); }`
`void (JNICALL DeleteGlobalRef) (JNIEnv env, jobject gref);`	`void DeleteGlobalRef(jobject gref) { functions->DeleteGlobalRef(this,gref); }`
`void (JNICALL DeleteLocalRef) (JNIEnv env, jobject obj);`	`void DeleteLocalRef(jobject obj) { functions->DeleteLocalRef(this, obj); }`
`jboolean (JNICALL IsSameObject) (JNIEnv env, jobject obj1, jobject obj2);`	`jboolean IsSameObject(jobject obj1, jobject obj2) { return functions->IsSameObject(this,obj1,obj2); }`
`jobject (JNICALL NewLocalRef) (JNIEnv env, jobject ref);`	`jobject NewLocalRef(jobject ref) { return functions->NewLocalRef(this,ref); }`
`jint (JNICALL EnsureLocalCapacity) (JNIEnv env, jint capacity);`	`jint EnsureLocalCapacity(jint capacity) { return functions->EnsureLocalCapacity(this,capacity); }`

Auf Arrays von Primitiven zugreifen

Problem: Bei Java Objekte mit mit viel Primitiv-Daten (int-Array, ...) ist es unzureichend, jedes Element mit einem Funktionsaufruf zu ermitteln (z.b. bei Matrixoperationen)
eine Möglichkeit, das Problem zu lösen ist pinnen: die native Methode fragt die JVM, die Elmente des Array "festzuhalten" (pin down the elements of the array) und bekommt einen Zugriffszeiger auf die Elemente.
Konsequenzen:
1. Der GC muß pinnen unterstützen
2. Die Primitiv-Arrays müssen im Speicher immer zusammenhängend dargestellt werden. Das ist zwar "natürlich", aber z,b, boolean arrays können packed oder unpacked im Speicher existieren. Code, der sich strikt auf das Layout von Daten im Speicher verläßt, ist nicht mehr portierbar (bzw. eingeschränkt)

Kompromiß:

es gibt JNI-Funktionen, die Daten zwischen einem segment eines Java-Arrays und einem native Buffer kopieren, z.B. wenn man Zugriff auf wenige Elemente eines Array haben möchte


											void (JNICALL *GettypeArrayRegion)

											  (JNIEnv *env, jtypeArray array, jsize start, jsize l,
											jtype *buf);

void GettypeArrayRegion(jtypeArray array, jsize start, jsize len, jtype *buf) { functions->GettypeArrayRegion(this,array,start,len,buf); }

Funktionen, die eine "festgehaltene" (pinned down) Version von Array-Elementen zurückgeben.


											jtype * (JNICALL *GettypeArrayElements)

											    (JNIEnv *env, jtypeArray array, jboolean *isCopy);

jtype * GettypeArrayElements(jtypeArray array, jboolean *isCopy) { return functions->GettypeArrayElements(this,array,isCopy); }

Funktionen, die die VM informieren, daß die down gepinnten Array-Elemente nicht mehr benötigt werden


											void (JNICALL *ReleasetypeArrayElements)

											  (JNIEnv *env, jtypeArray array, jtype *elems, jint mode);

void ReleasetypeArrayElements(jtypeArray array, jtype *elems, jint mode) { functions->ReleasetypeArrayElements(this,array,elems,mode); }

Auf Felder und Methoden zugreifen

JNI identifiziert Felder und Methoden durch ihre Namen und Typsignaturen
Dies ist ein 2 stufiger Prozess:

MethodID ermitteln (diese kann dann mehrmals wieder verwendet werden)


											jmethodID (JNICALL *GetMethodID)

											  (JNIEnv *env, jclass clazz, const char *name, const char *sig);

jmethodID GetMethodID(jclass clazz, const char *name, const char *sig) { return functions->GetMethodID(this,clazz,name,sig); }

Methode aufrufen: nur möglich durch bestimmte JNI-Funktionen


											type (JNICALL *CalltypeMethod)

											  (JNIEnv *env, jobject obj, jmethodID methodID, ...);

type CalltypeMethod(jobject obj, jmethodID methodID, ...) { va_list args; type result; va_start(args,methodID); result = functions->CallShortMethodV(this,obj,methodID,args); va_end(args); return result; }

Nachteil: auch wenn eine FieldID oder MethodID ermittelt wurde, kann die Klasse oder das Objekt aus dem Speicher entfernt werden (unloaded). Deshalb sollte man eine aktive Referenz erhalten.