Ikhtisar JNDI, Bagian 3: JNDI Lanjutan

Saya perlu membahas banyak hal bulan ini, jadi saya akan meninggalkan masalah dan langsung membahas poin-poin penting. Pertama, Penamaan Java dan Antarmuka Direktori memainkan peran penting dalam beberapa teknologi Java. Kita akan melihat peran ini untuk lebih memahami posisi strategis JNDI dalam gambaran Jawa secara keseluruhan. Selanjutnya, sebagai pengakuan atas kebutuhan Anda akan layanan JNDI yang berfungsi untuk dimainkan, saya akan memperkenalkan Anda pada implementasi LDAP portabel yang tersedia secara gratis, dan saya akan mengajari Anda cara menyambung ke dan menggunakan penyedia layanan JNDI. Akhirnya, saya akan membawa Anda untuk melihat dari dekat objek yang mengikat ke entri di JNDI.

KOLOM TULISAN:

TEXTBOX_HEAD: Ikhtisar 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

Sebelum saya mulai, sedikit pemikiran ganda sudah beres. Selama dua bulan terakhir, saya telah mencoba meyakinkan Anda bahwa layanan penamaan dan direktori kira-kira sama secara elektronik dengan katalog kartu yang ditemukan di perpustakaan. Sekarang saat kita memulai tur fitur-fitur canggih JNDI, saya ingin Anda melupakan analogi ini sepenuhnya - ini sangat meremehkan kekuatan JNDI.

Mari kita mulai dengan melihat bagaimana JNDI muncul di teknologi Java lainnya.

JNDI dimana-mana

JNDI berperan dalam sejumlah teknologi Java. Mari kita pertimbangkan tiga di antaranya: JDBC (paket Konektivitas Database Java), JMS (Layanan Pesan Java), dan EJB (Enterprise JavaBeans).

JDBC adalah teknologi Java untuk database relasional. JNDI pertama kali muncul di Paket Opsional JDBC 2.0 (lihat Sumberdaya) dalam hubungannya dengan DataSourceantarmuka. Sebuah DataSourceinstance, seperti namanya, merepresentasikan sumber data - seringkali dari database tetapi tidak selalu. Sebuah DataSourcecontoh menyimpan informasi tentang sumber data - seperti namanya, driver beban dan penggunaan, dan lokasinya - dan memungkinkan aplikasi untuk mendapatkan koneksi ke sumber data tanpa memperhatikan detail yang mendasari. Spesifikasi JDBC merekomendasikan penggunaan JNDI untuk menyimpan DataSourceobjek.

JMS adalah teknologi Java untuk olahpesan. Spesifikasi JMS menjelaskan objek yang dikelola - objek yang berisi informasi konfigurasi JMS dan digunakan oleh klien JMS untuk menemukan antrian dan topik pesan tertentu. Seperti halnya dengan JDBC, spesifikasi merekomendasikan lokasi objek yang dikelola JMS melalui JNDI.

Terakhir, pertimbangkan Enterprise JavaBeans. Semua kacang perusahaan mempublikasikan antarmuka rumah - satu lokasi di mana klien menemukan kacang perusahaan tertentu - melalui JNDI.

Apa yang dibawa JNDI ke meja yang membuatnya sangat dihormati?

Pertama, JNDI mempromosikan gagasan tentang sumber informasi yang dikelola secara terpusat - persyaratan utama untuk aplikasi perusahaan. Sumber informasi yang dikelola secara terpusat lebih mudah dikelola daripada kumpulan sumber informasi yang didistribusikan. Klien juga lebih mudah menemukan informasi yang dibutuhkan jika mereka hanya perlu mencari di satu tempat.

Kedua, seperti yang akan Anda lihat, kemampuan JNDI untuk secara langsung menyimpan objek Java memungkinkannya untuk berintegrasi hampir secara transparan ke dalam aplikasi Java.

Inti dari penyedia

Untuk menggunakan JNDI, Anda memerlukan layanan penamaan dan direktori serta penyedia layanan JNDI. Sun menyediakan beberapa penyedia layanan penamaan dan direktori umum (penamaan COS, NIS, registri RMI, LDAP, dan lainnya). Saya telah menetapkan LDAP.

LDAP (Lightweight Directory Access Protocol) memiliki keuntungan ganda karena diterapkan secara luas (baik dalam bentuk komersial maupun gratis) dan cukup mudah digunakan. Fitur-fiturnya juga didukung dengan baik oleh penyedia layanan LDAP Sun dan JNDI.

Karena mendapatkan dan mengonfigurasi server LDAP sebenarnya bukan materi pelajaran Java, saya hanya akan mengarahkan Anda ke arah yang benar dan memberi Anda referensi ke sumber daya Internet.

Banyak implementasi LDAP tersedia. Banyak produk komersial seperti Netscape Directory Server dan IBM's Secure Way Directory. Beberapa dikemas sebagai bagian dari penawaran yang lebih besar (Direktori Aktif Microsoft adalah bagian dari Windows 2000). Jika Anda memiliki akses ke implementasi seperti itu, Anda dapat melewati sebagian besar bagian ini. Jika tidak, saya akan menjelaskan OpenLDAP - implementasi LDAP yang tersedia secara gratis berdasarkan implementasi referensi University of Michigan - serta instalasi dan konfigurasinya.

OpenLDAP tersedia dari OpenLDAP Foundation (lihat Sumberdaya). Lisensinya didasarkan pada "lisensi artistik" Perl, yang berarti OpenLDAP adalah perangkat lunak gratis (atau sumber terbuka). Binari yang telah dikemas tersedia untuk berbagai varian Linux (Debian, Red Hat) serta BSD Unix. Pekerjaan sedang dilakukan pada port ke Windows NT.

Jika Anda berencana untuk menginstal OpenLDAP, Anda harus membaca Panduan Administrator SLAPD dan SLURPD (slapd adalah nama server LDAP yang dapat dieksekusi dan slurpd adalah nama server replikasi LDAP; lihat Sumber daya untuk lokasinya).

Saya punya satu saran terakhir untuk membuat seluruh pengalaman Anda lebih menyenangkan: apa pun implementasi LDAP yang Anda gunakan, nonaktifkan pemeriksaan skema . Skema LDAP, seperti skema database, menentukan batasan pada informasi yang disimpan. Dalam penggunaan normal, pemeriksaan skema membantu memastikan bahwa entri (pikirkan entri buku alamat) sesuai dengan format yang benar. Namun, karena Anda mungkin akan bermain daripada membangun sesuatu yang memiliki signifikansi yang langgeng, pemeriksaan skema hanya akan menghalangi. Ambil kata-kataku untuk itu.

Menghubungkan ke konteks JNDI

Pada artikel sebelumnya, saya mencoba menghindari penjelasan secara detail bagaimana berinteraksi dengan penyedia layanan JNDI seperti penyedia layanan LDAP. Saya menyebutkan bahwa Anda memerlukan konteks awal untuk melakukan operasi JNDI, tetapi saya tidak menghabiskan banyak waktu untuk memberi tahu Anda cara mendapatkannya. Biarkan saya mengisi kekosongannya. (Untuk mengetahui lebih lanjut tentang konteks awal, lihat dua artikel pertama dalam seri ini.)

Sebelum Anda dapat melakukan apa pun dengan JNDI, Anda memerlukan konteks awal. Semua operasi dilakukan relatif terhadap konteks atau salah satu subkonteksnya.

Mendapatkan konteks awal membutuhkan tiga langkah:

  1. Pertama, pilih penyedia layanan. Jika Anda akan menggunakan OpenLDAP atau implementasi LDAP lainnya, Sun menyediakan referensi penyedia layanan LDAP (lihat Sumberdaya). Tambahkan nama penyedia layanan ke kumpulan properti lingkungan (disimpan dalam sebuah Hashtableinstance):

    Hashtable hashtableEnvironment = new Hashtable (); hashtableEnvironment.put (Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
  2. Tambahkan informasi tambahan yang dibutuhkan penyedia layanan. Untuk LDAP, itu termasuk URL yang mengidentifikasi layanan, konteks akar, dan nama dan kata sandi untuk dihubungkan dengan:

    // layanan: ldap: // localhost: 389 / // konteks root: dc = etcee, dc = com hashtableEnvironment.put (Context.PROVIDER_URL, "ldap: // localhost: 389 / dc = etcee, dc = com "); hashtableEnvironment.put (Context.SECURITY_PRINCIPAL, "nama"); hashtableEnvironment.put (Context.SECURITY_CREDENTIALS, "password");
  3. Finally, get the initial context. If you just intend to perform naming operations, you'll only need a Context instance. If you intend to perform a directory operation as well, you'll need a DirContext instance instead. Not all providers supply both:

     Context context = new InitialContext(hashtableEnvironment); 

    Or:

     DirContext dircontext = new InitialDirContext(hashtableEnvironment); 

That's all there is to it. Now let's look at how applications store objects to and retrieve objects from JNDI.

Work with objects

The ability to store Java objects is useful: object storage provides persistence and allows objects to be shared between applications or between different executions of the same application.

From the standpoint of the code involved, object storage is surprisingly easy:

 context.bind("name", object) 

The bind() operation binds a name to a Java object. The syntax of the command is reminiscent of RMI, but the semantics are not as clearly defined. It's permissible for the bind() operation to store either a snapshot of the object or a reference to a "live" object, for example.

Be aware that the bind() operation throws a NamingException if an exception occurs during the execution of the operation.

Now let's take a look at the bind() operation's complement -- lookup():

 Object object = context.lookup("name") 

The lookup() operation retrieves the object bound to the specified name. Once again, the syntax is reminiscent of RMI, but the method's semantics are not as clearly defined.

Just as with bind(), the lookup() operation throws a NamingException if an exception occurs during the execution of the operation.

Object storage

What does it mean to store an object in a JNDI naming and directory service? We've already mentioned that the exact semantics of the bind() and lookup() operations aren't tightly defined; it's up to the JNDI service provider to define their semantics.

According to the JNDI specification, service providers are encouraged (but not required) to support object storage in one of the following formats:

  • Serialized data
  • Reference
  • Attributes in a directory context

If all JNDI service providers support these standard mechanisms, Java programmers are free to develop generic solutions that work even when the underlying service provider layer changes.

Each of the methods above has advantages and disadvantages. The best method will depend on the requirements of the application under development.

Let's consider each in turn.

As serialized data

The most obvious approach to storing an object in a directory is to store the serialized representation of an object. The only requirement is that the object's class implement the Serializable interface.

When an object is serialized, its state becomes transformed into a stream of bytes. The service provider takes the stream of bytes and stores it in the directory. When a client looks up the object, the service provider reconstructs it from the stored data.

The following code demonstrates how to bind a LinkedList to an entry in an JNDI service:

 // create linked list LinkedList linkedlist = new LinkedList(); . . . // bind context.bind("cn=foo", linkedlist); . . . // lookup linkedlist = (LinkedList)context.lookup("cn=foo"); 

It's that easy!

Unfortunately, the other two methods are more complicated. I will describe them briefly but reserve a detailed discussion for a later date.

As a reference

Sometimes it's not appropriate (or possible) to serialize an object. If the object provides a service on a network, for example, it doesn't make sense to store the state of the object itself. We're interested in the information necessary to find and communicate with the object.

An example is a connection to an external resource (one outside the scope of the Java Virtual Machine) such as a database or file. It clearly doesn't make sense to try to store the database or the file itself in the JNDI service. Instead, we want to store the information necessary to reconstruct the connection.

In this case the programmer should either bind a Reference instance that corresponds to the object or have the object's class implement the Referenceable interface (in which the object generates and provides a Reference instance when requested by the service provider).

The Reference instance contains enough information to recreate the reference. If a reference to a file was stored, the reference contains enough information to create a File object that points to the correct file.

As attributes

If you're using a service provider that provides directory functionality instead of only naming functionality, you can also store an object as a collection of attributes on a DirContext object (a DirContext instance differs from a Context instance in that it may have attributes).

To use this method, you must create objects that implement the DirContext interface and contain the code necessary to write their internal state as an Attributes object. You must also create an object factory to reconstitute the object.

This approach is useful when the object must be accessible by non-Java applications.

Conclusion

If you've read the series, you should understand and appreciate the power and importance of JNDI -- you don't hear much about it, but it's there under the covers.

Bulan depan kita akan melihat aplikasi berbasis JNDI. Sementara itu, Anda harus mencoba mengaktifkan JNDI dan menjalankannya di server LDAP.

Pelajari lebih lanjut tentang topik ini

  • Paket Opsional JDBC 2.0

    //java.sun.com/products/jdbc/articles/package2.html

  • Kunjungi OpenLDAP Foundation untuk mengunduh OpenLDAP

    //www.openldap.org/

  • Untuk mengunduh Panduan Administrator SLAPD dan SLURPD , kunjungi

    //www.umich.edu/~dirsvcs/ldap/doc/guides/

  • Informasi JNDI, penyedia layanan, dan sebagainya

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

Artikel ini, "Ikhtisar JNDI, Bagian 3: JNDI Tingkat Lanjut" awalnya diterbitkan oleh JavaWorld.