4141#include " runtime/runtime_state.h"
4242#include " util/defer_op.h"
4343#include " util/jni-util.h"
44+ #include " util/jni_plugin_registry.h"
4445#include " util/pretty_printer.h"
4546
4647namespace doris {
@@ -192,7 +193,6 @@ void retain_resources_after_failed_close(std::unique_ptr<PaimonJniMemoryManager>
192193// JNI helpers — class loading
193194// ────────────────────────────────────────────────────────────
194195
195- static constexpr const char * PAIMON_JNI_WRITER_CLASS = " org/apache/doris/paimon/PaimonJniWriter" ;
196196const char * const PAIMON_JNI_WRITER_OPEN_SIGNATURE =
197197 " (Ljava/lang/String;Ljava/util/Map;[Ljava/lang/String;JLjava/lang/String;ZZLjava/lang/"
198198 " String;JJJ)V" ;
@@ -213,7 +213,7 @@ JniPaimonWriteBackend::~JniPaimonWriteBackend() {
213213}
214214
215215Status JniPaimonWriteBackend::close () {
216- if (_jni_writer_obj == nullptr && _jni_writer_cls == nullptr ) {
216+ if (_jni_writer_obj. uninitialized () ) {
217217 _memory_manager.reset ();
218218 _arrow_schema.reset ();
219219 _spill_session.reset ();
@@ -224,38 +224,23 @@ Status JniPaimonWriteBackend::close() {
224224 JNIEnv* env = nullptr ;
225225 Status env_status = Jni::Env::Get (&env);
226226 if (!env_status.ok ()) {
227- bool java_users_may_exist = _jni_writer_obj != nullptr ;
228- // JNI global references cannot be released without an environment.
229- // Deliberately abandon the handles so the Java writer remains alive.
230- _jni_writer_obj = nullptr ;
231- _jni_writer_cls = nullptr ;
232- if (java_users_may_exist) {
233- retain_resources_after_failed_close (std::move (_memory_manager),
234- std::move (_spill_session));
235- } else {
236- _memory_manager.reset ();
237- _spill_session.reset ();
238- }
227+ // JNI global references cannot be released without an environment. Leave the wrapper
228+ // intact so its destructor can release the reference if the thread can attach later.
229+ retain_resources_after_failed_close (std::move (_memory_manager), std::move (_spill_session));
239230 _arrow_schema.reset ();
240231 _opened = false ;
241232 return env_status;
242233 }
243234
244235 Status close_status = Status::OK ();
245- if (_jni_writer_obj != nullptr ) {
236+ if (!_jni_writer_obj. uninitialized () ) {
246237 _refresh_memory_profile ();
247- if (_close_id == nullptr ) {
248- close_status = Status::InternalError (" PaimonJniWriter.close method is unavailable" );
238+ if (_writer_api == nullptr ) {
239+ close_status = Status::InternalError (" Paimon JniWriter API is unavailable" );
249240 } else {
250- env->CallVoidMethod (_jni_writer_obj, _close_id);
251- close_status = _check_jni_exception (env, " close PaimonJniWriter" );
241+ close_status = _jni_writer_obj.call_void_method (env, _writer_api->close ).call ();
252242 }
253- env->DeleteGlobalRef (_jni_writer_obj);
254- _jni_writer_obj = nullptr ;
255- }
256- if (_jni_writer_cls != nullptr ) {
257- env->DeleteGlobalRef (_jni_writer_cls);
258- _jni_writer_cls = nullptr ;
243+ _jni_writer_obj.reset (env);
259244 }
260245
261246 if (close_status.ok ()) {
@@ -349,40 +334,28 @@ Status JniPaimonWriteBackend::open(const TPaimonTableSink& sink, RuntimeState* s
349334 }
350335 Defer pop_local_frame ([&]() { env->PopLocalFrame (nullptr ); });
351336
352- // Step 1: Load PaimonJniWriter class through ScannerLoader (Paimon jars are
353- // not on the default application classpath, so FindClass won't work).
354- Jni::LocalObject local_writer_class;
355- RETURN_IF_ERROR (
356- Jni::Util::get_jni_scanner_class (env, PAIMON_JNI_WRITER_CLASS , &local_writer_class));
357- auto writer_class = static_cast <jclass>(local_writer_class.get ());
358- _jni_writer_cls = static_cast <jclass>(env->NewGlobalRef (writer_class));
359- RETURN_IF_ERROR (_check_jni_exception (env, " create global PaimonJniWriter class reference" ));
360- if (_jni_writer_cls == nullptr ) {
361- return Status::JniError (" Failed to create global PaimonJniWriter class reference" );
362- }
363- RETURN_IF_ERROR (PaimonJniMemoryManager::register_natives (env, _jni_writer_cls));
364- RETURN_IF_ERROR (register_paimon_spill_natives (env, _jni_writer_cls));
365-
366- // Step 2: Cache JNI method IDs for write, prepareCommit, abort, close.
367- jmethodID open_id = env->GetMethodID (_jni_writer_cls, " open" , PAIMON_JNI_WRITER_OPEN_SIGNATURE );
368- jmethodID get_arrow_schema_id = env->GetMethodID (_jni_writer_cls, " getArrowSchema" , " ()[B" );
369- _write_id = env->GetMethodID (_jni_writer_cls, " writeArrow" , " (JJ)V" );
370- _prepare_commit_id = env->GetMethodID (_jni_writer_cls, " prepareCommit" , " ()[[B" );
371- _abort_id = env->GetMethodID (_jni_writer_cls, " abort" , " ()V" );
372- _close_id = env->GetMethodID (_jni_writer_cls, " close" , " ()V" );
337+ // Step 1: Create the writer through the isolated Paimon plugin. Asking the returned object for
338+ // its class is the only valid way to reach a concrete class owned by a plugin classloader.
339+ const std::map<std::string, std::string> writer_params;
340+ RETURN_IF_ERROR (Jni::PluginRegistry::create_writer (env, Jni::plugin::PAIMON_WRITER ,
341+ state->batch_size (), writer_params,
342+ &_jni_writer_obj, &_writer_api));
343+ Jni::LocalClass writer_class;
344+ RETURN_IF_ERROR (Jni::Util::get_object_class (env, _jni_writer_obj, &writer_class));
345+ auto raw_writer_class = static_cast <jclass>(writer_class.get ());
346+ RETURN_IF_ERROR (PaimonJniMemoryManager::register_natives (env, raw_writer_class));
347+ RETURN_IF_ERROR (register_paimon_spill_natives (env, raw_writer_class));
348+
349+ // Step 2: Cache the Paimon-specific method IDs. The common close method comes from WriterApi.
350+ jmethodID open_id =
351+ env->GetMethodID (raw_writer_class, " open" , PAIMON_JNI_WRITER_OPEN_SIGNATURE );
352+ jmethodID get_arrow_schema_id = env->GetMethodID (raw_writer_class, " getArrowSchema" , " ()[B" );
353+ _write_id = env->GetMethodID (raw_writer_class, " writeArrow" , " (JJ)V" );
354+ _prepare_commit_id = env->GetMethodID (raw_writer_class, " prepareCommit" , " ()[[B" );
355+ _abort_id = env->GetMethodID (raw_writer_class, " abort" , " ()V" );
373356 RETURN_IF_ERROR (_check_jni_exception (env, " resolve PaimonJniWriter methods" ));
374357
375- // Step 3: Create the Java PaimonJniWriter instance.
376- jmethodID ctor_id = env->GetMethodID (_jni_writer_cls, " <init>" , " ()V" );
377- jobject local_obj = env->NewObject (_jni_writer_cls, ctor_id);
378- RETURN_IF_ERROR (_check_jni_exception (env, " create PaimonJniWriter" ));
379- _jni_writer_obj = env->NewGlobalRef (local_obj);
380- RETURN_IF_ERROR (_check_jni_exception (env, " create global PaimonJniWriter object reference" ));
381- if (_jni_writer_obj == nullptr ) {
382- return Status::JniError (" Failed to create global PaimonJniWriter object reference" );
383- }
384-
385- // Step 4: Create a lazy query-scoped spill session. Java requests its path only when Paimon
358+ // Step 3: Create a lazy query-scoped spill session. Java requests its path only when Paimon
386359 // first uses the IOManager, so a memory-only writer does not depend on spill storage.
387360 auto * spill_file_manager = state->exec_env ()->spill_file_mgr ();
388361 if (spill_file_manager != nullptr ) {
@@ -392,7 +365,7 @@ Status JniPaimonWriteBackend::open(const TPaimonTableSink& sink, RuntimeState* s
392365 spill_relative_path, state->get_query_ctx (), &_spill_session));
393366 }
394367
395- // Step 5 : Build Java arguments and call PaimonJniWriter.open().
368+ // Step 4 : Build Java arguments and call PaimonJniWriter.open().
396369 const std::map<std::string, std::string> empty_config;
397370 jstring j_serialized_table = env->NewStringUTF (sink.serialized_table .c_str ());
398371 Jni::LocalObject j_hadoop_config;
@@ -413,15 +386,16 @@ Status JniPaimonWriteBackend::open(const TPaimonTableSink& sink, RuntimeState* s
413386
414387 PaimonJniWriterOpenMode open_mode = PaimonJniWriterOpenMode::from_write_mode (sink.write_mode );
415388 env->CallVoidMethod (
416- _jni_writer_obj, open_id, j_serialized_table, j_hadoop_config.get (), j_cols,
389+ _jni_writer_obj. get () , open_id, j_serialized_table, j_hadoop_config.get (), j_cols,
417390 static_cast <jlong>(sink.transaction_id ), j_commit_user, open_mode.overwrite ,
418391 open_mode.changelog , j_time_zone, static_cast <jlong>(_memory_manager->memory_limit ()),
419392 reinterpret_cast <jlong>(_memory_manager.get ()),
420393 _spill_session == nullptr ? 0 : reinterpret_cast <jlong>(_spill_session.get ()));
421394 Status st = _check_jni_exception (env, " open PaimonJniWriter" );
422395
423396 if (st.ok ()) {
424- st = _get_paimon_arrow_schema (env, _jni_writer_obj, get_arrow_schema_id, &_arrow_schema);
397+ st = _get_paimon_arrow_schema (env, _jni_writer_obj.get (), get_arrow_schema_id,
398+ &_arrow_schema);
425399 }
426400 if (st.ok ()) {
427401 _opened = true ;
@@ -439,8 +413,8 @@ Status JniPaimonWriteBackend::create_writer( // NOLINT(readability-make-member-f
439413 std::unique_ptr<IPaimonWriter>* writer) {
440414 DORIS_CHECK (_opened);
441415 DORIS_CHECK (_arrow_schema != nullptr );
442- *writer = std::make_unique<JniPaimonWriter>(_jni_writer_obj, _write_id, _prepare_commit_id ,
443- _abort_id, _arrow_schema);
416+ *writer = std::make_unique<JniPaimonWriter>(_jni_writer_obj. get () , _write_id,
417+ _prepare_commit_id, _abort_id, _arrow_schema);
444418 return Status::OK ();
445419}
446420
0 commit comments