Guía de objetos de datos Java

1. Información general

Java Data Objects es una API diseñada para conservar datos orientados a objetos en cualquier base de datos y proporcionar un lenguaje de consulta fácil de usar utilizando la sintaxis de Java.

En este artículo, veremos cómo utilizar la API de JDO para conservar nuestros objetos en una base de datos.

2. Dependencias y configuración de Maven

Vamos a utilizar la API de DataNucleus JDO que está actualizada y ofrece soporte completo para la API de JDO 3.2.

Agreguemos la siguiente dependencia a nuestro archivo pom.xml :

 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  

Las últimas versiones de las dependencias se pueden encontrar aquí: javax.jdo, datanucleus-core, datanucleus-api-jdo, datanucleus-rdbms y datanucleus-xml.

3. Modelo

Vamos a guardar nuestros datos en una base de datos, y antes de que podamos hacer eso, necesitamos crear una clase que será utilizada por JDO para almacenar nuestros datos.

Para hacer eso, necesitamos crear una clase con algunas propiedades y anotarla con @PersistentCapable:

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

También anotamos nuestra clave principal y la estrategia elegida.

Una vez que creamos nuestro objeto, necesitamos ejecutar el potenciador para generar el código de bytes requerido por JDO. Usando Maven, podemos ejecutar este comando:

mvn datanucleus:enhance

Este paso es obligatorio. De lo contrario, obtenemos un error de tiempo de compilación de que la clase no se ha mejorado.

Por supuesto, es posible hacer esto automáticamente durante una compilación de Maven:

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

La última versión del complemento se puede encontrar aquí: datanucleus-maven-plugin

4. Objetos persistentes

Accedemos a la base de datos mediante una fábrica de JDO que nos da el administrador de transacciones que se encarga de realizar las transacciones:

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

Las transacciones se utilizan para permitir una reversión en caso de error:

Transaction tx = pm.currentTransaction();

Hacemos nuestras transacciones dentro de un bloque try / catch :

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

En nuestro bloque finalmente , definimos estas operaciones a realizar en caso de falla.

Si por alguna razón no se puede completar la transacción, hacemos una reversión, y también cerramos la conexión a la base de datos con pm.close () :

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

Para conectar nuestro programa a la base de datos, necesitamos crear una unidad de persistencia en tiempo de ejecución para especificar las clases persistentes, el tipo de base de datos y los parámetros de conexión:

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. Leer objetos

Para leer datos de nuestra base de datos dentro de nuestro bloque de transacciones, creamos una consulta. Luego, almacenamos estos elementos en una colección Java List , que contendrá una copia en memoria de la información del almacenamiento persistente.

El administrador de persistencia nos da acceso a la interfaz de consulta que nos permite interactuar con la base de datos:

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. Actualización de objetos

Para actualizar objetos en la base de datos necesitamos encontrar los objetos que queremos actualizar usando una consulta, luego actualizamos los resultados de la consulta y confirmamos la transacción:

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

7. Eliminación de objetos

De manera similar al procedimiento de actualización, primero buscamos el objeto y luego lo eliminamos usando el administrador de persistencia. En esas situaciones, JDO actualiza el almacenamiento persistente:

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

8. Almacenes de datos XML

Usando el complemento XML, podemos usar archivos XML para conservar nuestros datos.

Especificamos nuestra ConnectionURL indicando que es un archivo XML y especificando el nombre del archivo:

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

Un almacén de datos XML no admite la propiedad de incremento automático, por lo que necesitamos crear otra clase:

@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.