1. Overview
The Java Data Objects is an API designed for persisting object-oriented data into any database and provide a user-friendly query language using the Java syntax.
In this article, we are going to see how to use the JDO API for persisting our objects in a database.
2. Maven Dependencies and Setup
We are going to use DataNucleus JDO API that is up to date and offers full support for the JDO 3.2 API.
Let’s add the following dependency to our pom.xml file:
<dependency>
<groupId>org.datanucleus</groupId>
<artifactId>javax.jdo</artifactId>
<version>3.2.0-m6</version>
</dependency>
<dependency>
<groupId>org.datanucleus</groupId>
<artifactId>datanucleus-core</artifactId>
<version>5.1.0-m2</version>
</dependency>
<dependency>
<groupId>org.datanucleus</groupId>
<artifactId>datanucleus-api-jdo</artifactId>
<version>5.1.0-m2</version>
</dependency>
<dependency>
<groupId>org.datanucleus</groupId>
<artifactId>datanucleus-rdbms</artifactId>
<version>5.1.0-m2</version>
</dependency>
<dependency>
<groupId>org.datanucleus</groupId>
<artifactId>datanucleus-xml</artifactId>
<version>5.0.0-release</version>
</dependency>
The latest versions of the dependencies can be found here: javax.jdo ,datanucleus-core ,datanucleus-api-jdo ,datanucleus-rdbms and datanucleus-xml.
3. Model
We are going to save our data in a database, and before we can do that, we need to create a class that will be used by JDO for storing our data.
To do that we need to create a class with some properties and annotate it with the @PersistentCapable:
@PersistenceCapable
public class Product {
@PrimaryKey
@Persistent(valueStrategy = IdGeneratorStrategy.INCREMENT)
long id;
String name;
Double price = 0.0;
// standard constructors, getters, setters
}
We also annotated our primary key and the chosen strategy.
Once we create our object, we need to run the enhancer to generate the bytecode required by JDO. Using Maven, we can run this command:
mvn datanucleus:enhance
This step is mandatory. Otherwise, we get compile time error that the class is not enhanced.
Of course, it’s possible to do this automatically during a Maven build:
<plugin>
<groupId>org.datanucleus</groupId>
<artifactId>datanucleus-maven-plugin</artifactId>
<version>5.0.2</version>
<configuration>
<api>JDO</api>
<props>${basedir}/datanucleus.properties</props>
<log4jConfiguration>${basedir}/log4j.properties</log4jConfiguration>
<verbose>true</verbose>
</configuration>
<executions>
<execution>
<phase>process-classes</phase>
<goals>
<goal>enhance</goal>
</goals>
</execution>
</executions>
</plugin>
The latest version of the plugin can be found here: datanucleus-maven-plugin
4. Persisting Objects
We get access to the database using a JDO factory that gives us the transaction manager that is in charge of performing transactions:
PersistenceManagerFactory pmf = new JDOPersistenceManagerFactory(pumd, null); PersistenceManager pm = pmf.getPersistenceManager();
Transactions are used to allow a rollback in case of an error:
Transaction tx = pm.currentTransaction();
We make our transactions inside a try/catch block:
Product product = new Product("Tablet", 80.0);
pm.makePersistent(product);
In our finally block, we define these operations to be done in the case of a failure.
If for any reason the transaction cannot be completed, we make a rollback, and we also close the connection to the database with pm.close():
finally {
if (tx.isActive()) {
tx.rollback();
}
pm.close();
}
To connect our program to the database, we need to create a persistence-unit at runtime to specify the persistent classes, the database type, and connection parameters:
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. Reading Objects
To read data from our database inside our transaction block, we create a query. Then, we store these items into a Java List collection, which will hold an in-memory copy of the information from the persistent storage.
The persistence manager gives us an access to the query interface that allows us to interact with the database:
Query q = pm.newQuery(
"SELECT FROM " + Product.class.getName() + " WHERE price < 1");
List<Product> products = (List<Product>) q.execute();
Iterator<Product> iter = products.iterator();
while (iter.hasNext()) {
Product p = iter.next();
// show the product information
}
6. Updating Objects
To update objects in the database we need to find the objects that we want to update using a query, then we update the results of the query and commit the transaction:
Query query = pm.newQuery(Product.class, "name == \"Phone\"");
Collection result = (Collection) query.execute();
Product product = (Product) result.iterator().next();
product.setName("Android Phone");
7. Deleting Objects
Similar to the update procedure, we search for the object first and then delete it using the persistence manager. In those situations, JDO updates the persistent storage:
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 Datastores
Using the XML plugin, we can use XML files for persisting our data.
We specify our ConnectionURL indicating that is an XML file and specifying the name of the file:
pumdXML.addProperty("javax.jdo.option.ConnectionURL", "xml:file:myPersistence.xml");
An XML datastore does not support the auto-increment property, so we need to create another class:
@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:
<productXML productNumber="0">
<name>Tablet</name>
<price>80.0</price>
</productXML>
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<ProductXML> products = (List<ProductXML>) 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<Product> 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<Product> 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.