Einführung in die OrientDB-Java-APIs

Einführung in die OrientDB Java APIs

1. Überblick

OrientDB ist eine Open-Source-NoSQL-Datenbanktechnologie mit mehreren Modellen, die für die ModelleGraph,Document,Key-Value,GeoSpatial undReactiveentwickelt wurde beim Verwalten von Abfragen mit der Syntax vonSQL.

In diesem Artikel werden wir das Setup und die Verwendung der OrientDB-Java-APIs behandeln.

2. Installation

Erstens müssen wir das Binärpaket installieren.

Laden Sie die neueste stabile Version vonOrientDB (2.2.x zum Zeitpunkt des Schreibens dieses Artikels herunter).

Zweitens müssen wir es entpacken und seinen Inhalt in ein geeignetes Verzeichnis verschieben (unter Verwendung vonORIENTDB_HOME). Stellen Sie sicher, dass Sie den Ordnerbinzu den Umgebungsvariablen hinzufügen, damit Sie die Befehlszeile einfach verwenden können.

Schließlich müssen wir dieorientdb.sh-Datei in$ORIENTDB_HOME/bin bearbeiten, indem wir den Speicherort (ORIENTDB_HOME) des OrientDB-Verzeichnisses anstelle von[.s1]#ORIENTDB_DIR #and also the system user we’d like to use instead of USER_YOU_WANT_ORIENTDB_RUN_WITH. füllen

Jetzt haben wir eine voll funktionsfähige OrientDB. Wir können dieorientdb.sh <option> script with options verwenden:

start: um den Server zu starten
status: um den Status zu überprüfen
stop: um den Server zu stoppen

Bitte beachten Sie, dass für die Aktionenstart undstopdas Benutzerkennwort erforderlich ist (das Kennwort, das wir in der Dateiorientdb.sh eingerichtet haben).

Sobald der Server gestartet ist, belegt er den Port 2480. Daher können wir mit diesenURL: lokal darauf zugreifen

Weitere Details zur manuellen Installation finden Sie unterhere.

Hinweis: Für OrientDB istJavaVersion 1.7 oder höher erforderlich.

Frühere Versionen sind inhere verfügbar.

3. OrientDB Java APIs Setup

Mit der OrientDB können Java-Entwickler mit drei verschiedenen APIs arbeiten:

Graph API - Graphdatenbanken
Dokument-API - dokumentorientierte Datenbanken
Objekt-API - Objekte, die direkt an OrientDB Document gebunden sind

Wir können all diese Typen in einer einzigen Codebasis verwenden, indem wir OrientDB integrieren und verwenden.

Schauen wir uns einige verfügbare Gläser an, die wir in den Klassenpfad des Projekts aufnehmen können:

orientdb-core-*.jar: Bringt die Kernbibliothek
blueprints-core-*.jar: um die Kernkomponenten des Adapters zu bringen
orientdb-graphdb-*.jar: Gibt die Graph-Datenbank-API an
orientdb-object-*.jar: Liefert die Objektdatenbank-API
orientdb-distributed-*.jar: Stellt das Plugin für verteilte Datenbanken für die Arbeit mit einem Servercluster bereit
orientdb-tools-*.jar: Übergibt den Konsolenbefehl
orientdb-client-*.jar: Stellt den Remote-Client bereit
orientdb-enterprise-*.jar: Aktiviert die von Client und Server gemeinsam genutzten Protokoll- und Netzwerkklassen

Die beiden letzten sind nur erforderlich, wenn wir unsere Daten auf einem Remote-Server verwalten.

Beginnen wir mit einem Maven-Projekt und verwenden die folgenden Abhängigkeiten:


    com.orientechnologies
    orientdb-core
    2.2.31


    com.orientechnologies
    orientdb-graphdb
    2.2.31


    com.orientechnologies
    orientdb-object
    2.2.31


    com.tinkerpop.blueprints
    blueprints-core
    2.6.0

Bitte überprüfen Sie das Maven Central-Repository auf die neuesten Versionen derCore,GraphDB,Object APIs undBlueprints-Core von OrientDB.

4. Verwendungszweck

Die OrientDB verwendet die Implementierung vonTinkerPop Blueprintsfür die Arbeit mit Diagrammen.

TinkerPop ist ein Graph Computing Framework, das viele Möglichkeiten zum Erstellen von Graphendatenbanken bietet, wobei jede von ihnen ihre Implementierungen hat:

Darüber hinaus ermöglicht OrientDB die Arbeit mit den drei Arten vonSchemas, unabhängig vom API-Typ:

Schema-Voll - Der strikte Modus ist aktiviert, sodass alle Felder während der Klassenerstellung angegeben werden
Schema-weniger - Klassen werden ohne bestimmte Eigenschaft erstellt, sodass wir sie nach Belieben hinzufügen können. it’s the default mode
Schema-Hybrid - Es ist die Mischung aus schemavoll und schemalos, bei der wir eine Klasse mit vordefinierten Feldern erstellen können, aber den Datensatz andere benutzerdefinierte Felder definieren lassen

4.1. Graph API

Da es sich um eine graphbasierte Datenbank handelt, werden Daten als Netzwerk dargestellt, dasVertices (Knoten) enthält, die durchEdges (Bögen) miteinander verbunden sind.

Verwenden Sie als ersten Schritt die Benutzeroberfläche, um eine Diagrammdatenbank mit dem NamenexampleDB mit einem Benutzeradmin und einem Kennwortadmin. zu erstellen

Wie wir im folgenden Bild sehen, wurdegraph als Datenbanktyp ausgewählt, sodass auf seine Daten inGRAPH Tab zugegriffen werden kann:

Stellen Sie nun eine Verbindung zur gewünschten Datenbank her und wissen Sie, dassORIENTDB_HOME eine Umgebungsvariable ist, die dem Installationsordner vonOrientDB entspricht:

@BeforeClass
public static void setup() {
    String orientDBFolder = System.getenv("ORIENTDB_HOME");
    graph = new OrientGraphNoTx("plocal:" + orientDBFolder +
      "/databases/exampleDB", "admin", "admin");
}

Lassen Sie uns die KlassenArticle,Author undEditor initiieren und zeigen, wie Sie ihren Feldern eine Validierung hinzufügen können:

@BeforeClass
public static void init() {
    graph.createVertexType("Article");

    OrientVertexType writerType
      = graph.createVertexType("Writer");
    writerType.setStrictMode(true);
    writerType.createProperty("firstName", OType.STRING);
    // ...

    OrientVertexType authorType
      = graph.createVertexType("Author", "Writer");
    authorType.createProperty("level", OType.INTEGER).setMax("3");

    OrientVertexType editorType
      = graph.createVertexType("Editor", "Writer");
    editorType.createProperty("level", OType.INTEGER).setMin("3");

    Vertex vEditor = graph.addVertex("class:Editor");
    vEditor.setProperty("firstName", "Maxim");
    // ...

    Vertex vAuthor = graph.addVertex("class:Author");
    vAuthor.setProperty("firstName", "Jerome");
    // ...

    Vertex vArticle = graph.addVertex("class:Article");
    vArticle.setProperty("title", "Introduction to ...");
    // ...

    graph.addEdge(null, vAuthor, vEditor, "has");
    graph.addEdge(null, vAuthor, vArticle, "wrote");
}

Im obigen Code-Snippet haben wir eine einfache Darstellung unserer einfachen Datenbank erstellt:

Article ist die schemalose Klasse, die Artikel enthält
Writer ist eine schema-vollständige Superklasse, die die erforderlichen Writer-Informationen enthält
Writer ist ein Untertyp vonAuthor, der seine Details enthält
Editor ist ein schemaloser Untertyp vonWriter, der Editordetails enthält
Das FeldlastNamewurde im gespeicherten Autor nicht ausgefüllt, wird jedoch in der folgenden Grafik angezeigt
Wir haben eine Beziehung zwischen allen Klassen: EinAuthor kannArticle schreiben und muss einEditor haben
Vertex repräsentiert eine Entität mit einigen Feldern
Edge ist eine Entität, die zweiVertices verbindet

Beachten Sie, dass beim Versuch, einem Objekt einer vollständigen Klasse eine weitere Eigenschaft hinzuzufügen, dieOValidationException angezeigt werden.

Nachdem Sie mitOrientDB studio eine Verbindung zu unserer Datenbank hergestellt haben, wird die grafische Darstellung unserer Daten angezeigt:

Lassen Sie uns sehen, wie die Anzahl aller Datensätze (Eckpunkte) der Datenbank ermittelt wird:

long size = graph.countVertices();

Lassen Sie uns nun nur die Anzahl derWriter (Author & Editor)-Objekte anzeigen:

@Test
public void givenexampleDB_checkWeHaveTwoWriters() {
    long size = graph.countVertices("Writer");

    assertEquals(2, size);
}

Im nächsten Schritt können wir alle Daten vonWritermit der folgenden Anweisung finden:

Iterable writers = graph.getVerticesOfClass("Writer");

Lassen Sie uns abschließend alleEditor mitlevel 7 abfragen. hier haben wir nur eine, die passt:

@Test
public void givenexampleDB_getEditorWithLevelSeven() {
    String onlyEditor = "";
    for(Vertex v : graph.getVertices("Editor.level", 7)) {
        onlyEditor = v.getProperty("firstName").toString();
    }

    assertEquals("Maxim", onlyEditor);
}

Der Klassenname wird immer angegeben, um beim Anfordern nach einem bestimmten Eckpunkt zu suchen. Wir können mehr Detailshere finden.

4.2. Dokument-API

Die nächste Option ist die Verwendung des Dokumentmodells der OrientDB. Dies macht die Datenmanipulation über einen einfachen Datensatz mit Informationen zugänglich, die in Feldern gespeichert sind, in denen der Typ Text, Bild oder eine Binärform sein kann.

Verwenden Sie die Benutzeroberfläche erneut, um eine Datenbank mit dem NamenexampleDBTwo zu erstellen, jetzt jedoch mit einemdocument als Typ:

Hinweis: Ebenso kann diese API entweder im schema-vollständigen, schemalosen oder schema-hybriden Modus verwendet werden.

Die Datenbankverbindung bleibt unkompliziert, da wir nur einODatabaseDocumentTx-Objekt instanziieren, die Datenbank-URL und die Anmeldeinformationen des Datenbankbenutzers angeben müssen:

@BeforeClass
public static void setup() {
    String orientDBFolder = System.getenv("ORIENTDB_HOME");
    db = new ODatabaseDocumentTx("plocal:"
      + orientDBFolder + "/databases/exampleDBTwo")
      .open("admin", "admin");
}

Beginnen wir mit dem Speichern eines einfachen Dokuments, das die Informationen einesAuthorenthält.

Hier sehen wir, dass die Klasse automatisch erstellt wurde:

@Test
public void givenDB_whenSavingDocument_thenClassIsAutoCreated() {
    ODocument doc = new ODocument("Author");
    doc.field("name", "Paul");
    doc.save();

    assertEquals("Author", doc.getSchemaClass().getName());
}

Dementsprechend können wir zum Zählen der Anzahl vonAuthors verwenden:

long size = db.countClass("Author");

Fragen wir die Dokumente erneut mit einem Feldwert ab, um mitlevel 7 nach den Objekten vonAuthor zu suchen:

@Test
public void givenDB_whenSavingAuthors_thenWeGetOnesWithLevelSeven() {
    for (ODocument author : db.browseClass("Author")) author.delete();

    ODocument authorOne = new ODocument("Author");
    authorOne.field("firstName", "Leo");
    authorOne.field("level", 7);
    authorOne.save();

    ODocument authorTwo = new ODocument("Author");
    authorTwo.field("firstName", "Lucien");
    authorTwo.field("level", 9);
    authorTwo.save();

    List result = db.query(
      new OSQLSynchQuery("select * from Author where level = 7"));

    assertEquals(1, result.size());
}

Ebenso können wir zum Löschen aller Datensätze der KlasseAuthorFolgendes verwenden:

for (ODocument author : db.browseClass("Author")) {
    author.delete();
}

Auf denBROWSE Tab des OrientDB-Studios können wir eine Abfrage durchführen, um alle unsereAuthor's-Objekte abzurufen:

4.3. Objekt-API

OrientDB verfügt nicht über den Objekttyp der Datenbank. Daher stützt sich die Objekt-API auf eine Dokumentendatenbank.

Im Objekt-API-Typ bleiben alle anderen Konzepte mit nur einer Addition -binding zu POJO - gleich.

Beginnen wir mit der Verbindung zuexampleDBThree mithilfe derOObjectDatabaseTx-Klasse:

@BeforeClass
public static void setup() {
    String orientDBFolder = System.getenv("ORIENTDB_HOME");
    db = new OObjectDatabaseTx("plocal:"
      + orientDBFolder + "/databases/exampleDBThree")
      .open("admin", "admin");
}

Unter der Annahme, dassAuthor das POJO ist, das zum Speichern der Daten vonAuthorverwendet wird, müssen wir es registrieren:

db.getEntityManager().registerEntityClass(Author.class);

Author hat Getter und Setter für die folgenden Felder:

Vorname
Familienname, Nachname
Niveau

Erstellen wir einAuthor mit mehrzeiligen Anweisungen, wenn wir einen Konstruktor ohne Argumente bestätigt haben:

Author author = db.newInstance(Author.class);
author.setFirstName("Luke");
author.setLastName("Sky");
author.setLevel(9);
db.save(author);

Wenn wir dagegen einen anderen Konstruktor haben, derfirstName,lastName undlevel vonAuthor verwendet, ist die Instanziierung nur eine Zeile:

Author author = db.newInstance(Author.class, "Luke", "Sky", 9);
db.save(author);

In den folgenden Zeilen werden alle Datensätze der Author-Klasse durchsucht und gelöscht:

for (Author author : db.browseClass(Author.class)) {
    db.delete(author);
}

Um alle Autoren zu zählen, müssen wir nur die Klasse und die Datenbankinstanz bereitstellen, ohne eine SQL-Abfrage schreiben zu müssen:

long authorsCount = db.countClass(Author.class);

In ähnlicher Weise fragen wir Autoren mitlevel 7 wie folgt ab:

@Test
public void givenDB_whenSavingAuthors_thenWeGetOnesWithLevelSeven() {
    for (Author author : db.browseClass(Author.class)) {
        db.delete(author);
    }

    Author authorOne
      = db.newInstance(Author.class, "Leo", "Marta", 7);
    db.save(authorOne);

    Author authorTwo
      = db.newInstance(Author.class, "Lucien", "Aurelien", 9);
    db.save(authorTwo);

    List result
      = db.query(new OSQLSynchQuery(
      "select * from Author where level = 7"));

    assertEquals(1, result.size());
}

Schließlich ist diesofficial guide, das einige erweiterte Objekt-API-Verwendungen einführt.

5. Fazit

In diesem Artikel haben wir gesehen, wie OrientDB als Datenbankverwaltungssystem mit seinen Java-APIs verwendet wird. Wir haben auch gelernt, wie Sie die Felder validieren und einige einfache Abfragen schreiben.

Der Quellcode für diesen Artikel befindet sich wie immer inover on GitHub.

TOC

Einführung in die OrientDB-Java-APIs