Ikhtisar JNDI, Bagian 1: Pengantar layanan penamaan

Bagi Anda yang pernah ke perpustakaan dan masih dapat mengingat pengalaman tersebut mungkin ingat proses menemukan buku perpustakaan. Jika Anda tidak berhubungan dengan sisi barang antik Anda, situasi ini akan tampak asing; tetapi sesekali saya pergi ke perpustakaan setempat untuk mencari buku offline asli. Perpustakaan dipenuhi dengan ribuan hal - semuanya berdebu dan terbuat dari bubur kayu dan kulit sapi, tetapi mereka memesona dengan caranya sendiri. Bagaimanapun, ketika keharusan untuk menemukan yang tertentu menyerang, saya menghindari cara naif berjalan mondar-mandir di lorong perpustakaan mencarinya dan beralih ke katalog kartu.

TEXTBOX: TEXTBOX_HEAD: Ringkasan JNDI: Baca keseluruhan seri!

  • Bagian 1. Pengantar layanan penamaan
  • Bagian 2. Gunakan layanan direktori JNDI untuk mengelola aplikasi terdistribusi Anda dengan lebih baik

  • Bagian 3. Gunakan JNDI untuk menyimpan objek aplikasi terdistribusi Anda

  • Bagian 4. Kumpulkan apa yang telah Anda pelajari dengan aplikasi berkemampuan JNDI: END_TEXTBOX

Katalog kartu, untuk yang belum tahu, memetakan nama-nama buku ke lokasinya di perpustakaan. Dengan membuka katalog kartu terlebih dahulu dan mencari lokasi buku, saya menghemat banyak waktu berjalan kaki. (Kebetulan, saya pernah mendengar bahwa beberapa perpustakaan benar-benar mengizinkan pelanggan untuk menggunakan komputer daripada katalog kartu. Mereka sudah mendapatkannya setengahnya - sekarang jika mereka hanya akan memasukkan informasi di buku ke komputer di tempatnya. ..)

Meskipun kelihatannya mengejutkan, gagasan tentang katalog kartu juga cukup berguna dalam dunia komputasi. Dalam komputasi, kami menyebutnya layanan penamaan, yang mengaitkan nama dengan lokasi layanan dan dengan informasi. Ini menyediakan program komputer dengan satu lokasi di mana mereka dapat menemukan sumber daya yang mereka butuhkan. Selain itu, program tidak membuang waktu dengan melakukan ekuivalen elektronik dengan berjalan naik dan turun di gang, dan tidak mengharuskan lokasi di-hardcode ke dalam logikanya.

Menemukan sumber daya sangat penting dalam lingkungan perusahaan berskala besar, di mana aplikasi yang Anda buat mungkin bergantung pada layanan yang disediakan oleh aplikasi yang ditulis oleh grup lain di departemen lain. Infrastruktur penamaan yang dirancang dengan baik memungkinkan proyek semacam itu - dan ketiadaan salah satu membuatnya tidak mungkin. Faktanya, banyak upaya rekayasa ulang proses bisnis dimulai dengan desain dan implementasi infrastruktur direktori dan penamaan yang kuat di seluruh perusahaan.

Bulan ini, saya memperkenalkan Java Naming and Directory Interface (JNDI). JNDI menyediakan antarmuka penyebut umum ke banyak layanan penamaan yang ada. Dengan demikian, JNDI tidak dirancang untuk menggantikan teknologi yang sudah ada; sebaliknya, ini menyediakan antarmuka umum ke layanan penamaan yang ada. Mari kita mulai dengan melihat beberapa layanan ini.

Pengantar layanan penamaan

Gambar di bawah ini menggambarkan organisasi layanan penamaan generik.

Layanan penamaan mempertahankan satu set binding. Binding menghubungkan nama dengan objek. Semua objek dalam sistem penamaan diberi nama dengan cara yang sama (yaitu, mereka berlangganan konvensi penamaan yang sama ). Klien menggunakan layanan penamaan untuk menemukan objek berdasarkan nama.

Ada sejumlah layanan penamaan yang ada, beberapa di antaranya akan saya jelaskan di bawah. Masing-masing mengikuti pola di atas, tetapi berbeda dalam detailnya.

  • COS (Common Object Services) Penamaan: Layanan penamaan untuk aplikasi CORBA; memungkinkan aplikasi untuk menyimpan dan mengakses referensi ke objek CORBA.

  • DNS (Domain Name System): Layanan penamaan Internet; memetakan nama-nama yang ramah orang (seperti www.etcee.com) ke dalam alamat IP (Protokol Internet) yang ramah komputer dalam notasi titik-titik (207.69.175.36). Menariknya, DNS adalah layanan penamaan terdistribusi , yang berarti bahwa layanan dan basis data dasarnya tersebar di banyak host di Internet.

  • LDAP (Lightweight Directory Access Protocol): Dikembangkan oleh University of Michigan; seperti yang tersirat dari namanya, ini adalah versi ringan dari DAP (Directory Access Protocol), yang pada gilirannya merupakan bagian dari X.500, standar untuk layanan direktori jaringan. Saat ini, lebih dari 40 perusahaan mendukung LDAP.

  • NIS (Network Information System) dan NIS +: Layanan penamaan jaringan yang dikembangkan oleh Sun Microsystems. Keduanya memungkinkan pengguna untuk mengakses file dan aplikasi pada sembarang host dengan satu ID dan kata sandi.

Fitur umum

Seperti yang saya sebutkan sebelumnya, fungsi utama dari sistem penamaan adalah untuk mengikat nama ke objek (atau, dalam beberapa kasus, ke referensi ke objek - lebih banyak lagi di saat ini). Untuk menjadi layanan penamaan, layanan setidaknya harus menyediakan kemampuan untuk mengikat nama ke objek dan mencari objek berdasarkan nama.

Banyak sistem penamaan tidak menyimpan objek secara langsung. Sebaliknya, mereka menyimpan referensi ke objek. Sebagai ilustrasi, pertimbangkan DNS. Alamat 207.69.175.36 adalah referensi ke lokasi komputer di Internet, bukan komputer itu sendiri.

JNDI menyediakan antarmuka yang mendukung semua fungsi umum ini. Saya akan menyajikan antarmuka ini nanti di artikel ini.

Perbedaan mereka

Penting juga untuk memahami bagaimana layanan penamaan yang ada berbeda, karena JNDI harus menyediakan abstraksi yang bisa diterapkan yang mengatasi perbedaan tersebut.

Selain perbedaan fungsional, perbedaan yang paling mencolok adalah cara setiap layanan penamaan memerlukan nama untuk ditentukan - konvensi penamaannya. Beberapa contoh harus menggambarkan masalahnya.

Dalam DNS, nama dibuat dari komponen yang dipisahkan oleh titik ("."). Mereka membaca dari kanan ke kiri. Nama "www.etcee.com" memberi nama mesin yang disebut "www" dalam domain "etcee.com". Demikian pula, nama "etcee.com" memberi nama domain "etcee" di domain level teratas "com."

Di LDAP, situasinya sedikit lebih rumit. Nama dibangun dari komponen yang dipisahkan dengan koma (","). Seperti nama DNS, mereka membaca dari kanan ke kiri. Namun, komponen dalam nama LDAP harus ditentukan sebagai pasangan nama / nilai. Nama "cn = Todd Sundsted, o = ComFrame, c = US" menamai orang tersebut "cn = Todd Sundsted" dalam organisasi "o = ComFrame, c = US." Demikian juga, nama "o = ComFrame, c = US" menamai organisasi "o = ComFrame" di negara "c = US".

Seperti yang diilustrasikan oleh contoh di atas, konvensi penamaan layanan penamaan saja memiliki potensi untuk memperkenalkan sejumlah besar ragam layanan penamaan yang mendasarinya ke dalam JNDI. Ini bukan fitur yang harus dimiliki antarmuka yang tidak bergantung pada implementasi.

JNDI memecahkan masalah ini dengan Namekelas dan subkelas serta kelas penolongnya. The Namekelas merupakan nama yang terdiri dari urutan memerintahkan subnames, dan menyediakan metode untuk bekerja dengan nama-nama yang independen dari layanan penamaan yang mendasari.

Lihat penamaan JNDI

Seperti yang saya sebutkan di atas, penting untuk diingat bahwa JNDI adalah antarmuka daripada implementasi. Fakta ini memiliki beberapa kelemahan - Anda memerlukan akses ke layanan penamaan yang ada (seperti layanan LDAP) dan Anda perlu memahami sesuatu tentang cara kerjanya untuk bermain dengan JNDI. Di sisi lain, hal ini memungkinkan JNDI untuk berintegrasi dengan mulus ke dalam lingkungan komputasi yang ada di mana layanan penamaan yang mapan memegang kendali.

JNDI naming revolves around a small set of classes and a handful of operations. Let's take a look at them.

Context and InitialContext

The Context interface plays a central role in JNDI. A context represents a set of bindings within a naming service that all share the same naming convention. A Context object provides the methods for binding names to objects and unbinding names from objects, for renaming objects, and for listing the bindings.

Some naming services also provide subcontext functionality. Much like a directory in a filesystem, a subcontext is a context within a context. This hierarchical structure permits better organization of information. For naming services that support subcontexts, the Context class also provides methods for creating and destroying subcontexts.

JNDI performs all naming operations relative to a context. To assist in finding a place to start, the JNDI specification defines an InitialContext class. This class is instantiated with properties that define the type of naming service in use and, for naming services that provide security, the ID and password to use when connecting.

For those of you familiar with the RMI Naming class, many of the methods provided by the Context interface outlined below will look familiar. Let's take a look at Context's methods:

  • void bind(String stringName, Object object): Binds a name to an object. The name must not be bound to another object. All intermediate contexts must already exist.

  • void rebind(String stringName, Object object): Binds a name to an object. All intermediate contexts must already exist.

  • Object lookup(String stringName): Returns the specified object.

  • void unbind(String stringName): Unbinds the specified object.

The Context interface also provides methods for renaming and listing bindings.

  • void rename(String stringOldName, String stringNewName): Changes the name to which an object is bound.
  • NamingEnumeration listBindings(String stringName): Returns an enumeration containing the names bound to the specified context, along with the objects and the class names of the objects bound to them.

  • NamingEnumeration list(String stringName): Returns an enumeration containing the names bound to the specified context, along with the class names of the objects bound to them.

Each of these methods has a sibling that takes a Name object instead of a String object. A Name object represents a generic name. The Name class allows a program to manipulate names without having to know as much about the specific naming service in use.

The example

The example below illustrates how to connect to a naming service, list all of the bindings, or list a specific binding. It uses the filesystem service provider, which is one of the reference JNDI service-provider implementations provided by Sun. The filesystem service provider makes the filesystem look like a naming service (which it is, in many ways -- filenames like /foo/bar/baz are names and are bound to objects like files and directories). I selected it because everyone has access to a filesystem (as opposed to, say, an LDAP server).

import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.Binding; import javax.naming.NamingEnumeration; import javax.naming.NamingException; import java.util.Hashtable; public class Main { public static void main(String [] rgstring) { try { // Create the initial context. The environment // information specifies the JNDI provider to use // and the initial URL to use (in our case, a // directory in URL form -- file:///...). Hashtable hashtableEnvironment = new Hashtable(); hashtableEnvironment.put( Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory" ); hashtableEnvironment.put( Context.PROVIDER_URL, rgstring[0] ); Context context = new InitialContext(hashtableEnvironment); // If you provide no other command line arguments, // list all of the names in the specified context and // the objects they are bound to. if (rgstring.length == 1) { NamingEnumeration namingenumeration = context.listBindings(""); while (namingenumeration.hasMore()) { Binding binding = (Binding)namingenumeration.next(); System.out.println( binding.getName() + " " + binding.getObject() ); } } // Otherwise, list the names and bindings for the // specified arguments. else { for (int i = 1; i < rgstring.length; i++) { Object object = context.lookup(rgstring[i]); System.out.println( rgstring[i] + " " + object ); } } context.close(); } catch (NamingException namingexception) { namingexception.printStackTrace(); } } } 

The program in the listing above first creates an initial context from the specified JNDI provider (in this case, Sun's filesystem provider) and a URL specifying a local directory. If no additional command-line arguments are specified, the program lists the objects and names of every entity in the specified directory. Otherwise, it lists the objects and names of only those items specified on the command line.

Conclusion

You should now have both an understanding of and an appreciation for naming services in general and JNDI in particular. In distributed environments, they are valuable tools for locating information and resources. JNDI makes it possible to work with a variety of naming services without having to master a multitude of APIs. Next month, we'll take a look at the other half of JNDI -- its directory functions.

Todd Sundsted telah menulis program sejak komputer tersedia dalam model desktop yang nyaman. Meskipun awalnya tertarik untuk membangun aplikasi terdistribusi di C ++, Todd beralih ke bahasa pemrograman Java ketika itu menjadi pilihan yang jelas untuk hal semacam itu. Selain menulis, Todd juga bekerja sebagai arsitek Java dengan Software ComFrame.

Pelajari lebih lanjut tentang topik ini

  • Unduh kode sumber lengkap untuk artikel ini, dalam format zip

    //images.techhive.com/downloads/idge/imported/article/jvw/2000/01/jw-01-howto.zip

  • Semua hal JNDI

    //java.sun.com/products/jndi/

  • Dokumentasi JNDI

    //java.sun.com/products/jndi/docs.html

  • Penyedia layanan saat ini tersedia

    //java.sun.com/products/jndi/serviceproviders.html

  • Daftar lengkap kolom How-To Java sebelumnya

    //www.javaworld.com/javaworld/topicalindex/jw-ti-howto.html

Artikel ini, "Ikhtisar JNDI, Bagian 1: Pengenalan layanan penamaan" awalnya diterbitkan oleh JavaWorld.