Ketekunan objek dan Java

Ketahanan objek, atau ketekunan , adalah istilah yang sering Anda dengar digunakan sehubungan dengan masalah penyimpanan objek dalam database. Kegigihan diharapkan beroperasi dengan integritas transaksional, dan karenanya tunduk pada persyaratan yang ketat. (Lihat bagian Sumber dari artikel ini untuk informasi lebih lanjut tentang pemrosesan transaksi.) Sebaliknya, layanan bahasa yang ditawarkan melalui pustaka dan paket bahasa standar sering kali bebas dari batasan transaksional.

Seperti yang akan kita lihat di artikel ini, bukti menunjukkan bahwa persistensi Java sederhana kemungkinan besar berasal dari bahasa itu sendiri, sementara fungsionalitas database yang canggih akan ditawarkan oleh vendor database.

Tidak ada objek adalah sebuah pulau

Di dunia nyata, Anda jarang menemukan objek yang tidak memiliki hubungan dengan objek lain. Objek adalah komponen model objek . Masalah daya tahan objek melampaui masalah ketahanan model objek dan distribusi begitu kita membuat pengamatan bahwa objek saling berhubungan berdasarkan hubungannya satu sama lain.

Pendekatan relasional untuk penyimpanan data cenderung menggabungkan data berdasarkan jenis. Baris dalam tabel mewakili agregat fisik objek dari jenis yang sama di disk. Hubungan antar objek kemudian diwakili oleh kunci yang digunakan bersama di banyak tabel. Meskipun melalui organisasi database, database relasional terkadang memungkinkan tabel yang mungkin digunakan bersama untuk ditempatkan bersama (atau berkerumun ) di partisi logis yang sama, seperti segmen database, mereka tidak memiliki mekanisme untuk menyimpan hubungan objek dalam database. Oleh karena itu, untuk membangun model objek, hubungan ini dibangun dari kunci yang ada pada waktu proses dalam proses yang disebut sebagai gabungan tabel . Ini adalah properti terkenal yang sama dari database relasional yang dipanggilindependensi data . Hampir semua varian database objek menawarkan beberapa mekanisme untuk meningkatkan kinerja sistem yang melibatkan hubungan objek yang kompleks melalui database relasional tradisional.

Untuk menanyakan atau menavigasi?

Dalam menyimpan objek pada disk, kita dihadapkan pada pilihan objek terkait yang ditempatkan bersama untuk mengakomodasi akses navigasi dengan lebih baik, atau untuk menyimpan objek dalam koleksi seperti tabel yang menggabungkan objek berdasarkan jenis untuk memfasilitasi akses berbasis predikat (kueri), atau keduanya. . Lokasi bersama objek dalam penyimpanan persisten adalah area di mana database relasional dan berorientasi objek sangat berbeda. Pilihan bahasa kueri adalah area pertimbangan lain. Structured Query Language (SQL) dan ekstensinya telah menyediakan sistem relasional dengan mekanisme akses berbasis predikat. Object Query Language (OQL) adalah varian objek dari SQL, distandarisasi oleh ODMG, tetapi dukungan untuk bahasa ini masih sedikit. Metode polimorfik menawarkan keanggunan yang belum pernah terjadi sebelumnya dalam membangun kueri semantik untuk sekumpulan objek. Sebagai contoh,bayangkan perilaku polimorfik untukacccountdipanggil isInGoodStanding. Ini dapat mengembalikan Boolean true untuk semua akun dengan reputasi baik, dan false sebaliknya. Sekarang bayangkan keanggunan menanyakan kumpulan akun, inGoodStandingyang diterapkan secara berbeda berdasarkan aturan bisnis, untuk semua akun dengan reputasi baik. Ini mungkin terlihat seperti:

setOfGoodCustomers = setOfAccounts.query(account.inGoodStanding());

Sementara beberapa database objek yang ada mampu memproses gaya kueri seperti itu di C ++ dan Smalltalk, sulit bagi mereka untuk melakukannya untuk koleksi yang lebih besar (katakanlah, 500+ gigabyte) dan ekspresi kueri yang lebih kompleks. Beberapa perusahaan database relasional, seperti Oracle dan Informix, akan segera menawarkan sintaks berbasis SQL lainnya untuk mencapai hasil yang sama.

Ketekunan dan tipe

Penggemar bahasa berorientasi objek akan mengatakan ketekunan dan tipe adalah properti ortogonal dari suatu objek; Artinya, objek persisten dan transien dari tipe yang sama bisa identik karena satu properti tidak boleh memengaruhi properti lainnya. Pandangan alternatif menyatakan bahwa persistensi adalah perilaku yang hanya didukung oleh objek persistable dan perilaku tertentu mungkin hanya berlaku untuk objek persisten. Pendekatan terakhir memanggil metode yang menginstruksikan objek persistable untuk menyimpan dan mengambil sendiri dari penyimpanan persisten, sedangkan pendekatan sebelumnya memberi aplikasi tampilan yang mulus dari seluruh model objek - seringkali dengan memperluas sistem memori virtual.

Kanonikalisasi dan kemandirian bahasa

Objek berjenis sama dalam suatu bahasa harus disimpan dalam penyimpanan persisten dengan tata letak yang sama, terlepas dari urutan kemunculan antarmukanya. Proses mengubah tata letak objek ke format umum ini secara kolektif dikenal sebagai kanonikalisasi representasi objek. Dalam bahasa yang dikompilasi dengan objek pengetikan statis (bukan Java) yang ditulis dalam bahasa yang sama, tetapi dikompilasi di bawah sistem yang berbeda, harus direpresentasikan secara identik dalam penyimpanan persisten.

Perpanjangan kanonikalisasi membahas representasi objek yang tidak bergantung pada bahasa. Jika objek dapat direpresentasikan dalam mode bahasa-independen, akan memungkinkan representasi yang berbeda dari objek yang sama untuk berbagi penyimpanan persisten yang sama.

Salah satu mekanisme untuk menyelesaikan tugas ini adalah untuk memperkenalkan tingkat tipuan tambahan melalui bahasa definisi antarmuka (IDL). Antarmuka database objek dapat dibuat melalui IDL dan struktur data yang sesuai. Kelemahan dari ikatan gaya IDL ada dua: Pertama, tingkat tipuan ekstra selalu membutuhkan tingkat terjemahan tambahan, yang mempengaruhi kinerja keseluruhan sistem; kedua, membatasi penggunaan layanan database yang unik untuk vendor tertentu dan yang mungkin berharga bagi pengembang aplikasi.

Mekanisme serupa adalah untuk mendukung layanan objek melalui ekstensi SQL. Vendor database relasional dan objek yang lebih kecil / vendor relasional adalah pendukung pendekatan ini; Namun, seberapa sukses perusahaan-perusahaan ini dalam membentuk kerangka penyimpanan objek masih harus dilihat.

Tetapi pertanyaannya tetap: Apakah ketekunan objek bagian dari perilaku objek atau apakah itu layanan eksternal yang ditawarkan ke objek melalui antarmuka terpisah? Bagaimana dengan kumpulan objek dan metode untuk menanyakannya? Pendekatan relasional, relasional yang diperluas, dan objek / relasional cenderung mendukung pemisahan antara bahasa, sementara database objek - dan bahasa Java itu sendiri - melihat ketekunan sebagai hal yang intrinsik dalam bahasa tersebut.

Ketekunan asli Java melalui serialisasi

Serialisasi objek adalah mekanisme khusus bahasa Java untuk penyimpanan dan pengambilan objek Java dan primitif ke aliran. Perlu dicatat bahwa meskipun pustaka pihak ketiga komersial untuk membuat serialisasi objek C ++ telah ada selama beberapa waktu, C ++ tidak pernah menawarkan mekanisme asli untuk serialisasi objek. Berikut cara menggunakan serialisasi Java:

// Menulis "foo" ke aliran (misalnya, file)

// Langkah 1. Buat aliran keluaran

// artinya, buat keranjang untuk menerima byte

FileOutputStream out = FileOutputStream baru ("fooFile");

// Langkah 2. Buat ObjectOutputStream

// Yaitu, buat selang dan masukkan kepalanya ke dalam ember

ObjectOutputStream os = baru ObjectOutputStream (keluar)

// Langkah 3. Menulis string dan objek ke aliran

// artinya, biarkan arus mengalir ke dalam ember

os.writeObject ("foo");

os.writeObject (Foo baru ());

// Langkah 4. Flush data ke tujuannya

os.flush ();

The WriteobjectMetode serializes foo dan penutupan transitif nya - yaitu, semua benda yang dapat dirujuk dari foo dalam grafik. Dalam aliran hanya ada satu salinan dari objek berseri. Referensi lain ke objek disimpan sebagai pegangan objek untuk menghemat ruang dan menghindari referensi melingkar. Objek serial dimulai dengan kelas diikuti dengan bidang setiap kelas dalam hierarki warisan.

// Membaca objek dari sungai

// Langkah 1. Buat aliran input

FileInputStream in = new FileInputStream ("fooFile");

// Langkah 2. Buat aliran input objek

ObjectInputStream ins = new ObjectInputStream (dalam);

// Langkah 3. Mengetahui apa yang Anda baca

String fooString = (String) ins.readObject ();

Foo foo = (Foo) s.readObject ();

Serialisasi objek dan keamanan

Secara default, serialisasi menulis dan membaca kolom non-statis dan non-transien dari aliran. Karakteristik ini dapat digunakan sebagai mekanisme keamanan dengan mendeklarasikan kolom yang tidak dapat diserialkan sebagai private transient. Jika kelas mungkin tidak serial sama sekali, writeObjectdan readObjectmetode harus diterapkan untuk melempar NoAccessException.

Ketekunan dengan integritas transaksional: Memperkenalkan JDBC

Dimodelkan setelah X / Open's SQL CLI (Client Level Interface) dan abstraksi ODBC Microsoft, konektivitas database Java (JDBC) bertujuan untuk menyediakan mekanisme konektivitas database yang tidak tergantung pada sistem manajemen database yang mendasarinya (DBMS). Agar sesuai dengan JDBC, driver perlu mendukung setidaknya API level awal ANSI SQL-2, yang memberikan vendor alat dan aplikasi pihak ketiga cukup fleksibilitas untuk akses database.

JDBC dirancang agar konsisten dengan sistem Java lainnya. Vendor didorong untuk menulis API yang diketik lebih kuat daripada ODBC, yang memungkinkan pemeriksaan jenis statis lebih besar pada waktu kompilasi.

Berikut deskripsi antarmuka JDBC yang paling penting:

  • java.sql.Driver.Manager menangani pemuatan driver dan memberikan dukungan untuk koneksi database baru.

  • java.sql.Connection mewakili koneksi ke database tertentu.

  • java.sql.Statement bertindak sebagai wadah untuk mengeksekusi pernyataan SQL pada koneksi tertentu.

  • java.sql.ResultSet mengontrol akses ke set hasil.

Anda dapat mengimplementasikan driver JDBC dengan beberapa cara. Yang paling sederhana adalah membangun driver sebagai jembatan ke ODBC. Pendekatan ini paling cocok untuk alat dan aplikasi yang tidak memerlukan kinerja tinggi. Desain yang lebih dapat diperluas akan memperkenalkan tingkat tipuan ekstra ke server DBMS dengan menyediakan driver jaringan JDBC yang mengakses server DBMS melalui protokol yang diterbitkan. Driver yang paling efisien, bagaimanapun, akan langsung mengakses API berpemilik DBMS.

Database objek dan ketekunan Java

Sejumlah proyek yang sedang berlangsung di industri menawarkan ketekunan Java di tingkat objek. Namun, pada tulisan ini, Object Design PSE (Persistent Storage Engine) dan PSE Pro adalah satu-satunya paket database berorientasi objek yang sepenuhnya berbasis Java yang tersedia (setidaknya, yang saya ketahui). Periksa bagian Sumber Daya untuk informasi lebih lanjut tentang PSE dan PSE Pro.

Pengembangan Java telah menyebabkan penyimpangan dari paradigma pengembangan tradisional untuk vendor perangkat lunak, terutama dalam timeline proses pengembangan. Misalnya, PSE dan PSE Pro dikembangkan di lingkungan yang heterogen. Dan karena tidak ada langkah penautan dalam proses pengembangan, pengembang dapat membuat berbagai komponen fungsional yang independen satu sama lain, yang menghasilkan kode berorientasi objek yang lebih baik dan lebih andal.

PSE Pro memiliki kemampuan untuk memulihkan database yang rusak dari transaksi yang dibatalkan karena kegagalan sistem. Kelas yang bertanggung jawab untuk fungsionalitas tambahan ini tidak ada dalam rilis PSE. Tidak ada perbedaan lain antara kedua produk tersebut. Produk ini adalah apa yang kami sebut "dribbleware" - rilis perangkat lunak yang meningkatkan fungsionalitasnya dengan mencolokkan komponen baru. Dalam waktu yang tidak terlalu lama, konsep membeli perangkat lunak monolitik yang besar akan menjadi sesuatu dari masa lalu. Lingkungan bisnis baru di dunia maya, bersama dengan komputasi Java, memungkinkan pengguna untuk membeli hanya bagian-bagian dari model objek (grafik objek) yang mereka butuhkan, menghasilkan produk akhir yang lebih ringkas.

PSE bekerja dengan pasca-pemrosesan dan membuat anotasi file kelas setelah dibuat oleh pengembang. Dari sudut pandang PSE, kelas dalam grafik objek bisa berupa persistent-aware atau persistent-aware. Kelas berkemampuan persisten dapat bertahan sendiri sementara kelas sadar-persisten dapat beroperasi pada objek persisten. Perbedaan ini diperlukan karena kegigihan mungkin bukan perilaku yang diinginkan untuk kelas tertentu. File kelas pasca-prosesor membuat modifikasi berikut ke kelas: