Un guide sur Neo4J avec Java

Un guide pour Neo4J avec Java

1. introduction

Cet article porte surNeo4j - l'une des bases de données graphiques les plus matures et les plus complètes du marché aujourd'hui. Les bases de données de graphes abordent la tâche de modélisation des données avec l'idée que de nombreux éléments de la vie se prêtent à être représentés comme une collection denodes (V) et de connexions entre eux appelésedges (E).

2. Neo4j intégré

La manière la plus simple de démarrer avecNeo4j est d'utiliser la version intégrée dans laquelleNeo4j s'exécute dans la même JVM que votre application.

Premièrement, nous devons ajouter une dépendance Maven:


    org.neo4j
    neo4j
    3.4.6

Vous pouvez vérifierthis link pour télécharger la dernière version.

Ensuite, créons une usine:

GraphDatabaseFactory graphDbFactory = new GraphDatabaseFactory();

Enfin, nous créons une base de données intégrée:

GraphDatabaseService graphDb = graphDbFactory.newEmbeddedDatabase(
  new File("data/cars"));

Maintenant, la vraie action peut commencer! Tout d'abord, nous devons créer des nœuds dans notre graphe et pour cela, nous devons démarrer une transaction carNeo4j rejettera toute opération destructive à moins qu'une transaction n'ait été lancée:

graphDb.beginTx();

Une fois la transaction en cours, nous pouvons commencer à ajouter des nœuds:

Node car = graphDb.createNode(Label.label("Car"));
car.setProperty("make", "tesla");
car.setProperty("model", "model3");

Node owner = graphDb.createNode(Label.label("Person"));
owner.setProperty("firstName", "example");
owner.setProperty("lastName", "example");

Ici, nous avons ajouté un nœudCar avec les propriétésmake etmodel ainsi qu'un nœudPerson avec les propriétésfirstName etlastName

Maintenant, nous pouvons ajouter une relation:

owner.createRelationshipTo(car, RelationshipType.withName("owner"));

L'instruction ci-dessus a ajouté une arête joignant les deux nœuds avec une étiquetteowner. Nous pouvons vérifier cette relation en exécutant une requête écrite dans le langageNeo4j’s puissant deCypher:

Result result = graphDb.execute(
  "MATCH (c:Car) <-[owner]- (p:Person) " +
  "WHERE c.make = 'tesla'" +
  "RETURN p.firstName, p.lastName");

Ici, nous demandons de trouver un propriétaire pour toute voiture dont la marque est tesla et de nous rendre son prénom et son nom. Sans surprise, cela renvoie:\{p.firstName=example, p.lastName=example}

3. Langage de requête de chiffrement

Neo4j fournit un langage d'interrogation très puissant et assez intuitif qui prend en charge la gamme complète des fonctionnalités attendues d'une base de données. Laissez-nous examiner comment nous pouvons accomplir cette norme créer, récupérer, mettre à jour et supprimer des tâches.

3.1. Créer un nœud

Le mot-clé Create peut être utilisé pour créer des nœuds et des relations.

CREATE (self:Company {name:"example"})
RETURN self

Ici, nous avons créé une entreprise avec une seule propriéténame. Une définition de nœud est marquée par des parenthèses et ses propriétés sont entourées d'accolades. Dans ce cas,self est un alias pour le nœud etCompany est une étiquette de nœud.

3.2. Créer une relation

Il est possible de créer un nœud et une relation avec ce nœud en une seule requête:

Result result = graphDb.execute(
  "CREATE (example:Company {name:\"example\"}) " +
  "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
  "RETURN example, tesla");

Ici, nous avons créé les nœudsexample ettesla et établi une relation de propriété entre eux. La création de relations avec des nœuds préexistants est bien sûr également possible.

3.3. Récupérer des données

Le mot cléMATCH est utilisé pour rechercher des données en combinaison avecRETURN pour contrôler les points de données renvoyés. La clauseWHERE peut être utilisée pour filtrer uniquement les nœuds qui ont les propriétés souhaitées.

Laissez-nous trouver le nom de la société qui possède le modèle X Tesla:

Result result = graphDb.execute(
  "MATCH (company:Company)-[:owns]-> (car:Car)" +
  "WHERE car.make='tesla' and car.model='modelX'" +
  "RETURN company.name");

3.4. Mettre à jour les nœuds

Le mot cléSET peut être utilisé pour mettre à jour les propriétés ou les étiquettes des nœuds. Ajoutons le kilométrage à nos tesla:

Result result = graphDb.execute("MATCH (car:Car)" +
  "WHERE car.make='tesla'" +
  " SET car.milage=120" +
  " SET car :Car:Electro" +
  " SET car.model=NULL" +
  " RETURN car");

Ici, nous ajoutons une nouvelle propriété appeléemilage, modifions les étiquettes pour qu'elles soient à la foisCar etElectro et enfin, nous supprimons complètement la propriétémodel.

3.5. Supprimer les nœuds

Le mot clé DELETE peut être utilisé pour supprimer définitivement les nœuds ou les relations du graphique:

graphDb.execute("MATCH (company:Company)" +
  " WHERE company.name='example'" +
  " DELETE company");

Ici, nous avons supprimé une entreprise nommée exemple.

3.6. Liaison de paramètres

Dans les exemples ci-dessus, nous avons des valeurs de paramètres codées en dur, ce qui n'est pas la meilleure pratique. Heureusement,Neo4j fournit une fonction pour lier des variables à une requête:

Map params = new HashMap<>();
params.put("name", "example");
params.put("make", "tesla");
params.put("model", "modelS");

Result result = graphDb.execute("CREATE (example:Company {name:$name}) " +
  "-[:owns]-> (tesla:Car {make: $make, model: $model})" +
  "RETURN example, tesla", params);

4. Pilote Java

Jusqu'à présent, nous avons cherché à interagir avec une instanceNeo4j intégrée, cependant, selon toute probabilité pour la production, nous souhaitons exécuter un serveur autonome et nous y connecter via un pilote fourni. Tout d'abord, nous devons ajouter une autre dépendance dans nos mavenpom.xml:


    org.neo4j.driver
    neo4j-java-driver
    1.6.2

Vous pouvez suivrethis link pour vérifier la dernière version de ce pilote.

Maintenant nous pouvons établir une connexion:

Driver driver = GraphDatabase.driver(
  "bolt://localhost:7687", AuthTokens.basic("neo4j", "12345"));

Ensuite, créez une session:

Session session = driver.session();

Enfin, nous pouvons exécuter quelques requêtes:

session.run("CREATE (example:Company {name:\"example\"}) " +
  "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
  "RETURN example, tesla");

Une fois tout notre travail terminé, nous devons fermer la session et le pilote:

session.close();
driver.close();

5. Pilote JDBC

Il est également possible d'interagir avecNeo4j via un pilote JDBC. Encore une autre dépendance pour nospom.xml:


    org.neo4j
    neo4j-jdbc-driver
    3.4.0

Vous pouvez suivrethis link pour télécharger la dernière version de ce pilote.

Ensuite, établissons une connexion JDBC:

Connection con = DriverManager.getConnection(
  "jdbc:neo4j:bolt://localhost/?user=neo4j,password=12345,scheme=basic");

Ici,con est une connexion JDBC standard qui peut être utilisée pour créer et exécuter des instructions ou des instructions préparées:

try (Statement stmt = con.
  stmt.execute("CREATE (example:Company {name:\"example\"}) "
  + "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})"
  + "RETURN example, tesla")

    ResultSet rs = stmt.executeQuery(
      "MATCH (company:Company)-[:owns]-> (car:Car)" +
      "WHERE car.make='tesla' and car.model='modelX'" +
      "RETURN company.name");

    while (rs.next()) {
        rs.getString("company.name");
    }
}

6. Mappage d'objets-graphes

Object-Graph-Mapping ou OGM est une technique qui nous permet d'utiliser nos POJO de domaine comme des entités dans la base de donnéesNeo4j. Laissez-nous examiner comment cela fonctionne. La première étape, comme d'habitude, nous ajoutons de nouvelles dépendances à nospom.xml:


    org.neo4j
    neo4j-ogm-core
    3.1.2



    org.neo4j
    neo4j-ogm-embedded-driver
    3.1.2

Vous pouvez vérifier lesOGM Core Link etOGM Embedded Driver Link pour vérifier les dernières versions de ces bibliothèques.

Deuxièmement, nous annotons nos POJO avec des annotations OGM:

@NodeEntity
public class Company {
    private Long id;

    private String name;

    @Relationship(type="owns")
    private Car car;
}

@NodeEntity
public class Car {
    private Long id;

    private String make;

    @Relationship(direction = "INCOMING")
    private Company company;
}

@NodeEntity informeNeo4j que cet objet devra être représenté par un nœud dans le graphique résultant. @Relationship communique la nécessité de créer une relation avec un nœud représentant le type associé. Dans ce cas, uncompany possède uncar.

Veuillez noter queNeo4j nécessite que chaque entité ait une clé primaire, avec un champ nomméid étant sélectionné par défaut. Un champ de nom alternatif peut être utilisé en l'annotant avec@Id @GeneratedValue.

Ensuite, nous devons créer une configuration qui sera utilisée pour amorcer l'OGM deNeo4j. Pour plus de simplicité, utilisons une base de données incorporée uniquement dans la mémoire:

Configuration conf = new Configuration.Builder().build();

Après cela, nous initialisonsSessionFactory avec la configuration que nous avons créée et un nom de package dans lequel résident nos POJO annotés:

SessionFactory factory = new SessionFactory(conf, "com.example.graph");

Enfin, nous pouvons créer unSession et commencer à l'utiliser:

Session session = factory.openSession();
Car tesla = new Car("tesla", "modelS");
Company example = new Company("example");

example.setCar(tesla);
session.save(example);

Ici, nous avons lancé une session, créé nos POJO et demandé à la session OGM de les conserver. Le runtime OGM deNeo4j a converti de manière transparente les objets en un ensemble de requêtesCypher qui ont créé les nœuds et les arêtes appropriés dans la base de données.

Si ce processus semble familier, c'est parce qu'il l'est! C’est précisément ainsi que fonctionne JPA, la seule différence étant le fait que l’objet soit traduit en lignes persistantes dans un SGBDR ou en une série de nœuds et d’arêtes persistants dans une base de données de graphes.

7. Conclusion

Cet article a examiné quelques bases d’une base de données graphique Neo4j.

Comme toujours, le code de cet article est entièrement disponibleover on Github.