Anleitung zu Java-Datenobjekten

Leitfaden zu Java-Datenobjekten

1. Überblick

Die Java-Datenobjekte sind eine API, mit der objektorientierte Daten in einer beliebigen Datenbank gespeichert und mithilfe der Java-Syntax eine benutzerfreundliche Abfragesprache bereitgestellt werden können.

In diesem Artikel erfahren Sie, wie Sie die JDO-API zum Speichern unserer Objekte in einer Datenbank verwenden.

2. Maven-Abhängigkeiten und Setup

Wir werden die aktuelle DataNucleus-JDO-API verwenden, die vollständige Unterstützung für die JDO 3.2-API bietet.

Fügen wir unsererpom.xml-Datei die folgende Abhängigkeit hinzu:


    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

Die neuesten Versionen der Abhängigkeiten finden Sie hier:javax.jdo,datanucleus-core,datanucleus-api-jdo,datanucleus-rdbms unddatanucleus-xml.

3. Modell

Wir werden unsere Daten in einer Datenbank speichern, und bevor wir dies tun können, müssen wir eine Klasse erstellen, die von JDO zum Speichern unserer Daten verwendet wird.

Dazu müssen wir eine Klasse mit einigen Eigenschaften erstellen und mit@PersistentCapable: versehen

@PersistenceCapable
public class Product {

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.INCREMENT)
    long id;

    String name;
    Double price = 0.0;

    // standard constructors, getters, setters
}

Wir haben auch unseren Primärschlüssel und die gewählte Strategie mit Anmerkungen versehen.

Sobald wir unser Objekt erstellt haben, müssen wir den Enhancer ausführen, um den für JDO erforderlichen Bytecode zu generieren. Mit Maven können wir diesen Befehl ausführen:

mvn datanucleus:enhance

Dieser Schritt ist obligatorisch. Andernfalls wird beim Kompilieren ein Fehler gemeldet, dass die Klasse nicht erweitert wurde.

Natürlich ist dies während eines Maven-Builds automatisch möglich:


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

Die neueste Version des Plugins finden Sie hier:datanucleus-maven-plugin

4. Persistierende Objekte

Wir erhalten Zugriff auf die Datenbank über eine JDO-Factory, die uns den Transaktionsmanager zur Verfügung stellt, der für die Ausführung von Transaktionen verantwortlich ist:

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

Transaktionen werden verwendet, um im Fehlerfall ein Rollback zu ermöglichen:

Transaction tx = pm.currentTransaction();

Wir machen unsere Transaktionen innerhalb einestry/catch Blocks:

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

In unseremfinally-Block definieren wir diese Operationen, die im Falle eines Fehlers ausgeführt werden sollen.

Wenn die Transaktion aus irgendeinem Grund nicht abgeschlossen werden kann, führen wir einen Rollback durch und schließen die Verbindung zur Datenbank mitpm.close():

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

Um unser Programm mit der Datenbank zu verbinden, müssen wir zur Laufzeit einpersistence-unit erstellen, um die persistenten Klassen, den Datenbanktyp und die Verbindungsparameter anzugeben:

PersistenceUnitMetaData pumd = new PersistenceUnitMetaData(
  "dynamic-unit", "RESOURCE_LOCAL", null);
pumd.addClassName("com.example.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. Objekte lesen

Um Daten aus unserer Datenbank in unserem Transaktionsblock zu lesen, erstellen wir eine Abfrage. Anschließend speichern wir diese Elemente in einer JavaList-Sammlung, die eine speicherinterne Kopie der Informationen aus dem persistenten Speicher enthält.

Der Persistenzmanager gibt uns Zugriff auf die Abfrageoberfläche, über die wir mit der Datenbank interagieren können:

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. Objekte aktualisieren

Um Objekte in der Datenbank zu aktualisieren, müssen wir die zu aktualisierenden Objekte mithilfe einer Abfrage suchen. Anschließend aktualisieren wir die Ergebnisse der Abfrage und übergeben die Transaktion:

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

7. Objekte löschen

Ähnlich wie bei der Aktualisierung suchen wir zuerst nach dem Objekt und löschen es dann mit dem Persistenzmanager. In diesen Situationen aktualisiert JDO den persistenten Speicher:

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-Datenspeicher

Mit dem XML-Plugin können wir XML-Dateien zum Speichern unserer Daten verwenden.

Wir geben unsereConnectionURLan, die angeben, dass es sich um eine XML-Datei handelt, und geben den Namen der Datei an: __

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

Ein XML-Datenspeicher unterstützt die Auto-Increment-Eigenschaft nicht, daher müssen wir eine weitere Klasse erstellen:

@PersistenceCapable()
public class ProductXML {

    @XmlAttribute
    private long productNumber = 0;
    @PrimaryKey
    private String name = null;
    private Double price = 0.0;

    // standard getters and setters

Die Annotation@XmlAttribute gibt an, dass dies in der XML-Datei als Attribut des Elements angezeigt wird.

Lassen Sie uns unser Produkt erstellen und beibehalten:

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

Wir bekommen das Produkt in der XML-Datei gespeichert:


    Tablet
    80.0

8.1. Objekte aus dem XML-Datenspeicher wiederherstellen

Wir können unsere Objekte aus der XML-Datei mit einer Abfrage wiederherstellen:

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

Und dann verwenden wir den Iterator, um mit jedem Objekt zu interagieren.

9. JDO-Abfragen

JDOQL ist eine objektbasierte Abfragesprache, mit der Abfragen mithilfe von Java-Objekten ausgeführt werden können.

9.1. Deklaratives JDOQL

Mit der deklarativen Abfrage deklarieren wir die Parameter und setzen sie mit Java, um die Typensicherheit zu gewährleisten:

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 bietet einen Mechanismus zum Ausführen von Standard-SQL-Abfragen:

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

Wir verwendenjavax.jdo.query.SQL als einen Parameter für das Abfrageobjekt und der zweite Parameter ist SQL selbst.

9.3. JPQL

JDO bietet auch einen Mechanismus zum Ausführen von JPA-Abfragen. Wir können die vollständige Syntax der JPA-Abfragesprache verwenden:

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

10. Zusammenfassung

In diesem Tutorial werden wir:

hat eine einfache CRUD-Anwendung erstellt, die JDO verwendet
Speichern und Abrufen unserer Daten als XML
untersuchten gängige Abfragemechanismen

Wie immer finden Sie den Code aus dem Artikelover on Github.

TOC