Seite 2: Neo4j

Inhaltsverzeichnis

Auf den Zug aufgesprungen

Neo4j ist eine ACID-transaktionale Datenbank, die in Java implementiert ist. Ihre Ursprünge reichen bis ins Jahr 2003 zurück, seit Anfang 2010 liegt die Version 1.0 vor, zurzeit wird an Version 1.2 gearbeitet. Neo4j wurde also bereits vor der "NoSQL"-Welle entwickelt und eingesetzt. Neo4j wird von der Firma NeoTechnology betreut, über die bei Bedarf auch eine kommerzielle Lizenz inklusive Support als Alternative zur freien (AGPLv3-)Lizenz verfügbar ist.

Wie erwähnt sind die Kernbestandteile von Graphendatenbanken Knoten und Kanten, die sich jeweils durch Properties näher beschreiben lassen. Das Standardbeispiel, das man in beinahe jedem Tutorial zu Graphendatenbanken beziehungsweise Neo4j findet, ist das aus den sozialen Web-2.0-Netzen bekannte "Wer kennt wen"-Beispiel. Daher soll dieses "Hello-World der Graphendatenbanken" auch hier verwendet werden. In der einfachsten Variante existieren mehrere Personen, die sich untereinander kennen. Die Personen werden als Knoten modelliert, die Sich-kennen-Beziehungen als Kanten. Über die Neo4j-Java-API lassen sich zwei Personen inklusive Beziehung wie folgt anlegen:

EmbeddedGraphDatabase neo4j_db = new EmbeddedGraphDatabase("testdb");
Transaction tx = neo4j_db.beginTx();
 try {
  Node person_a = neo4j_db.createNode();
   person_a.setProperty("vorname","Willi");
   person_a.setProperty("nachname","Müller");
  Node person_b = neo4j_db.createNode();
  person_b.setProperty("vorname","Heinz");
  person_b.setProperty("nachname","Schmidt");
  person_a.createRelationshipTo(person_b, KENNT);
}
finally {
   tx.finish();
   neo4j_db.shutdown();
 }

In dem Beispiel existiert nur eine Beziehung vom Typ KENNT, der auf Java-Ebene zuvor mit

RelationshipType KENNT = DynamicRelationshipType.withName("KENNT");

zu erstellen ist. Über den RelationshipType kann man nun alle Beziehungen einer Person wie folgt ermitteln:

for(Relationship bekanntenkreis:person_a.getRelationships(KENNT)){
  Node bekannter = bekanntenkreis.getOtherNode(person_a);
  System.out.println("Der nächste Bekannte ist "
     + bekannter.getProperty("vorname") + " 
     + bekannter.getProperty("nachname"));
}

Hilfestellung durch Frameworks

Neo4j zeichnet sich durch eine Vielzahl von Sprachanbindungen und Frameworks aus, mit denen sich auf die Daten zugreifen lässt. Wer als Java-Entwickler vor der Aufgabe steht, Daten aus einer Neo4j-Datenbank in einer Java-Anwendung zu verwenden, dem sei ein Blick auf jo4neo empfohlen. Über Annotationen kann man hiermit POJOs (Plain Old Java Objects) so erweitern, dass sich über das Framework die zugehörigen Daten aus Neo4j extrahieren lassen. Der folgende Sourcecode-Auszug aus der jo4neo-Website illustriert das Vorgehen:

public class Person {
   //used by jo4neo
   transient Nodeid node; 
   //simple property
   @neo String firstName;
   //helps you store a java.util.Date to neo4j 
   @neo Date date; 
   // jo4neo will index for you
   @neo(index=true) String email; 
   // many to many relation
   @neo Collection<Role> roles; 

   /* normal class oriented 
    * programming stuff goes here
    */
}

Ruby-Entwickler finden ein vergleichbares Framework auf GitHub, und auch für Python-, Scala- und Clojure Anhänger sind Angebote verfügbar. Frameworks für Grails, Spring sowie ein Eclipse-Plug-in namens Neoclipse runden das Bild ab.

Welche Abfragesprachen gibt es für Graphendatenbanken im Allgemeinen beziehungsweise Neo4j im Speziellen? SQL als "Standard-Abfragesprache für Datenbanken" ist für die speziellen Gegebenheiten eines als Netzwerk verfügbaren Datenmodells unpassend, da es nicht auf Knoten, Kanten und Pfaden basiert. Als NoSQL-Datenbanken müssen auch die Graphendatenbanken ihrem Namen alle Ehre machen und bieten speziell auf ihre Speicherstruktur zugeschnittene Abfragesprachen an. Zu nennen sind SPARQL und Gremlin. Während sich Ersteres in seiner Syntax an SQL orientiert, finden sich in Gremlin viele Konstrukte, die an die XML-Abfragesprache XPath erinnern. Zusätzlich bieten Graphendatenbanken wie Neo4j native Abfragemöglichkeiten an. Diese konzentrieren sich auf die pfadbasierte Suche. Ist dagegen eine Volltextsuche über die gesamte Knotenhierarchie gefordert, lässt sich in Neo4j auf Apache Lucene zurückgreifen.

Fazit

Als Graphendatenbank kommt Neo4j insbesondere bei Projekten in Frage, bei denen eine Modellierung in Graphenform möglich ist. Zu nennen sind vor allem geographische Anwendungen sowie jene, bei denen (soziale) Beziehungen im Mittelpunkt stehen. Wer ein solches Projekt bearbeitet, findet mit Neo4j einen NoSL-Vertreter, der schon eine lange Lebensdauer vorweisen kann und daher in zahlreichen Praxisprojekten seine Reife unter Beweis stellen konnte.

Rudolf Jansen
arbeitet als freiberuflicher Software-Entwickler und Journalist in Aachen. Seine Tätigkeitsschwerpunkte liegen in den Bereichen Java, C++, XML und Datenbanken. (ane)