Einführung in die OrientDB Java APIs

1. Übersicht

OrientDB ist eine Open-Source-NoSQL-Datenbanktechnologie mit mehreren Modellen, die für die Arbeit mit den Modellen Graph, Document, Key-Value, GeoSpatial und Reactive entwickelt wurde, während Abfragen mit SQL-Syntax verwaltet werden.

In diesem Artikel behandeln wir das Setup und verwenden die OrientDB-Java-APIs.

2. Installation

Zunächst müssen wir das Binärpaket installieren.

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

Zweitens müssen wir es entpacken und seinen Inhalt in ein geeignetes Verzeichnis verschieben (mit ORIENTDB_HOME ). Stellen Sie sicher, dass Sie den Ordner bin zu den Umgebungsvariablen hinzufügen, damit Sie die Befehlszeile einfach verwenden können.

Schließlich müssen wir die Datei orientdb.sh in $ ORIENTDB_HOME / bin bearbeiten, indem wir den Speicherort ( ORIENTDB_HOME ) des OrientDB-Verzeichnisses anstelle von ORIENTDB_DIR und auch den Systembenutzer, den wir anstelle von USER_YOU_WANT_ORIENTDB_RUN_WITH verwenden möchten, ausfüllen .

Jetzt haben wir eine voll funktionsfähige OrientDB. Wir können das Skript orientdb.sh mit folgenden Optionen verwenden:

  • start : um den Server zu starten
  • status : um den status zu überprüfen

  • stop : um den Server zu stoppen

Bitte beachten Sie, dass beide Start- und Stopp - Aktionen das Benutzerkennwort erforderlich (diejenige , die wir in der einrichten orientdb.sh - Datei).

Sobald der Server gestartet ist, belegt er den Port 2480. Daher können wir über diese URL lokal darauf zugreifen :

Weitere Details zur manuellen Installation finden Sie hier.

Hinweis: Für OrientDB ist Java Version 1.7 oder höher erforderlich.

Frühere Versionen finden Sie hier.

3. Setup der OrientDB Java APIs

Mit der OrientDB können Java-Entwickler mit drei verschiedenen APIs arbeiten, z.

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

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

Werfen wir einen Blick auf einige verfügbare Gläser, 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 Object-Datenbank-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 von OrientDBs Core, GraphDB, Objekt-APIs und Blueprints-Core.

4. Verwendung

Die OrientDB verwendet die TinkerPop Blueprints-Implementierung zum Arbeiten mit Grafiken.

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

  • Blaupausen
  • Rohre
  • Gremlin
  • Rexster
  • Segel Ouplementation

Darüber hinaus ermöglicht OrientDB die Arbeit mit den drei Arten von Schemas, unabhängig von der Art der API:

  • Schema-Full - Der strikte Modus ist aktiviert, sodass alle Felder bei der Klassenerstellung angegeben werden
  • Schema-weniger - Klassen werden ohne bestimmte Eigenschaft erstellt, sodass wir sie nach Belieben hinzufügen können. Dies ist der Standardmodus
  • 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, das Scheitelpunkte (Knoten) enthält, die durch Kanten (Bögen) miteinander verbunden sind.

Genannt Als ersten Schritt wollen wir die Benutzeroberfläche verwenden , um ein Graph - Datenbank erstellen BaeldungDB mit einem Benutzer Admin und das Kennwort admin ein .

Wie wir im folgenden Bild sehen, wurde das Diagramm als Datenbanktyp ausgewählt, sodass auf seine Daten auf der Registerkarte GRAFIK zugegriffen werden kann :

Stellen Sie nun eine Verbindung zur gewünschten Datenbank her und wissen Sie, dass ORIENTDB_HOME eine Umgebungsvariable ist, die dem Installationsordner von OrientDB entspricht :

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

Lassen Sie uns die Klassen " Artikel" , " Autor" und " Editor " 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, in der:

  • Artikel ist die schemalose Klasse, die Artikel enthält
  • Writer ist eine schemaberechte Superklasse, die die erforderlichen Writer-Informationen enthält
  • Writer ist ein Untertyp des Autors , der seine Details enthält
  • Editor ist ein schemaloser Untertyp von Writer , der Editordetails enthält
  • Das Feld lastName wurde im gespeicherten Autor nicht ausgefüllt, wird jedoch in der folgenden Grafik angezeigt
  • Wir haben eine Beziehung zwischen allen Klassen: Ein Autor kann Artikel schreiben und benötigt einen Editor
  • Scheitelpunkt repräsentiert eine Entität mit einigen Feldern
  • Edge ist eine Entität, die zwei Scheitelpunkte verbindet

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

Nachdem Sie mit OrientDB Studio eine Verbindung zu unserer Datenbank hergestellt haben, sehen wir die grafische Darstellung unserer Daten:

Mal sehen, wie man die Anzahl aller Datensätze (Eckpunkte) der Datenbank hat:

long size = graph.countVertices();

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

@Test public void givenBaeldungDB_checkWeHaveTwoWriters() { long size = graph.countVertices("Writer"); assertEquals(2, size); }

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

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

Lassen Sie uns abschließend alle Editoren mit Stufe 7 abfragen . hier haben wir nur eine, die passt:

@Test public void givenBaeldungDB_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 bei der Anforderung nach einem bestimmten Scheitelpunkt zu suchen. Weitere Details finden Sie hier.

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 verfügbar, die in Feldern gespeichert sind, in denen der Typ Text, Bild oder eine binäre Form sein kann.

Verwenden wir die Benutzeroberfläche erneut, um eine Datenbank mit dem Namen BaeldungDBTwo zu erstellen , jetzt jedoch mit einem Dokument als Typ:

Hinweis: Ebenso kann diese API entweder im Schema-Voll-, Schema-Ohne- oder Schema-Hybrid-Modus verwendet werden.

The database connection remains straightforward as we just need to instantiate an ODatabaseDocumentTx object, provide the database URL and the database user's credentials:

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

Let's start with saving a simple document that holds an Author information.

Here we can see that the class has been automatically created:

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

Accordingly, to count the number of Authors, we can use:

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

Let's query documents again using a field value, to search for the Author‘s objects with level 7:

@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()); }

Likewise, to delete all the records of Author class, we can use:

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

On the OrientDB studio's BROWSE Tab we can make a query to get all our Author's objects:

4.3. Object API

OrientDB doesn't have the object type of database. Thus, the Object API is relying on a Document database.

In Object API type, all other concepts remain the same with only one addition – binding to POJO.

Let's start by connecting to the BaeldungDBThree by using the OObjectDatabaseTx class:

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

Next, by assuming that the Author is the POJO used to hold an Author data, we need to register it:

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

Author has getters and setters for the following fields:

  • firstName
  • lastName
  • level

Let's create an Author with multi-line instructions if we acknowledged a no-arg constructor:

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

On the other hand, if we've another constructor that takes the firstName, lastName, and level of the Author respectively, the instantiation is just one line:

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

The following lines are using to browse and delete all the records of Author class:

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

To count all authors we just have to provide the class and the database instance without the need to write an SQL query:

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

Similarly, we query authors with level 7 like so:

@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()); }

Finally, this is the official guide that introduces some advanced Object API uses.

5. Conclusion

In diesem Artikel haben wir gesehen, wie OrientDB als Datenbankverwaltungssystem mit seinen Java-APIs verwendet wird. Wir haben auch gelernt, wie man Validierung für die Felder hinzufügt und einige einfache Abfragen schreibt.

Wie immer finden Sie den Quellcode für diesen Artikel auf GitHub.