Introduction aux API Java d'OrientDB

1. Vue d'ensemble

OrientDB est une technologie de base de données NoSQL multi-modèle open source conçue pour fonctionner avec les modèles Graph, Document, Key-Value, GeoSpatial et Reactive tout en gérant les requêtes avec la syntaxe SQL.

Dans cet article, nous allons couvrir la configuration et utiliser les API Java OrientDB.

2. Installation

Tout d'abord, nous devons installer le package binaire.

Téléchargeons la dernière version stable d'OrientDB (2.2.x au moment de la rédaction de cet article).

Deuxièmement, nous devons le décompresser et déplacer son contenu dans un répertoire pratique (en utilisant ORIENTDB_HOME ). Assurez-vous d'ajouter le dossier bin aux variables d'environnement pour une utilisation facile de la ligne de commande.

Enfin, nous devons éditer le fichier orientdb.sh situé dans $ ORIENTDB_HOME / bin en remplissant l'emplacement ( ORIENTDB_HOME ) du répertoire OrientDB à la place de ORIENTDB_DIR et également l'utilisateur système que nous aimerions utiliser à la place de USER_YOU_WANT_ORIENTDB_RUN_WITH .

Maintenant, nous avons un OrientDB entièrement fonctionnel. Nous pouvons utiliser le script orientdb.sh avec des options:

  • start : pour démarrer le serveur
  • status : pour vérifier l'état

  • stop : pour arrêter le serveur

Veuillez noter que les actions de démarrage et d' arrêt nécessitent le mot de passe de l'utilisateur (celui que nous avons configuré dans le fichier orientdb.sh ).

Une fois le serveur lancé, il occupera le port 2480. Nous pouvons donc y accéder localement en utilisant cette URL:

Plus de détails sur l'installation manuelle peuvent être trouvés ici.

Remarque: OrientDB nécessite Java version 1.7 ou supérieure.

Les versions précédentes sont disponibles ici.

3. Configuration des API Java OrientDB

L'OrientDB permet aux développeurs Java de travailler avec trois API différentes telles que:

  • Graph API - bases de données de graphes
  • Document API - bases de données orientées document
  • Object API - objets directement liés au document OrientDB

Nous pouvons utiliser tous ces types dans une seule base de code simplement en intégrant et en utilisant OrientDB.

Jetons un coup d'œil à quelques jars disponibles que nous pouvons inclure dans le classpath du projet:

  • orientdb-core - *. jar : apporte la bibliothèque principale
  • blueprints-core - *. jar : pour apporter les composants de base des adaptateurs
  • orientdb-graphdb - *. jar : donne l'API de la base de données Graph
  • orientdb-object - *. jar : fournit l'API de base de données d'objets
  • orientdb-shared - *. jar : fournit le plugin de base de données distribuée pour fonctionner avec un cluster de serveurs
  • orientdb-tools - *. jar : passe la commande console
  • orientdb-client - *. jar : fournit le client distant
  • orientdb-enterprise - *. jar : active le protocole et les classes réseau partagés par le client et le serveur

Les deux derniers ne sont nécessaires que si nous gérons nos données sur un serveur distant.

Commençons par un projet Maven et utilisons les dépendances suivantes:

 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 

Veuillez consulter le référentiel Maven Central pour les dernières versions d'OrientDB Core, GraphDB, Object APIs et Blueprints-Core.

4. Utilisation

L'OrientDB utilise l'implémentation TinkerPop Blueprints pour travailler avec des graphiques.

TinkerPop est un framework de calcul graphique fournissant de nombreuses façons de créer des bases de données graphiques, où chacune d'elles a ses implémentations:

  • Blueprints
  • Tuyaux
  • Diablotin
  • Rexster
  • Mise en place de voile

De plus, OrientDB permet de travailler avec les trois types de schémas quel que soit le type d'API:

  • Schema-Full - le mode strict est activé, donc tous les champs sont spécifiés lors de la création de la classe
  • Sans schéma - les classes sont créées sans propriété spécifique, nous pouvons donc les ajouter comme nous le voulons; c'est le mode par défaut
  • Schema-Hybrid - c'est le mélange de schéma complet et sans schéma où nous pouvons créer une classe avec des champs prédéfinis mais laisser l'enregistrement définir d'autres personnalisés

4.1. API Graph

Puisqu'il s'agit d'une base de données basée sur des graphiques, les données sont représentées sous la forme d'un réseau contenant des sommets (nœuds) interconnectés par des arêtes (arcs).

Dans un premier temps, utilisons l'interface utilisateur pour créer une base de données Graph appelée BaeldungDB avec un administrateur d' utilisateur et un administrateur de mot de passe .

Comme nous le voyons dans l'image suivante, le graphique a été sélectionné comme type de base de données, donc par conséquent ses données seront accessibles dans l' onglet GRAPH :

Connectons- nous maintenant à la base de données souhaitée, sachant que ORIENTDB_HOME est une variable d'environnement qui correspond au dossier d'installation d' OrientDB :

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

Lançons les classes Article , Author et Editor - tout en montrant comment ajouter une validation à leurs champs:

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

Dans l'extrait de code ci-dessus, nous avons fait une représentation simple de notre base de données simple où:

  • Article est la classe sans schéma qui contient les articles
  • Writer est une super-classe complète de schéma qui contient les informations nécessaires sur le rédacteur
  • Writer est un sous-type d' auteur qui contient ses détails
  • Editor est un sous-type de Writer sans schéma qui contient les détails de l'éditeur
  • Le champ lastName n'a pas été renseigné dans l'auteur enregistré mais apparaît toujours sur le graphique suivant
  • nous avons une relation entre toutes les classes: un auteur peut écrire un article et doit avoir un éditeur
  • Vertex représente une entité avec certains champs
  • Edge est une entité qui relie deux sommets

Veuillez noter qu'en essayant d'ajouter une autre propriété à un objet d'une classe complète, nous nous retrouverons avec l'exception OValidationException.

Après vous être connecté à notre base de données en utilisant le studio OrientDB, nous verrons la représentation graphique de nos données:

Voyons comment avoir le nombre de tous les enregistrements (sommets) de la base de données:

long size = graph.countVertices();

Maintenant, montrons juste le nombre d' objets Writer (Author & Editor) :

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

Dans l'étape suivante, nous pouvons trouver toutes les données de Writer , en utilisant l'instruction suivante:

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

Enfin, recherchons tous les éditeurs de niveau 7; ici, nous n'en avons qu'un qui correspond:

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

Le nom de la classe est toujours spécifié pour rechercher un sommet spécifique lors de la demande. Nous pouvons trouver plus de détails ici.

4.2. API de document

L'option suivante consiste à utiliser le modèle de document d'OrientDB. Cela expose la manipulation des données via un simple enregistrement avec des informations stockées dans des champs où le type peut être du texte, une image ou une forme binaire.

Utilisons à nouveau l'interface utilisateur pour créer une base de données nommée BaeldungDBTwo , mais maintenant avec un document comme type:

Remarque: de même, cette API peut également être utilisée en mode schéma complet, sans schéma ou hybride de schéma.

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

Dans cet article, nous avons vu comment utiliser OrientDB en tant que système de gestion de base de données avec ses API Java. Nous avons également appris comment ajouter une validation sur les champs et écrire quelques requêtes simples.

Comme toujours, le code source de cet article se trouve à l'adresse over sur GitHub.