¿Cómo detectar la excepción JNI/Java?

Tengo una capa JNI en mi aplicación. En algunos casos, Java lanza una excepción. ¿Cómo puedo obtener la excepción de Java en la capa JNI? Tengo el código algo como lo siguiente.

if((*(pConnDA->penv))->ExceptionCheck(pConnDA->penv))
{
    (*(pConnDA->penv))->ExceptionDescribe(pConnDA->penv); 
    (*(pConnDA->penv))->ExceptionClear(pConnDA->penv);
}

¿Este bloque de código capturará solo las excepciones de JNI? ¿Dónde se registrará la descripción de la excepción en la consola (STDERR)? ¿Cómo ingreso esto en el búfer, para poder pasarlo a mi módulo de registro?

si invoca un método Java de JNI, llamando ExceptionCheck despues volvere JNI_TRUE si Java lanzó una excepción.

si solo está invocando una función JNI (como FindClass), ExceptionCheck le dirá si eso falló de una manera que deja una excepción pendiente (como FindClass hará en caso de error).

ExceptionDescribe salidas a stderr. no hay una manera conveniente de hacer que vaya a otro lado, pero ExceptionOccurred te da un jthrowable si quieres jugar con él, o simplemente puedes dejarlo subir a Java y manejarlo allí. ese es el estilo habitual:

jclass c = env->FindClass("class/does/not/Exist");
if (env->ExceptionCheck()) {
  return;
}
// otherwise do something with 'c'...

tenga en cuenta que no importa el valor que devuelva; el código Java que llama nunca lo verá; en su lugar, verá la excepción pendiente.

Este es un complemento de la respuesta de Elliott Hughes. Mi respuesta proporciona un ejemplo paso a paso que explica cómo detectar excepciones y cómo traducirlas entre palabras de C++ y Java usando el JNI capa.

Respuesta corta

Vea la respuesta correcta de Elliott Hughes.

ejemplo reutilizable

Esta respuesta y los fragmentos son de dominio público o CC0 para facilitar su reutilización. Todo el código fuente aquí es compatible con versiones anteriores de C ++ 03.

Para reutilizar el fragmento anterior, haga lo siguiente:

• Reemplazar mypackage::Exception por su propia excepción de C++.
• Si la excepción de Java correspondiente my.group.mypackage.Exception no está definido, entonces reemplace "my/group/mypackage/Exception" por "java/lang/RuntimeException".

Captura excepciones de Java

Véase también el fragmento de coliru.

void rethrow_cpp_exception_as_java_exception()
{
    try
    {
        throw; // This allows to determine the type of the exception
    }
    catch (const mypackage::Exception& e) {
        jclass jc = env->FindClass("my/group/mypackage/Exception");
        if(jc) env->ThrowNew (jc, e.what());
        /* if null => NoClassDefFoundError already thrown */
    }
    catch (const std::bad_alloc& e) {
        jclass jc = env->FindClass("java/lang/OutOfMemoryError");
        if(jc) env->ThrowNew (jc, e.what());
    }
    catch (const std::ios_base::failure& e) {
        jclass jc = env->FindClass("java/io/IOException");
        if(jc) env->ThrowNew (jc, e.what());                          
    }                                                               
    catch (const std::exception& e) {
        /* unknown exception (may derive from std::exception) */
        jclass jc = env->FindClass("java/lang/Error");
        if(jc) env->ThrowNew (jc, e.what());
    }
    catch (...) {
        /* Oops I missed identifying this exception! */
        jclass jc = env->FindClass("java/lang/Error");
        if(jc) env->ThrowNew (jc, "Unidentified exception => "
          "Improve rethrow_cpp_exception_as_java_exception()" );
    }
}

Agradezco a Mooing Duck por su contribución al código C++ anterior.

Adaptar el código fuente generado por JNI

el siguiente archivo Java_my_group_mypackage_example.cpp usa lo anterior rethrow_cpp_exception_as_java_exception() función:

JNIEXPORT jlong JNICALL Java_my_group_mypackage_example_function1
        (JNIEnv *env, jobject object, jlong value)
{
  try {
    /* ... my processing ... */
    return jlong(result);
  } catch(...) {
    rethrow_cpp_exception_as_java_exception();
    return 0;
  }
}
   
JNIEXPORT jstring JNICALL Java_my_group_mypackage_example_function2
        (JNIEnv *env, jobject object, jlong value)
{
  jstring jstr = 0
  try {
    /* ... my processing ... */
    jstr = env->NewStringUTF("my result");
  } catch(...) {
    rethrow_cpp_exception_as_java_exception();
  }
  return  jstr;
}

JNIEXPORT void JNICALL Java_my_group_mypackage_example_function3
        (JNIEnv *env, jobject object, jlong value)
{
  try {
    /* ... my processing ... */
  } catch(...) {
    rethrow_cpp_exception_as_java_exception();
  }
}

Código Java correspondiente

Archivo example.java

package my.group.mypackage;

public class Example {
  static {
    System.loadLibrary("my-DLL-name");
  }

  public Example() {
    /* ... */
  }

  private native int    function1(int); //declare DLL functions
  private native String function2(int); //using the keyword
  private native void   function3(int); //'native'

  public void dosomething(int value) {
    int result = function1(value);  
    String str = function2(value);  //call your DLL functions
    function3(value);               //as any other java function
  }
}

Nota: “my-DLL-name” se refiere a la biblioteca dinámica producida a partir del código C/C++ anterior compilado. Puede ser my-DLL-name.dll en Windows o my-DLL-name.so en GNU/Linux/Unix.

Pasos

1. Generar example.class de example.java (usando javac o maven o su IDE favorito Eclipse/Netbeans/IntelliJ IDEA/…)

2. Generar archivo de encabezado C/C++ Java_my_group_mypackage_example.h de example.class usando javah

En el caso, cuando la excepción de Java ocurre en una llamada de C++ anidada, no se hace con un retorno simple, sino que prefiere eliminar los niveles intermedios de la pila de acuerdo con el mecanismo de lanzamiento.

Resolví esto con un

class JavaException : public std::exception
{
};

Luego, en una llamada anidada, donde se genera la excepción

void nestedMethod()
{
    env->CallVoidMethod(...); // Java call creating Exception
    if (env->ExceptionCheck())
    {
        throw JavaException();
    }
}

Finalmente volviendo a Java

void JNI_method(JNIenv *env)
{
    try
    {
        doComplexCall(); // --> nestedMethod()
    }
    catch(const JavaException&)
    {
        //coming from positive ExceptionCheck()
        return;
    }
}