Panduan untuk Objek Data Java

1. Ikhtisar

Objek Data Java adalah API yang dirancang untuk menyimpan data berorientasi objek ke dalam database apa pun dan menyediakan bahasa kueri yang ramah pengguna menggunakan sintaks Java.

Pada artikel ini, kita akan melihat bagaimana menggunakan JDO API untuk mempertahankan objek kita dalam database.

2. Ketergantungan dan Penyiapan Maven

Kami akan menggunakan DataNucleus JDO API yang terbaru dan menawarkan dukungan penuh untuk JDO 3.2 API.

Mari tambahkan ketergantungan berikut ke file pom.xml kita :

 org.datanucleus javax.jdo 3.2.0-m6   org.datanucleus datanucleus-core 5.1.0-m2   org.datanucleus datanucleus-api-jdo 5.1.0-m2   org.datanucleus datanucleus-rdbms 5.1.0-m2   org.datanucleus datanucleus-xml 5.0.0-release  

Versi terbaru dari dependensi dapat ditemukan di sini: javax.jdo, datanucleus-core, datanucleus-api-jdo, datanucleus-rdbms and datanucleus-xml.

3. Model

Kami akan menyimpan data kami dalam database, dan sebelum kami dapat melakukannya, kami perlu membuat kelas yang akan digunakan oleh JDO untuk menyimpan data kami.

Untuk melakukan itu kita perlu membuat kelas dengan beberapa properti dan menganotasinya dengan @PersistentCapable:

@PersistenceCapable public class Product { @PrimaryKey @Persistent(valueStrategy = IdGeneratorStrategy.INCREMENT) long id; String name; Double price = 0.0; // standard constructors, getters, setters }

Kami juga menjelaskan kunci utama kami dan strategi yang dipilih.

Setelah kita membuat objek kita, kita perlu menjalankan enhancer untuk menghasilkan bytecode yang dibutuhkan oleh JDO. Menggunakan Maven, kita dapat menjalankan perintah ini:

mvn datanucleus:enhance

Langkah ini wajib. Jika tidak, kita mendapatkan kesalahan waktu kompilasi bahwa kelas tidak ditingkatkan.

Tentu saja, ini mungkin dilakukan secara otomatis selama pembuatan Maven:

 org.datanucleus datanucleus-maven-plugin 5.0.2  JDO ${basedir}/datanucleus.properties ${basedir}/log4j.properties true    process-classes  enhance    

Versi terbaru plugin dapat ditemukan di sini: datanucleus-maven-plugin

4. Objek yang Tetap Ada

Kami mendapatkan akses ke database menggunakan pabrik JDO yang memberi kami manajer transaksi yang bertugas melakukan transaksi:

PersistenceManagerFactory pmf = new JDOPersistenceManagerFactory(pumd, null); PersistenceManager pm = pmf.getPersistenceManager(); 

Transaksi digunakan untuk memungkinkan rollback jika terjadi kesalahan:

Transaction tx = pm.currentTransaction();

Kami melakukan transaksi kami di dalam blok coba / tangkap :

Product product = new Product("Tablet", 80.0); pm.makePersistent(product);

Di blok terakhir kami , kami mendefinisikan operasi ini untuk dilakukan jika terjadi kegagalan.

Jika karena alasan apa pun transaksi tidak dapat diselesaikan, kami melakukan rollback, dan kami juga menutup koneksi ke database dengan pm.close () :

finally { if (tx.isActive()) { tx.rollback(); } pm.close(); }

Untuk menghubungkan program kita ke database, kita perlu membuat unit persistensi pada waktu proses untuk menentukan kelas persisten, tipe database, dan parameter koneksi:

PersistenceUnitMetaData pumd = new PersistenceUnitMetaData( "dynamic-unit", "RESOURCE_LOCAL", null); pumd.addClassName("com.baeldung.jdo.Product"); pumd.setExcludeUnlistedClasses(); pumd.addProperty("javax.jdo.option.ConnectionDriverName", "org.h2.Driver"); pumd .addProperty("javax.jdo.option.ConnectionURL", "jdbc:h2:mem:mypersistence"); pumd.addProperty("javax.jdo.option.ConnectionUserName", "sa"); pumd.addProperty("javax.jdo.option.ConnectionPassword", ""); pumd.addProperty("datanucleus.autoCreateSchema", "true");

5. Membaca Objek

Untuk membaca data dari database kami di dalam blok transaksi kami, kami membuat kueri. Kemudian, kami menyimpan item ini ke dalam koleksi Daftar Java , yang akan menyimpan salinan informasi dalam memori dari penyimpanan persisten.

Manajer persistensi memberi kita akses ke antarmuka kueri yang memungkinkan kita berinteraksi dengan database:

Query q = pm.newQuery( "SELECT FROM " + Product.class.getName() + " WHERE price < 1"); List products = (List) q.execute(); Iterator iter = products.iterator(); while (iter.hasNext()) { Product p = iter.next(); // show the product information } 

6. Memperbarui Objek

Untuk memperbarui objek dalam database kita perlu menemukan objek yang ingin kita perbarui menggunakan query, kemudian kita memperbarui hasil query dan melakukan transaksi:

Query query = pm.newQuery(Product.class, "name == \"Phone\""); Collection result = (Collection) query.execute(); Product product = (Product) result.iterator().next(); product.setName("Android Phone"); 

7. Menghapus Objek

Mirip dengan prosedur pembaruan, kami mencari objek terlebih dahulu dan kemudian menghapusnya menggunakan manajer persistensi. Dalam situasi tersebut, JDO memperbarui penyimpanan persisten:

Query query = pm.newQuery(Product.class, "name == \"Android Phone\""); Collection result = (Collection) query.execute(); Product product = (Product) result.iterator().next(); pm.deletePersistent(product); 

8. XML Datastore

Dengan menggunakan plugin XML, kita dapat menggunakan file XML untuk menyimpan data kita.

Kami menetapkan ConnectionURL kami yang menunjukkan bahwa itu adalah file XML dan menentukan nama file:

pumdXML.addProperty("javax.jdo.option.ConnectionURL", "xml:file:myPersistence.xml");

XML datastore tidak mendukung properti auto-increment, jadi kita perlu membuat kelas lain:

@PersistenceCapable() public class ProductXML { @XmlAttribute private long productNumber = 0; @PrimaryKey private String name = null; private Double price = 0.0; // standard getters and setters

The @XmlAttribute annotation denotes that this will appear in the XML file as an attribute of the element.

Let's create and persist our product:

ProductXML productXML = new ProductXML(0,"Tablet", 80.0); pm.makePersistent(productXML);

We get the product stored in the XML file:

 Tablet 80.0 

8.1. Recover Objects from the XML Datastore

We can recover our objects from the XML file using a query:

Query q = pm.newQuery("SELECT FROM " + ProductXML.class.getName()); List products = (List) q.execute();

And then we use the iterator to interact with each object.

9. JDO Queries

JDOQL is an object-based query language designed to perform queries using Java objects.

9.1. Declarative JDOQL

Using the declarative query, we declare the parameters and set them using Java, this ensures type safety:

Query qDJDOQL = pm.newQuery(Product.class); qDJDOQL.setFilter("name == 'Tablet' && price == price_value"); qDJDOQL.declareParameters("double price_value"); List resultsqDJDOQL = qDJDOQL.setParameters(80.0).executeList();

9.2. SQL

JDO provides a mechanism for executing standard SQL queries:

Query query = pm.newQuery("javax.jdo.query.SQL", "SELECT * FROM PRODUCT"); query.setClass(Product.class); List results = query.executeList();

We use javax.jdo.query.SQL as one parameter for the query object and the second parameter is the SQL itself.

9.3. JPQL

JDO provides a mechanism for executing JPA queries as well. We can use the full syntax of the JPA query language:

Query q = pm.newQuery("JPQL", "SELECT p FROM " + Product.class.getName() + " p WHERE p.name = 'Laptop'"); List results = (List) q.execute();

10. Summary

In this tutorial, we:

  • created a simple CRUD application that uses JDO
  • saved and retrieved our data as XML
  • examined common query mechanisms

As always, you can find the code from the article over on Github.