Bagian Satu. Prompt Apakah saya perlu membaca artikel ini?
Pemuat kelas Java sangat penting untuk pengoperasian sistem Java, tetapi sering kali kita mengabaikannya. Pemuat kelas Java memuat kelas saat runtime dengan mencari dan memuatnya. Pemuat kelas khusus dapat sepenuhnya mengubah cara kelas dimuat, mempersonalisasi mesin virtual Java sesuai keinginan Anda. Artikel ini secara singkat memperkenalkan pemuat kelas Java, dan kemudian mengilustrasikannya melalui contoh pembuatan pemuat kelas khusus. Pemuat kelas ini akan secara otomatis mengkompilasi kode sebelum memuat kelas. Anda akan mempelajari apa yang sebenarnya dilakukan oleh pemuat kelas dan cara membuatnya sendiri. Selama Anda memiliki pengetahuan dasar Java, mengetahui cara membuat, mengkompilasi, dan menjalankan program Java baris perintah dan beberapa konsep dasar file kelas Java, Anda dapat memahami isi artikel ini. Setelah membaca artikel ini, Anda seharusnya dapat:
* Perluas fungsi mesin virtual Java
* Buat pemuat kelas khusus
* Cara mengintegrasikan pemuat kelas khusus ke dalam aplikasi Anda
* Ubah pemuat kelas Anda agar kompatibel dengan Java 2
Bagian 2. Pendahuluan Apa yang dimaksud dengan pemuat kelas?
Perbedaan Java dengan bahasa lainnya adalah Java berjalan di Java Virtual Machine (JVM). Ini berarti bahwa kode yang dikompilasi disimpan dalam format yang tidak bergantung pada platform, bukan dalam format yang berjalan pada mesin tertentu. Format ini memiliki banyak perbedaan penting dari format kode tradisional yang dapat dieksekusi. Secara khusus, tidak seperti program C atau C++, program Java bukanlah file eksekusi independen, namun terdiri dari banyak file kelas terpisah, masing-masing file kelas terkait dengan kelas Java. Selain itu, file kelas ini tidak langsung dimuat ke dalam memori, tetapi dimuat saat program membutuhkannya. Pemuat kelas adalah alat yang digunakan di mesin virtual Java untuk memuat kelas ke dalam memori. Selain itu, pemuat kelas Java juga diimplementasikan di Java. Dengan cara ini Anda dapat dengan mudah membuat pemuat kelas Anda sendiri tanpa harus memiliki pemahaman mendalam tentang mesin virtual Java.
Mengapa membuat pemuat kelas?
Sekarang Java Virtual Gold sudah memiliki pemuat kelas, apakah kita perlu membuat yang lain sendiri? Pemuat kelas default hanya mengetahui cara memuat kelas dari sistem lokal. Ketika program Anda dikompilasi sepenuhnya secara asli, pemuat kelas default umumnya berfungsi dengan baik. Namun salah satu hal yang paling menarik tentang Java adalah betapa mudahnya memuat kelas dari jaringan, bukan hanya secara lokal.
Misalnya, browser dapat memuat kelas melalui pemuat kelas khusus. Ada juga banyak cara untuk memuat kelas. Salah satu hal paling menarik tentang Java adalah Anda dapat menyesuaikannya selain dari lokal atau jaringan:
* Secara otomatis memverifikasi tanda tangan digital sebelum menjalankan kode yang tidak tepercaya
* Dekripsi kode berdasarkan kata sandi yang diberikan oleh pengguna
* Buat kelas secara dinamis sesuai kebutuhan pengguna. Apa pun yang Anda pedulikan dapat dengan mudah diintegrasikan ke dalam aplikasi Anda dalam bentuk bytecode. Contoh pemuat kelas khusus jika Anda telah menggunakan appletviewer JDK (Java Software Development Kit) (browser aplikasi kecil) atau lainnya.
Untuk browser tertanam Java, Anda sudah menggunakan pemuat kelas khusus. Ketika Sun pertama kali merilis bahasa Java, salah satu hal yang paling menarik adalah menyaksikan bagaimana Java mengeksekusi kode yang diunduh dari situs web jarak jauh. Jalankan dari situs jarak jauh melalui HTTP
Bytecode yang dikirimkan oleh koneksi P terlihat agak aneh. Ini berfungsi karena Java memiliki kemampuan untuk menginstal pemuat kelas khusus. Browser applet berisi pemuat kelas. Pemuat kelas ini tidak menemukan kelas Java secara lokal. Sebaliknya, ia mengakses server jarak jauh, memuat file bytecode asli melalui HTTP, dan kemudian mengubahnya menjadi kelas Java di mesin virtual Java. Tentu saja pemuat kelas melakukan banyak hal lain: mereka memblokir kelas Java yang tidak aman dan menjaga applet yang berbeda pada halaman berbeda agar tidak saling mengganggu. Echidna, sebuah paket yang ditulis oleh Luke Gorrie, adalah paket perangkat lunak Java terbuka yang memungkinkan beberapa aplikasi Java dijalankan dengan aman di mesin virtual Java. Ini mencegah interferensi antar aplikasi dengan menggunakan pemuat kelas khusus untuk memberikan setiap aplikasi salinan file kelas.
Contoh pemuat kelas kita Sekarang setelah kita mengetahui cara kerja pemuat kelas dan cara mendefinisikan pemuat kelas kita sendiri, kita membuat pemuat kelas khusus bernama CompilingClassLoader (CCL). CCL melakukan kompilasi untuk kami, jadi kami tidak perlu mengkompilasinya sendiri secara manual. Ini pada dasarnya setara dengan memiliki program "make" yang dibangun ke dalam lingkungan runtime kita.
Catatan: Sebelum kita melanjutkan ke langkah berikutnya, perlu dipahami beberapa konsep terkait.
Sistem ini telah ditingkatkan secara signifikan pada JDK versi 1.2 (yang kami sebut sebagai platform Java 2). Artikel ini ditulis di bawah JDK 1.0 dan 1.1, tetapi semuanya akan berfungsi di versi yang lebih baru. ClassLoader juga telah ditingkatkan di Java2.
Pengenalan rinci disediakan di bagian kelima.
Bagian 3. Ikhtisar struktur ClassLoader Tujuan dasar dari pemuat kelas adalah untuk melayani permintaan kelas Java. Ketika mesin virtual Java memerlukan sebuah kelas, ia memberikan nama kelas kepada pemuat kelas, dan kemudian pemuat kelas mencoba mengembalikan instance kelas yang sesuai. Pemuat kelas khusus dapat dibuat dengan mengganti metode yang sesuai pada tahapan yang berbeda. Selanjutnya kita akan mempelajari beberapa metode utama dari class loader. Anda akan memahami apa yang dilakukan metode ini dan cara kerjanya saat memuat file kelas. Anda juga akan mengetahui kode apa yang perlu Anda tulis saat membuat pemuat kelas khusus. Di bagian selanjutnya, Anda akan memanfaatkan pengetahuan ini dan CompilingCl kustom kami
assLoader bekerja sama.
Metode loadClass
ClassLoader.loadClass() adalah titik masuk ClassLoader. Tanda tangan metodenya adalah sebagai berikut:
Kelas loadClass (Nama string, tekad boolean);
Nama parameter menentukan nama lengkap kelas (termasuk nama paket) yang diperlukan oleh mesin virtual Java, seperti Foo atau java.lang.Object.
Parameter penyelesaian menentukan apakah kelas perlu diselesaikan. Anda dapat memahami resolusi kelas sebagai siap dijalankan. Parsing umumnya tidak diperlukan. Jika mesin virtual Java hanya ingin mengetahui apakah kelas ini ada atau ingin mengetahui kelas induknya, penguraian sama sekali tidak diperlukan. Di Java 1.1 dan versi sebelumnya, jika Anda ingin menyesuaikan pemuat kelas, metode loadClass adalah satu-satunya metode yang perlu ditimpa di subkelas.
(ClassLoader diubah di Java1.2 dan menyediakan metode findClass()).
metodedefineClass
DefineClass adalah metode yang sangat misterius di ClassLoader. Metode ini membangun instance kelas dari array byte. Array byte mentah yang berisi data mungkin berasal dari sistem file atau dari jaringan. defineClass mengilustrasikan kompleksitas, misteri, dan ketergantungan platform dari Java Virtual Machine - ia menafsirkan bytecode untuk mengubahnya menjadi struktur data runtime, memeriksa validitas, dan banyak lagi. Tapi jangan khawatir, Anda tidak perlu melakukan semua ini. Sebenarnya Anda tidak bisa menimpanya sama sekali,
Karena caranya dimodifikasi dengan kata kunci final.
MetodetemukanSistemKelas
Metode findSystemClass memuat file dari sistem lokal. Ia mencari file kelas di sistem lokal dan, jika ditemukan, akan menelepon
defineClass mengubah array byte asli menjadi objek kelas. Ini adalah mekanisme default mesin virtual Java untuk memuat kelas saat menjalankan aplikasi Java. Untuk pemuat kelas khusus, kita hanya perlu menggunakan findSystemClass setelah gagal memuat. Alasannya sederhana: pemuat kelas kami bertanggung jawab untuk melakukan langkah-langkah tertentu dalam pemuatan kelas, tetapi tidak semua kelas. Misalnya,
Meskipun pemuat kelas kita memuat beberapa kelas dari situs jarak jauh, masih banyak kelas dasar yang perlu dimuat dari sistem lokal.
Kelas-kelas ini tidak menjadi perhatian kami, jadi kami membiarkan mesin virtual Java memuatnya dengan cara default: dari sistem lokal. Inilah yang dilakukan findSystemClass. Seluruh prosesnya kira-kira sebagai berikut:
* Mesin virtual Java meminta pemuat kelas khusus kami untuk memuat kelas.
* Kami memeriksa apakah situs jarak jauh memiliki kelas yang perlu dimuat.
* Jika ada, kita dapat kelas ini.
* Jika tidak, kami menganggap kelas ini ada di perpustakaan kelas dasar dan memanggil findSystemClass untuk memuatnya dari sistem file.
Di sebagian besar pemuat kelas khusus, Anda harus memanggil findSystemClass terlebih dahulu untuk menghemat waktu mencari dari jarak jauh.
Faktanya, seperti yang akan kita lihat di bagian selanjutnya, mesin virtual Java hanya diperbolehkan memuat kelas dari sistem file lokal ketika kita yakin bahwa kita telah mengkompilasi kode kita secara otomatis.
Metode penyelesaianKelas
Seperti disebutkan di atas, catatan kelas dapat dibagi menjadi pemuatan sebagian (tanpa penguraian) dan pemuatan lengkap (termasuk penguraian). Saat kita membuat pemuat kelas khusus, kita mungkin perlu memanggil resolClass.
MetodefindLoadedClass
findLoadedClass mengimplementasikan cache: ketika loadClass diperlukan untuk memuat sebuah kelas, Anda dapat memanggil metode ini terlebih dahulu untuk melihat apakah kelas tersebut telah dimuat untuk mencegah memuat ulang kelas yang sudah dimuat. Metode ini harus dipanggil terlebih dahulu. Mari kita lihat bagaimana metode ini disusun bersama.
Contoh implementasi loadClass kami melakukan langkah-langkah berikut. (Kami tidak menentukan teknologi spesifik untuk mendapatkan file kelas - mungkin dari jaringan, dari paket terkompresi, atau dikompilasi secara dinamis. Bagaimanapun, yang kami peroleh adalah file bytecode asli)
* Panggil findLoadedClass untuk memeriksa apakah kelas ini telah dimuat.
* Jika tidak dimuat, kita mendapatkan array byte asli.
* Jika array sudah didapat, panggil defineClass untuk mengubahnya menjadi objek kelas.
* Jika array byte asli tidak dapat diperoleh, panggil findSystemClass untuk memeriksa apakah array byte tersebut dapat direkam dari sistem file lokal.
* Jika parameter resolusi benar, panggil resolClass untuk menyelesaikan objek kelas.
* Jika kelas belum ditemukan, lemparkan ClassNotFoundException.
* Jika tidak, kembalikan kelas ini.
Sekarang kita memiliki pemahaman yang lebih komprehensif tentang pengetahuan kerja pemuat kelas, kita dapat membuat pemuat kelas khusus. Pada bagian selanjutnya kita akan membahas CCL.
Bagian 4. MengkompilasiClassLoader
CCL menunjukkan kepada kita fungsi pemuat kelas. Tujuan CCL adalah untuk memungkinkan kode kita dikompilasi dan diperbarui secara otomatis. Begini cara kerjanya:
* Ketika ada permintaan untuk suatu kelas, periksa terlebih dahulu apakah file kelas tersebut ada di direktori dan subdirektori disk saat ini.
* Jika tidak ada file kelas, tetapi ada file kode sumber, panggil kompiler Java untuk mengkompilasi dan menghasilkan file kelas.
* Jika file kelas sudah ada, periksa apakah file kelas lebih lama dari file kode sumber. Jika file kelas lebih lama dari file kode sumber, panggil kompiler Java untuk membuat ulang file kelas.
* Jika kompilasi gagal, atau file kelas tidak dapat dihasilkan dari file sumber karena alasan lain, berikan pengecualian ClassNotFou
ndException.
* Jika Anda belum mendapatkan kelas ini, mungkin kelas ini ada di perpustakaan kelas lain. Panggil findSystemClass untuk melihat apakah kelas ini dapat ditemukan.
* Jika tidak ditemukan, buang ClassNotFoundException.
* Jika tidak, kembalikan kelas ini.
Bagaimana kompilasi Java diimplementasikan?
Sebelum melangkah lebih jauh, kita perlu memahami proses kompilasi Java. Biasanya, kompiler Java hanya mengkompilasi kelas-kelas yang ditentukan. Itu juga akan mengkompilasi kelas terkait lainnya jika diperlukan oleh kelas yang ditentukan. CCL akan mengkompilasi kelas-kelas yang perlu kita kompilasi dalam aplikasi satu per satu. Namun, secara umum, setelah kompiler mengkompilasi kelas pertama,
CCL akan menemukan bahwa kelas terkait lainnya yang diperlukan sebenarnya telah dikompilasi. Mengapa? Kompiler Java menggunakan aturan serupa seperti yang kita lakukan: jika suatu kelas tidak ada atau file sumber telah diperbarui, kelas tersebut akan dikompilasi. Kompiler Java pada dasarnya selangkah lebih maju dari CCL, dan sebagian besar pekerjaan dilakukan oleh kompiler Java. Kami sepertinya CCL sedang mengkompilasi kelas-kelas ini.
Dalam kebanyakan kasus, Anda akan menemukan bahwa ia memanggil kompiler di kelas fungsi utama, dan hanya itu - panggilan sederhana saja sudah cukup. Namun, ada kasus khusus di mana kelas-kelas ini tidak dikompilasi saat pertama kali muncul. Jika Anda memuat kelas berdasarkan namanya, menggunakan metode Class.forName, kompiler Java tidak mengetahui apakah kelas tersebut diperlukan. dalam hal ini,
Anda menemukan bahwa CCL memanggil kompiler lagi untuk mengkompilasi kelas. Kode di Bagian 6 mengilustrasikan proses ini.
Menggunakan KompilasiClassLoader
Untuk menggunakan CCL kita tidak bisa menjalankan program kita secara langsung, harus dijalankan dengan cara khusus seperti ini:
% java Foo arg1 arg2
Kami menjalankannya seperti ini:
% java CCLRun Foo arg1 arg2
CCLRun adalah program rintisan khusus yang membuat CompilingClassLoader dan menggunakannya untuk memuat kelas fungsi utama kita. Ini memastikan bahwa seluruh program dimuat oleh CompilingClassLoader. CCLRun menggunakan Ja
API refleksi va memanggil fungsi utama dari kelas fungsi utama dan meneruskan parameter ke fungsi ini. Untuk mempelajari lebih lanjut, lihat kode sumber di Bagian 6.
Mari kita jalankan contoh untuk mendemonstrasikan cara kerja keseluruhan proses.
Program utamanya adalah kelas bernama Foo, yang membuat turunan kelas Bar. Instance Bar ini pada gilirannya menciptakan sebuah instance dari kelas Baz, yang ada dalam paket baz. Ini untuk mendemonstrasikan bagaimana CCL memuat kelas dari sub-paket. Bar juga memuat kelas Boo berdasarkan nama kelas
, ini juga dilakukan oleh CCL. Semua kelas dimuat dan siap dijalankan. Gunakan kode sumber dari Bab 6 untuk menjalankan program ini. Kompilasi CCLRun dan KompilasiClassLoader. Pastikan Anda tidak mengkompilasi kelas lain (Foo, Bar, Baz, a
dan Boo), jika tidak, CCL tidak akan berfungsi.
% java CCLRun Foo arg1 arg2
CCL: Mengkompilasi Foo.java...
foo! arg1 arg2
batang! arg1 arg2
baz! arg1 arg2
CCL: Mengkompilasi Boo.java...
Huuu!
Perhatikan bahwa kompiler dipanggil untuk pertama kalinya untuk Foo.java, dan Bar serta baz.Baz juga dikompilasi bersama. Dan seperti Boo
Ketika saluran perlu dimuat, CCL memanggil compiler lagi untuk mengkompilasinya.
Bagian 5. Ikhtisar Peningkatan Pemuat Kelas di Java 2 Di Java 1.2 dan versi yang lebih baru, pemuat kelas telah ditingkatkan secara signifikan. Kode lama masih berfungsi, namun sistem baru membuat implementasi kita lebih mudah. Model baru ini adalah model delegasi proxy, artinya jika pemuat kelas tidak dapat menemukan suatu kelas, maka pemuat kelas induknya akan meminta untuk menemukannya. Pemuat kelas sistem adalah nenek moyang dari semua pemuat kelas. Pemuat kelas sistem memuat kelas secara default, yaitu dari sistem file lokal. Mengganti metode loadClass umumnya mencoba beberapa cara untuk memuat kelas. Jika Anda menulis banyak pemuat kelas, Anda akan mendapati bahwa Anda hanya membuat beberapa modifikasi pada metode rumit ini berulang kali. Implementasi default loadClass di Java 1.2 mencakup cara paling umum untuk menemukan kelas, memungkinkan Anda mengganti metode findClass dan loadClass untuk memanggil metode findClass dengan tepat. Keuntungannya adalah Anda tidak perlu mengganti loadClass, Anda hanya perlu mengganti findClass, yang mengurangi beban kerja.
Metode baru: findClass
Metode ini dipanggil dengan implementasi default loadClass. Tujuan dari findClass adalah untuk memasukkan semua kode khusus pemuat kelas,
Tidak perlu mengulangi kode (seperti memanggil pemuat kelas sistem ketika metode yang ditentukan gagal).
Metode baru: getSystemClassLoader
Terlepas dari apakah Anda mengganti metode findClass dan loadClass, metode getSystemClassLoader dapat mengakses pemuat kelas sistem secara langsung (bukan akses tidak langsung melalui findSystemClass).
Metode baru: getParent
Untuk mendelegasikan permintaan ke pemuat kelas induk, pemuat kelas induk dari pemuat kelas ini dapat diperoleh melalui metode ini. Anda dapat mendelegasikan permintaan ke pemuat kelas induk ketika metode tertentu dalam pemuat kelas khusus tidak dapat menemukan kelas tersebut. Pemuat kelas induk pemuat kelas berisi kode yang membuat pemuat kelas.
Bagian 6. Kode sumber
MengkompilasiClassLoader.java
Berikut isi file CompilingClassLoader.java
import java.io.*;
/*
CompilingClassLoader mengkompilasi file sumber Java secara dinamis. Ia memeriksa apakah file .class ada dan apakah file .class lebih tua dari file sumber.
*/
CompilingClassLoader kelas publik memperluas ClassLoader
{
//Tentukan nama file, baca seluruh konten file dari disk, dan kembalikan array byte.
byte pribadi[] getBytes( String nama file ) melempar IOException {
// Dapatkan ukuran file.
File file = File baru (nama file);
panjang len = file.panjang();
//Buat array secukupnya untuk menyimpan konten file.
byte mentah[] = byte baru[(int)len];
//Buka berkas
FileInputStream sirip = FileInputStream baru( file );
// Membaca semua konten. Jika tidak dapat dibaca, terjadi kesalahan.
int r = sirip.baca(mentah);
jika (r != len)
throw new IOException( "Tidak dapat membaca semua, "+r+" != "+len );
// Jangan lupa menutup filenya.
sirip.dekat();
// Kembalikan larik ini.
kembali mentah;
}
// Hasilkan proses untuk mengkompilasi file sumber Java yang ditentukan dan menentukan parameter file. Jika kompilasi berhasil, kembalikan nilai true, jika tidak,
// Mengembalikan salah.
kompilasi boolean pribadi (String javaFile) melempar IOException {
//Tampilkan kemajuan saat ini
System.out.println( "CCL: Kompilasi "+javaFile+"..." );
//Mulai kompiler
Proses p = Runtime.getRuntime().exec( "javac "+javaFile );
// Tunggu hingga kompilasi selesai
mencoba {
p.tunggu();
} catch( InterruptedException yaitu ) { Sistem.keluar.println( yaitu }
// Periksa kode yang dikembalikan untuk melihat apakah ada kesalahan kompilasi.
int ret = p.exitValue();
//Kembalikan apakah kompilasi berhasil.
kembali ret==0;
}
// Kode inti pemuat kelas - memuat kelas secara otomatis mengkompilasi file sumber bila diperlukan.
Kelas publik loadClass (Nama string, tekad boolean)
melempar ClassNotFoundException {
//Tujuan kita adalah mendapatkan objek kelas.
Kelas kelas = null;
// Pertama, periksa apakah kelas ini sudah diproses.
clas = findLoadedClass( nama );
//Sistem.keluar.println( "findLoadedClass: "+kelas );
// Mendapatkan nama path melalui nama kelas, contoh: java.lang.Object => java/lang/Object
String fileStub = nama.ganti( ''''.'''', ''''/'''' );
// Membangun objek yang menunjuk ke file sumber dan file kelas.
String javaFilename = fileStub+".java";
String classFilename = fileStub+".class";
File javaFile = File baru( javaFilename );
File classFile = File baru (nama File kelas);
//Sistem.keluar.println( "j "+javaFile.lastModified()+" c "
//+classFile.lastModified() );
// Pertama, tentukan apakah kompilasi diperlukan. Jika file sumber ada tetapi file kelas tidak ada, atau keduanya ada kecuali file sumber
// Lebih baru, menunjukkan bahwa itu perlu dikompilasi.
jika (javaFile.exists() &&(!classFile.exists() ||
javaFile.lastModified() > classFile.lastModified())) {
mencoba {
// Kompilasi, jika kompilasi gagal, kita harus menyatakan alasan kegagalannya (menggunakan kelas lama saja tidak cukup).
if (!kompilasi( javaFilename ) || !classFile.exists()) {
throw new ClassNotFoundException("Kompilasi gagal: "+javaFilename );
}
} catch(IOException yaitu) {
// Kesalahan IO mungkin terjadi selama kompilasi.
melempar ClassNotFoundException baru(yaitu.toString());
}
}
// Pastikan sudah dikompilasi dengan benar atau tidak memerlukan kompilasi, kita mulai memuat byte mentah.
mencoba {
// Baca byte.
byte mentah[] = getBytes( classFilename );
//Konversikan ke objek kelas
clas = defineClass( nama, mentah, 0, mentah.panjang );
} catch(IOException yaitu) {
// Ini tidak berarti gagal, mungkin kelas yang kita hadapi ada di perpustakaan kelas lokal, seperti java.lang.Object.
}
//Sistem.keluar.println( "defineClass: "+kelas );
//Mungkin di perpustakaan kelas, dimuat dengan cara default.
jika (kelas==null) {
clas = findSystemClass( nama );
}
//Sistem.keluar.println( "findSystemClass: "+kelas );
// Jika parameter resolusi benar, interpretasikan kelas sesuai kebutuhan.
if (selesaikan && kelas != null)
resolClass(kelas);
// Jika kelas belum diperoleh, ada yang tidak beres.
jika (kelas == nol)
melempar ClassNotFoundException baru( nama );
// Jika tidak, kembalikan objek kelas ini.
kelas kembali;
}
}
CCRun.java
Ini file CCRun.java
import java.lang.reflect.*;
/*
CCLRun memuat kelas melalui CompilingClassLoader untuk menjalankan program.
*/
CCLRun kelas publik
{
static public void main( String args[] ) memunculkan Pengecualian {
//Parameter pertama menentukan kelas fungsi utama yang ingin dijalankan pengguna.
String progClass = args[0];
//Parameter selanjutnya adalah parameter yang diteruskan ke kelas fungsi utama ini.
String progArgs[] = String baru[args.length-1];
Sistem.arraycopy( args, 1, progArgs, 0, progArgs.length );
// Buat CompilingClassLoader
CompilingClassLoader ccl = baru CompilingClassLoader();
//Muat kelas fungsi utama melalui CCL.
Kelas kelas = ccl.loadClass( progClass );
// Gunakan refleksi untuk memanggil fungsi utamanya dan meneruskan parameter.
// Menghasilkan objek kelas yang mewakili tipe parameter fungsi utama.
Kelas mainArgType[] = { (String baru[0]).getClass() };
// Temukan fungsi utama standar di kelas.
Metode main = clas.getMethod( "utama", mainArgType );
// Membuat daftar parameter - dalam hal ini, array string.
Objek argsArray[] = { progArgs };
// Panggil fungsi utama.
main.invoke( null, argsArray );
}
}
Foo.java
Berikut isi file Foo.java
kelas publik Foo
{
static public void main( String args[] ) memunculkan Pengecualian {
Sistem.keluar.println( "foo! "+args[0]+" "+args[1] );
Batang baru( args[0], args[1] );
}
}
Bar.java
Berikut isi file Bar.java
impor baz.*;
Bar kelas publik
{
Bilah publik( String a, String b ) {
Sistem.keluar.println( "bar! "+a+" "+b );
Baz baru( a, b );
mencoba {
Kelas booClass = Kelas.forName( "Boo" );
Objek boo = booClass.newInstance();
} tangkapan(Pengecualian e) {
e.printStackTrace();
}
}
}
baz/Baz.java
Berikut isi file baz/Baz.java
paket baz;
kelas publik Baz
{
publik Baz( String a, String b ) {
Sistem.keluar.println( "baz! "+a+" "+b );
}
}
Boo.java
Berikut isi file Boo.java
kelas publik Boo
{
publikBoo() {
System.out.println("Boo!" );
}
}
Bagian 7. Ringkasan Ringkasan Setelah membaca artikel ini, tahukah Anda bahwa membuat pemuat kelas khusus memungkinkan Anda mendalami bagian dalam mesin virtual Java. Anda dapat memuat file kelas dari sumber daya apa pun, atau membuatnya secara dinamis, sehingga Anda dapat melakukan banyak hal yang Anda minati dengan memperluas fungsi-fungsi ini, dan Anda juga dapat menyelesaikan beberapa fungsi canggih.
Topik lain tentang ClassLoader Seperti disebutkan di awal artikel ini, pemuat kelas khusus memainkan peran penting dalam browser tertanam Java dan browser applet.