Comment intégrer Janus Graph dans Java

JanusGraph fournit des pilotes pour divers langages tels que Python et Javascript, et il est possible d'accéder au serveur Gremlin à partir de ces langages, mais je voulais créer une application (intégrée) qui incorpore la base de données elle-même. Dans ce cas, les choix sont effectivement limités à Java et Groovy.

Cette fois, je vais vous expliquer comment créer une application qui intègre Janus Graph (avec Berkeley DB) en Java.

Les paramètres de base de données et les données persistantes sont enregistrés dans des répertoires, mais à part cela, il s'agit d'une configuration d'application simple qui est effectuée indépendamment.

Variables d'installation et d'environnement JDK

Si vous souhaitez simplement exécuter JanusGraph, vous pouvez simplement utiliser JRE, mais si vous souhaitez développer, vous avez besoin de JDK. La version sera Java 8. Il semble que vous deviez créer un compte lors du téléchargement depuis Oracle, donc cette fois j'ai choisi AdoptOpenJDK.

Allez à l'URL et sélectionnez ʻOpenJDK 8 (LTS) dans 1. et HotSpot` dans 2. (les deux sont par défaut). À partir des fichiers affichés, téléchargez le JDK qui correspond à votre système d'exploitation.

J'ai utilisé la version jdk8u242-b08 (8.0.242.08) pour Windows x64.

La méthode d'installation est omise. Après l'installation, enregistrez le répertoire JDK en tant que variable d'environnement JAVA_HOME. Dans mon cas, c'était comme suit.

JAVA_HOME=c:\Program Files\AdoptOpenJDK\jdk-8.0.242.08-hotspot

Apache NetBeans

L'EDI utilisé pour le développement peut en fait être n'importe quoi, mais ici nous expliquerons comment utiliser Apache NetBeans. J'ai aussi essayé Eclipse, mais ça ne s'est pas bien passé, alors j'ai abandonné.

Installation

Téléchargez à partir de ce qui suit.

Apache NetBeans

J'ai choisi 11.3 comme version (car le programme d'installation était disponible pour Windows). Si la variable d'environnement JAVA_HOME n'est pas définie, une erreur se produira lors de l'installation.

Tous les installateurs ont procédé avec les paramètres standard pour terminer l'installation.

Créer un projet

Lorsque vous démarrez NetBeans, l'écran suivant s'affiche.

Sélectionnez "Fichier" - "Nouveau projet ..." dans le menu.

Puisque «Application Java» de «Java avec Maven» est sélectionné dans l'état initial, appuyez simplement sur le bouton «Suivant>».

Si c'est la première fois, un message indiquant que le plug-in etc. doit être téléchargé sera affiché, alors appuyez sur le bouton "Télécharger et activer" pour continuer.

Ensuite, définissez le nom du projet et l'emplacement du répertoire. L'un ou l'autre est approprié. Après avoir tout confirmé, cliquez sur le bouton "Terminer" pour terminer la création du projet.

Ajouter une dépendance (voir Janus Graph)

Sélectionnez «Fichiers» dans la ligne «Projet», «Fichiers» et «Services» en haut à gauche pour afficher l'arborescence des fichiers existant dans le projet.

Double-cliquez sur pom.xml pour l'ouvrir. Voici les informations de dépendance de Janus Graph.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>janusexample</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.janusgraph</groupId>
            <artifactId>janusgraph-core</artifactId>
            <version>0.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.janusgraph</groupId>
            <artifactId>janusgraph-berkeleyje</artifactId>
            <version>0.5.1</version>
        </dependency>
    </dependencies>
</project>

Ajouté entre «» et «</ dependencies>». Comme son nom l'indique, janus graph-core est la partie centrale de Janus Graph. janusgraph-berkeleyje est une bibliothèque requise pour utiliser la base de données intégrée de Berkeley. En outre, ajoutez les bibliothèques nécessaires selon les besoins en fonction de l'objectif.

Ajouter un fichier de configuration de base de données

Cette fois, je veux inclure Berkeley DB, donc je vais ajouter un tel fichier de configuration au projet.

Créez un répertoire conf dans le répertoire racine de l'arborescence de fichiers et ajoutez-y le fichier ʻembedded.properties` (le nom du fichier peut être n'importe quoi).

Écrivez les trois lignes suivantes dans le fichier.

embedded.properties

gremlin.graph=org.janusgraph.core.JanusGraphFactory
storage.backend=berkeleyje
storage.directory=../db/berkeley

Créer un programme

Ajoutez le code source du programme. Créez votre propre fichier de classe dans le répertoire avec le même nom que le nom du projet créé dans la partie la plus profonde du répertoire src. Le nom est «JanusExample.java».

Le contenu du code est le suivant dans un premier temps.

JanusExample.java

import org.apache.tinkerpop.gremlin.structure.Graph;
import org.janusgraph.core.JanusGraphFactory;

public class JanusExample {
    public static void main(String args[])
    {
        Graph graph = JanusGraphFactory.open("conf/embedded.properties");
        System.out.println(graph.toString());
        graph.close();
    }
}

Ceci est un exemple simple qui ouvre et ferme simplement le graphique. Build est "Exécuter" "Build Project" (touche F11 dans Windows) dans le menu. Il peut être exécuté à partir de "Exécuter" et "Exécuter le projet" (touche F6 sous Windows). La première fois que Maven télécharge diverses choses, cela prend donc beaucoup de temps. Une fois exécuté, un répertoire db sera créé et les données y seront stockées.

Pour interroger, récupérez la source de la traversée graphique. Obtenir la valeur de retour est un langage typé statiquement, donc c'est assez difficile, mais j'espère que vous le faites bien.

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.janusgraph.core.JanusGraphFactory;

public class JanusExample {
    public static void main(String args[])
    {
        Graph graph = JanusGraphFactory.open("conf/embedded.properties");
        GraphTraversalSource g = graph.traversal();
        //Vider le graphique
        g.V().drop().iterate();
        //Ajouter un sommet
        g.addV("person").property("name", "bob").property("age", 27).iterate();
        //Confirmer le changement
        g.tx().commit();
        //Essayez d'émettre une requête pour récupérer la valeur
        List<Map<Object, Object>> result = g.V().valueMap("name", "age").toList();
        //La valeur de retour est[{name: ["bob"], age: [27]}]Devrait être retourné
        for(Map<Object, Object> vertex : result){
            //le sommet est{name:["bob"], age: [27]}Devrait être
            ArrayList<String> names = (ArrayList<String>)vertex.get("name");  // ["bob"]Avoir
            ArrayList<Integer> ages = (ArrayList<Integer>)vertex.get("age");  // [27]Avoir
            String name = names.get(0);  //"bob"Avoir
            Integer age = ages.get(0);  //Obtenez 27
            System.out.printf("name: %s, age: %s\n", name, age);
        }
        //Essayez d'émettre une requête pour récupérer le nombre de sommets
        Long count = g.V().count().next();
        System.out.printf("vertex count is %d\n", count);
        graph.close();
    }
}

Le résultat devrait ressembler à ceci:

name: bob, age: 27
vertex count is 1

Remarque: que faire lorsqu'une erreur se produit

Si une exception se produit pendant l'exécution, le programme ne s'arrêtera pas. Si vous essayez de l'exécuter à nouveau tel quel, le graphique ne peut pas être ouvert, vous devez donc terminer le programme existant. Le bouton x est affiché en bas à droite de l'EDI, alors appuyez dessus pour quitter.

Référence de classe à utiliser

Si vous écrivez une classe qui n'a pas été importée dans votre code, elle s'affichera sous la forme d'une ligne rouge en bas. Vous pouvez importer la classe en déplaçant le curseur sur cette partie et en appuyant sur «Alt + Entrée». Pour être honnête, je ne peux pas développer en Java sans cette fonction.

en conclusion

Si vous n'êtes pas familier avec Java, il y a des douleurs (je suis moi-même un amateur, donc c'était vraiment douloureux), mais il est étonnamment facile à intégrer, donc je pense que c'est assez facile à utiliser.

Vous pouvez en faire une application autonome, ou vous pouvez convertir et envoyer les résultats de la requête vers JSON et l'utiliser comme un simple serveur GraphDB créé par vous-même.

Personnellement, ce serait idéal s'il pouvait être incorporé en Python comme ça ...