Akan lebih mudah jika semua komponen dijalankan pada ruang heap yang sama dari mesin virtual Java yang sama di komputer yang sama, namun dalam praktiknya kita sering menghadapi situasi yang tidak sama. Jika klien hanyalah perangkat yang dapat mengeksekusi Java apa yang harus dilakukan Mengerjakan? Bagaimana jika karena alasan keamanan hanya program di server yang dapat mengakses database?
Kita tahu bahwa dalam banyak kasus, pemanggilan metode terjadi antara dua objek di heap yang sama. Bagaimana jika Anda ingin memanggil metode pada objek di mesin yang berbeda?
Biasanya kita mendapatkan informasi dari satu komputer ke komputer lain melalui aliran input/output dari soket, membuka koneksi soket komputer lain, dan kemudian memperoleh aliran keluaran untuk menulis data komputer, apa saja metode objek pada mesin virtual Java lainnya? Tentu saja, kita dapat mendefinisikan dan merancang sendiri protokol komunikasi untuk dipanggil, dan kemudian mengirimkan kembali hasil eksekusi melalui Socket, dan bisa juga seperti metode pemanggilan di mesin lokal, yaitu jika kita ingin memanggil objek jarak jauh (seperti seperti tumpukan lainnya) ), tetapi seharusnya seperti panggilan biasa.
Inilah yang dihadirkan RMI kepada kita.
Desain panggilan prosedur jarak jauh
Ada 4 hal yang harus dibuat: server, klien, fasilitas tambahan server dan fasilitas tambahan klien.
1. Membuat aplikasi klien dan server. Aplikasi server adalah layanan jarak jauh, sebuah objek dengan metode yang akan dipanggil klien.
2. Buat pembantu sisi klien dan server. Mereka akan menangani semua detail input/output jaringan yang mendasari klien dan server, membuat klien dan program tampak memproses panggilan lokal.
Tugas Fasilitas Auxiliary Fasilitas Auxiliary adalah objek yang benar-benar melakukan komunikasi, membuat klien merasa seolah-olah memanggil objek lokal. Objek klien terlihat seperti memanggil metode jarak jauh, namun sebenarnya hanya memanggil metode A proxy yang menangani detail Socket dan streaming secara lokal. Di sisi server, fasilitas tambahan server akan menghubungkan permintaan dari fasilitas klien melalui soket, mengurai informasi yang dikemas, dan kemudian memanggil layanan sebenarnya, jadi untuk objek layanan ini adalah Setelahnya. memanggil fasilitas tambahan dari layanan lokal, ia mendapatkan nilai kembalian, membungkusnya dan mengirimkannya kembali (melalui aliran keluaran soket) ke fasilitas tambahan klien. Fasilitas tambahan klien membongkar informasi dan mengirimkannya ke objek klien.
Proses memanggil suatu metode
1. Objek klien memanggil doBigThing() pada objek fasilitas tambahan
2. Fasilitas tambahan klien mengemas informasi panggilan dan mengirimkannya ke fasilitas tambahan server melalui jaringan.
3. Fasilitas tambahan sisi server menerjemahkan informasi dari fasilitas tambahan sisi klien dan menggunakannya untuk memanggil layanan sebenarnya.
Diagram yang menggambarkan proses ini adalah sebagai berikut:
JavaRMI menyediakan objek pembantu sisi klien dan sisi server
Di Java, RMI telah membantu kami membuat fasilitas tambahan di sisi klien dan sisi server. Ia juga mengetahui cara membuat fasilitas tambahan di sisi klien terlihat seperti layanan nyata .
Selain itu, RMI menyediakan semua infrastruktur yang diperlukan untuk eksekusi, termasuk permintaan layanan dan fasilitas tambahan yang memungkinkan klien menemukan dan memperoleh klien (agen layanan nyata).
Saat menggunakan RMI, tidak perlu menulis jaringan atau program input/output apa pun. Panggilan klien ke metode jarak jauh sama dengan pemanggilan metode pada mesin virtual Java yang sama.
Panggilan umum sedikit berbeda dari panggilan RMI. Meskipun bagi klien, panggilan metode ini terlihat lokal, namun fasilitas tambahan klien akan melakukan panggilan melalui jaringan. Panggilan ini pada akhirnya akan melibatkan soket dan aliran. dan agen akan mengubahnya menjadi informasi perantara yang dikirim dari mesin virtual Java ke mesin virtual Java bergantung pada protokol yang digunakan oleh objek fasilitas tambahan.
Saat menggunakan RMI, Anda harus memutuskan protokolnya: JRMP atau IIOP. JRMP adalah protokol asli RMI. Ini dirancang untuk panggilan jarak jauh antar Java. Di sisi lain, IIOP diproduksi untuk CORBA, yang memungkinkan kita melakukan panggilan Java. Untuk objek atau metode jarak jauh lainnya, CORBA biasanya lebih merepotkan daripada RMI, karena jika kedua ujungnya bukan Java, banyak operasi penerjemahan dan percakapan yang buruk akan terjadi.
Kami hanya peduli dengan operasi Java-ke-Java, jadi kami akan menggunakan RMI yang cukup sederhana.
Di RMI, fasilitas tambahan di sisi klien disebut stub, dan fasilitas tambahan di sisi server disebut skeleton.
Cara membuat layanan jarak jauh
1.Buat antarmuka jarak jauh
Antarmuka jarak jauh mendefinisikan metode yang dapat dipanggil klien dari jarak jauh. Ini adalah kelas polimorfik sebagai layanan.
2. Implementasikan antarmuka jarak jauh
Ini adalah kelas pelaksana yang sebenarnya. Ini mengimplementasikan metode yang ditentukan pada antarmuka. Ini adalah objek yang akan dipanggil oleh klien.
3. Gunakan rmic untuk menghasilkan stub dan skeleton
Baik klien maupun server memiliki pembantu. Kita tidak perlu membuat kelas-kelas ini atau membuat kode sumber dari kelas-kelas ini. Ini akan ditangani secara otomatis saat menjalankan alat rmic yang terpasang pada JDK.
4. Mulai RMIregistry (rmiregistry)
rmiregistry seperti buku telepon, pengguna akan mendapatkan proxy (objek stub/helper klien) dari sini
5. Mulai layanan jarak jauh
Objek layanan harus mulai dieksekusi. Kelas yang mengimplementasikan layanan akan memulai instance layanan dan mendaftarkannya ke RMIRegistry. Hanya setelah registrasi, objek layanan tersebut dapat melayani pengguna.
Kode pelayan
Tentukan antarmuka
/**
*
*MyRemote.java
*
* Fungsi: TODO
* Nama kelas: MyRemote.java
*
* ver. Pemegang karakter yang diperbarui dan konten baru.
*───────────────────────────────────────────────
* V1.00 2013-3-19 Versi pertama modul Su Ruo
*
* Hak Cipta (c) 2013 dennisit korporasi Semua Hak Dilindungi Undang-undang.
*
* Email:<a href="mailto:[email protected]">Kirim email</a>
*
*
* Remote adalah antarmuka yang ditandai, artinya tidak ada metode. Namun, ini memiliki arti khusus bagi RMI, jadi aturan ini harus diikuti.
* Perhatikan bahwa extends digunakan di sini, dan antarmuka dapat mewarisi antarmuka lain.
*
*/
antarmuka publik MyRemote memperluas Remote{
/**
* Antarmuka jarak jauh mendefinisikan metode yang dapat dipanggil klien dari jarak jauh. Ini adalah kelas polimorfik sebagai layanan
* Memobilisasi stub yang mengimplementasikan antarmuka ini, dan karena stub ini akan menjalankan pekerjaan jaringan dan input/output, berbagai hal dapat terjadi
* Masalah, klien menangani atau mendeklarasikan pengecualian untuk mengenali jenis risiko ini. Jika metode mendeklarasikan pengecualian di antarmuka, panggil metode tersebut
* Semua prosedur harus menangani atau mendeklarasikan ulang pengecualian ini.
*
* Parameter dan nilai kembalian metode jarak jauh harus primitif atau dapat diserialkan
* Paket ditransmisikan melalui jaringan, dan ketika diselesaikan melalui serialisasi, nilai yang dikembalikan akan sama jika tipe khusus digunakan
*, harus berseri
* @kembali
* @melempar RemoteException
* Semua metode di antarmuka harus mendeklarasikan RemoteException
*/
String publik sayHello() menampilkan RemoteException;
}
/**
*
*MyRemoteImpl.java
*
* Fungsi: TODO
* Nama kelas: MyRemoteImpl.java
*
* ver. Pemegang karakter yang diperbarui dan konten baru.
*───────────────────────────────────────────────
* V1.00 2013-3-19 Versi pertama modul Su Ruo
*
* Hak Cipta (c) 2013 dennisit korporasi Semua Hak Dilindungi Undang-undang.
*
* Email:<a href="mailto:[email protected]">Kirim email</a>
*
* Untuk menjadi objek layanan jarak jauh, objek tersebut harus memiliki fungsi yang berhubungan dengan jarak jauh. Metode paling sederhana adalah dengan mewarisi UnicastRemoteObject
* (dari java.rmi.server) agar kelas induk ini yang menangani pekerjaannya
*
*/
kelas publik MyRemoteImpl memperluas UnicastRemoteObject mengimplementasikan MyRemote{
/**
* Konstruktor kelas induk mendeklarasikan pengecualian, jadi Anda harus menulis konstruktornya karena itu berarti konstruktor Anda akan memanggil kode program yang berisiko
*
* UnicastRemoteObject memiliki masalah kecil, konstruktornya menampilkan RemoteException
* Deklarasikan konstruktor untuk implementasi Anda sendiri sehingga ada tempat untuk mendeklarasikan RemoteException Saat kelas diinisialisasi, kelas induk
* Konstruktor pasti akan dipanggil. Jika konstruktor kelas induk mengeluarkan pengecualian, konstruktor khusus yang juga harus kita deklarasikan akan mengeluarkan pengecualian.
* @melempar RemoteException
*/
dilindungi MyRemoteImpl() melempar RemoteException {
}
/**
* Menerapkan semua metode antarmuka keluar, tetapi tidak perlu mendeklarasikan RemoteException
*/
@Mengesampingkan
String publik ucapkanHalo(){
return "server berkata, rmi halo dunia!";
}
public static void main(String[] args) {
mencoba {
/**
* Kami sudah memiliki layanan jarak jauh, dan kami harus mengizinkan pengguna jarak jauh untuk mengaksesnya. Hal ini dapat dilakukan dengan menginisialisasinya dan menambahkannya ke RMI Registry.
* (Ini harus berjalan, jika tidak program ini akan gagal). Saat mendaftarkan objek, sistem RMI akan menambahkan stub ke registri,
* Karena inilah yang dibutuhkan klien. Gunakan rebind() dari java.rmi.Naming untuk mendaftarkan layanan
*/
Layanan MyRemote = baru MyRemoteImpl();
/**
* Buat objek jarak jauh, lalu gunakan Naming.rebind() statis untuk membuat asosiasi. Nama terdaftar akan diberikan untuk permintaan klien
*/
Penamaan.rebind("Remote Hello World", layanan);
} tangkapan (Pengecualian e) {
e.printStackTrace();
}
}
}
kekosongan publik exec(){
mencoba {
/**
* Klien harus mendapatkan objek stub karena klien harus memanggil metodenya. Hal ini tergantung pada registri RMI Klien akan menanyakan jenis telepon
* Cari direktori yang sama untuk menemukan layanan dengan nama yang cocok.
* Klien menanyakan RMIRegistry dan mengembalikan objek stub
* Penamaan.lookup("rmi://127.0.0.1/Remote Hello World");
* Deskripsi parameter
* rmi://127.0.0.1/Remote Halo Dunia
* 127.0.0.1 mewakili nama host atau alamat IP host
* Remote Hello World harus sama dengan nama yang didaftarkan
*
*/
Layanan MyRemote = (MyRemote)Naming.lookup("rmi://127.0.0.1/Remote Hello World");
String tmp = layanan.sayHello();
Sistem.keluar.println(tmp);
} tangkapan (Pengecualian e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
baru MyRemoteClient().exec();
}
}
Alat rmic yang disertakan dengan JDK akan menghasilkan dua kelas, stub dan skeleton, berdasarkan implementasi layanan. Alat ini akan menambahkan _Stub atau _Skeleton setelah nama implementasi jarak jauh sesuai dengan aturan penamaan. rmic memiliki beberapa pilihan, termasuk tidak membuat kerangka, mengamati kode sumber dari kelas yang dihasilkan, atau menggunakan IIOP sebagai protokol komunikasi. Kelas yang dihasilkan akan ditempatkan di direktori saat ini. Oleh karena itu, Anda mungkin perlu menjalankan rmic dari direktori tempat implementasi berada (dalam praktiknya, Anda mungkin perlu mempertimbangkan struktur direktori paket dan nama lengkapnya, untuk mempermudah, paket tidak digunakan di sini)
Panggil baris perintah untuk memulai rmiregistry. Pastikan Anda memulainya dari direktori yang dapat mengakses kelas.
Tangkapan layar yang berjalan adalah sebagai berikut
Melihat:
Klien menggunakan antarmuka untuk memanggil metode pada stub. Mesin virtual Java klien harus memiliki kelas stub, tetapi klien tidak akan mereferensikan kelas stub dalam kode program. Klien selalu mengoperasikan objek jarak jauh yang sebenarnya melalui antarmuka.
Server harus memiliki stub dan skeleton, serta layanan dan antarmuka jarak jauh. Ini memerlukan kelas stub karena stub akan digantikan oleh layanan nyata yang terhubung ke RMIRegistry.
Kesalahan umum saat menggunakan RMI:
1. Lupa memulai rmiregistry sebelum memulai layanan jarak jauh (rmiregistry harus dimulai sebelum menggunakan Naming.rebind() untuk mendaftarkan layanan)
2. Lupa membuat parameter dan tipe kembalian menjadi serial (tidak akan terdeteksi selama kompilasi dan hanya akan ditemukan selama eksekusi)
3. Lupa menyerahkan kelas rintisan kepada klien
RMI sangat cocok untuk menulis dan menjalankan layanan jarak jauh, tetapi kami tidak akan menggunakan RMI sendirian untuk menjalankan layanan situs web. Untuk aplikasi tingkat perusahaan berskala besar, kami memerlukan fungsi yang lebih banyak dan lebih baik seperti manajemen transaksi, pemrosesan bersamaan berskala besar, dan lain-lain. dan keamanan Dan manajemen basis data, dll. Ini memerlukan penggunaan EnterpriseApplicationServer.
Server JavaEE mencakup server Web dan server Enterprise JavaBeans (EJB). Server EJB bertindak antara panggilan RMI dan lapisan layanan.
Penerapan RMI di JINI
Jini juga menggunakan RMI (walaupun protokol lain juga dapat digunakan), namun memiliki beberapa fungsi utama lainnya.
1. Penemuan adaptif
2. Jaringan penyembuhan diri
Klien RMI harus terlebih dahulu mendapatkan alamat dan nama layanan jarak jauh. Kode program kueri klien harus berisi alamat IP atau nama host layanan jarak jauh (karena RMIRegistry ada di dalamnya) dan nama yang didaftarkan oleh layanan.
Namun saat menggunakan JINI, pengguna hanya perlu mengetahui satu hal, antarmuka yang diterapkan oleh layanan itu saja!
Jini menggunakan layanan pencarian, yang lebih kuat dan lebih mudah beradaptasi daripada RMIRegistry. Karena Jini akan secara otomatis beriklan di jaringan. Ketika layanan query online, ia akan menggunakan teknologi IP multicast untuk mengirimkan informasi ke seluruh jaringan online setelah layanan kueri disiarkan, dan klien juga dapat mengirim pesan ke seluruh jaringan untuk menanyakan.
Ketika layanan online, ia akan secara dinamis menjelajahi layanan kueri JINI di jaringan dan mengajukan pendaftaran. Saat mendaftar, layanan akan mengirimkan objek serial ke layanan kueri driver perangkat jaringan. , atau bahkan layanan itu sendiri yang dapat dijalankan pada klien. Dan yang didaftarkan adalah antarmuka yang diimplementasikan.
Cara kerja eksplorasi adaptif
1.Layanan kueri Jini dimulai di jaringan dan menggunakan teknologi multicast IP untuk mempromosikan dirinya
2. Layanan Jini lain yang telah dimulai akan mencoba mendaftar ke layanan kueri yang baru dimulai. Layanan ini akan mendaftarkan fungsi, bukan nama, yaitu antarmuka yang diimplementasikan, dan kemudian mengirimkan objek serial ke layanan kueri.
3. Pelanggan internet ingin mendapatkan sesuatu untuk mengimplementasikan ScientificCalculator, tetapi mereka tidak tahu di mana menemukannya, jadi mereka menanyakan layanan permintaan
4. Layanan kueri merespons hasil kueri
Pengoperasian jaringan penyembuhan diri
1. Layanan Jini tertentu memerlukan pendaftaran, dan layanan kueri akan memberikan sewa. Layanan yang baru terdaftar harus memperbarui sewa secara berkala. Jika tidak, layanan kueri akan berasumsi bahwa layanan tersebut sedang offline menyelesaikan status jaringan layanan yang tersedia.
2. Layanan offline karena dimatikan, sehingga sewa tidak diperbarui dan layanan kueri dimulai.