Ein Leitfaden für Neo4J mit Java

1. Einführung

In diesem Artikel geht es umNeo4j - eine der ausgereiftesten und umfassendsten Grafikdatenbanken auf dem heutigen Markt. Graphendatenbanken nähern sich der Aufgabe der Datenmodellierung mit der Ansicht, dass viele Dinge im Leben als Sammlung vonnodes (V) und Verbindungen zwischen ihnen, die alsedges (E) bezeichnet werden, dargestellt werden können.

2. Eingebettetes Neo4j

Der einfachste Weg, um mitNeo4j zu beginnen, ist die Verwendung der eingebetteten Version, in derNeo4j in derselben JVM wie Ihre Anwendung ausgeführt wird.

Zuerst müssen wir eine Maven-Abhängigkeit hinzufügen:


    org.neo4j
    neo4j
    3.4.6

Sie könnenthis link überprüfen, um die neueste Version herunterzuladen.

Als nächstes erstellen wir eine Fabrik:

GraphDatabaseFactory graphDbFactory = new GraphDatabaseFactory();

Zuletzt erstellen wir eine eingebettete Datenbank:

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

Jetzt kann die eigentliche Aktion beginnen! Zuerst müssen wir einige Knoten in unserem Diagramm erstellen und dafür müssen wir eine Transaktion starten, daNeo4j jede destruktive Operation ablehnen, es sei denn, eine Transaktion wurde gestartet:

graphDb.beginTx();

Sobald eine Transaktion ausgeführt wird, können wir mit dem Hinzufügen von Knoten beginnen:

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

Hier haben wir einen KnotenCar mit den Eigenschaftenmake undmodel sowie einen KnotenPerson mit den EigenschaftenfirstName undlastName hinzugefügt

Nun können wir eine Beziehung hinzufügen:

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

In der obigen Anweisung wurde eine Kante hinzugefügt, die die beiden Knoten mit der Bezeichnungownerverbindet. Wir können diese Beziehung überprüfen, indem wir eine Abfrage ausführen, die inNeo4j’s mächtigerCypher Sprache geschrieben ist:

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

Hier bitten wir Sie, einen Autobesitzer für jedes Auto zu finden, dessen Marke Tesla ist, und geben Sie uns seinen Vor- und Nachnamen zurück. Es ist nicht überraschend, dass dies ergibt:\{p.firstName=example, p.lastName=example}

3. Cypher-Abfragesprache

Neo4j bietet eine sehr leistungsfähige und ziemlich intuitive Abfragesprache, die alle Funktionen unterstützt, die man von einer Datenbank erwarten würde. Lassen Sie uns untersuchen, wie wir diesen Standard zum Erstellen, Abrufen, Aktualisieren und Löschen von Aufgaben erreichen können.

3.1. Knoten erstellen

Mit dem Schlüsselwort "Create" können sowohl Knoten als auch Beziehungen erstellt werden.

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

Hier haben wir ein Unternehmen mit einer einzelnen Eigenschaftname erstellt. Eine Knotendefinition ist durch Klammern gekennzeichnet und ihre Eigenschaften sind in geschweiften Klammern eingeschlossen. In diesem Fall istself ein Alias für den Knoten undCompany ist eine Knotenbezeichnung.

3.2. Beziehung erstellen

Es ist möglich, einen Knoten und eine Beziehung zu diesem Knoten in einer einzigen Abfrage zu erstellen:

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

Hier haben wir die Knotenexample undtesla erstellt und eine Eigentumsbeziehung zwischen ihnen hergestellt. Das Erstellen von Beziehungen zu bereits vorhandenen Knoten ist natürlich auch möglich.

3.3. Daten abrufen

Das SchlüsselwortMATCHwird verwendet, um Daten in Kombination mitRETURN zu finden, um zu steuern, welche Datenpunkte zurückgegeben werden. DieWHERE-Klausel kann verwendet werden, um nur die Knoten herauszufiltern, die die gewünschten Eigenschaften haben.

Lassen Sie uns den Namen des Unternehmens herausfinden, dem das Tesla-Modell X gehört:

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

3.4. Knoten aktualisieren

Das SchlüsselwortSETkann zum Aktualisieren von Knoteneigenschaften oder Beschriftungen verwendet werden. Fügen wir unserem Tesla Meilen hinzu:

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

Hier fügen wir eine neue Eigenschaft mit dem Namenmilage hinzu, ändern Beschriftungen so, dass sie sowohlCar als auchElectro sind, und löschen schließlich die Eigenschaftmodelinsgesamt.

3.5. Knoten löschen

Das Schlüsselwort DELETE kann zum dauerhaften Entfernen von Knoten oder Beziehungen aus dem Diagramm verwendet werden:

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

Hier haben wir eine Firma namens example gelöscht.

3.6. Parameterbindung

In den obigen Beispielen haben wir fest codierte Parameterwerte, was nicht die beste Vorgehensweise ist. Glücklicherweise bietetNeo4j die Möglichkeit, Variablen an eine Abfrage zu binden:

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. Java-Treiber

Bisher haben wir uns mit der Interaktion mit einer eingebettetenNeo4j-Instanz befasst. Höchstwahrscheinlich möchten wir jedoch einen eigenständigen Server betreiben und über einen bereitgestellten Treiber eine Verbindung zu ihm herstellen. Zuerst müssen wir eine weitere Abhängigkeit in unseren Mavenpom.xml hinzufügen:


    org.neo4j.driver
    neo4j-java-driver
    1.6.2

Sie könnenthis link folgen, um nach der neuesten Version dieses Treibers zu suchen.

Jetzt können wir eine Verbindung herstellen:

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

Dann erstelle eine Sitzung:

Session session = driver.session();

Schließlich können wir einige Abfragen ausführen:

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

Sobald wir mit all unserer Arbeit fertig sind, müssen wir sowohl die Sitzung als auch den Fahrer schließen:

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

5. JDBC-Treiber

Es ist auch möglich, mitNeo4j über einen JDBC-Treiber zu interagieren. Noch eine Abhängigkeit für unserepom.xml:


    org.neo4j
    neo4j-jdbc-driver
    3.4.0

Sie könnenthis link folgen, um die neueste Version dieses Treibers herunterzuladen.

Als Nächstes stellen wir eine JDBC-Verbindung her:

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

Hier istcon eine reguläre JDBC-Verbindung, die zum Erstellen und Ausführen von Anweisungen oder vorbereiteten Anweisungen verwendet werden kann:

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. Objekt-Graph-Mapping

Object-Graph-Mapping oder OGM ist eine Technik, die es uns ermöglicht, unsere Domain-POJOs als Entitäten in derNeo4j-Datenbank zu verwenden. Lassen Sie uns untersuchen, wie dies funktioniert. Im ersten Schritt fügen wir wie gewohnt unserenpom.xml neue Abhängigkeiten hinzu:


    org.neo4j
    neo4j-ogm-core
    3.1.2



    org.neo4j
    neo4j-ogm-embedded-driver
    3.1.2

Sie könnenOGM Core Link undOGM Embedded Driver Link überprüfen, um nach den neuesten Versionen dieser Bibliotheken zu suchen.

Zweitens kommentieren wir unsere POJOs mit OGM-Anmerkungen:

@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 informiertNeo4j darüber, dass dieses Objekt im resultierenden Diagramm durch einen Knoten dargestellt werden muss. @Relationship teilt die Notwendigkeit mit, eine Beziehung zu einem Knoten herzustellen, der den zugehörigen Typ darstellt. In diesem Fall besitzt eincompany eincar.

Bitte beachten Sie, dass fürNeo4j für jede Entität ein Primärschlüssel erforderlich ist, wobei standardmäßig ein Feld mit dem Namenid erfasst wird. Ein alternativ benanntes Feld kann durch Annotieren mit@Id @GeneratedValue. verwendet werden

Dann müssen wir eine Konfiguration erstellen, die zum Booten vonNeo4j OGM verwendet wird. Verwenden wir der Einfachheit halber eine eingebettete In-Memory-Datenbank:

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

Danach initialisieren wirSessionFactory mit der von uns erstellten Konfiguration und einem Paketnamen, in dem sich unsere kommentierten POJOs befinden:

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

Schließlich können wir einSession erstellen und es verwenden:

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

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

Hier haben wir eine Sitzung initiiert, unsere POJOs erstellt und die OGM-Sitzung gebeten, diese beizubehalten. Neo4j OGM-Laufzeit konvertierte Objekte transparent in eine Reihe vonCypher-Abfragen, die geeignete Knoten und Kanten in der Datenbank erstellten.

Wenn dieser Prozess bekannt vorkommt, dann deshalb! Genau so funktioniert JPA. Der einzige Unterschied besteht darin, ob das Objekt in Zeilen übersetzt wird, die in einem RDBMS beibehalten werden, oder in einer Diagrammdatenbank eine Reihe von Knoten und Kanten.

7. Fazit

Dieser Artikel befasste sich mit einigen Grundlagen einer grafikorientierten Datenbank Neo4j.

Wie immer ist der Code in dieser Beschreibung alle verfügbarenover on Github.

TOC

Ein Leitfaden für Neo4J mit Java