streamalism.org

1. Inleiding

Dit artikel gaat over Neo4j - een van de meest volwassen en volledig uitgeruste grafische databases die momenteel op de markt zijn. Graph-databases benaderen de taak van datamodellering vanuit de visie dat veel dingen in het leven zich lenen om te worden weergegeven als een verzameling knooppunten (V) en verbindingen tussen hen genoemd randen (E).

2. Ingebouwde Neo4j

De gemakkelijkste manier om mee te beginnen Neo4j is om de embedded versie te gebruiken waarin Neo4j draait in dezelfde JVM als uw applicatie.

Eerst moeten we een Maven-afhankelijkheid toevoegen:

 org.neo4j neo4j 3.4.6 

U kunt deze link bekijken om de nieuwste versie te downloaden.

Laten we vervolgens een fabriek maken:

GraphDatabaseFactory graphDbFactory = nieuwe GraphDatabaseFactory ();

Ten slotte maken we een embedded database:

GraphDatabaseService graphDb = graphDbFactory.newEmbeddedDatabase (nieuw bestand ("data / cars"));

Nu kan de echte actie beginnen! Eerst moeten we enkele knooppunten in onze grafiek maken en daarvoor moeten we sindsdien een transactie starten Neo4j zal elke destructieve operatie weigeren, tenzij een transactie is gestart:

graphDb.beginTx ();

Zodra we een lopende transactie hebben, kunnen we beginnen met het toevoegen van knooppunten:

Knooppunt auto = graphDb.createNode (Label.label ("Auto")); car.setProperty ("make", "tesla"); car.setProperty ("model", "model3"); Knooppunt eigenaar = graphDb.createNode (Label.label ("Persoon")); owner.setProperty ("firstName", "baeldung"); owner.setProperty ("lastName", "baeldung");

Hier hebben we een knooppunt toegevoegd Auto met eigenschappen maken en model- evenals knooppunt Persoon met eigenschappen Voornaam en achternaam

Nu kunnen we een relatie toevoegen:

owner.createRelationshipTo (auto, RelationshipType.withName ("eigenaar"));

De bovenstaande verklaring heeft een rand toegevoegd die de twee knooppunten verbindt met een eigenaar etiket. We kunnen deze relatie verifiëren door een query uit te voeren die is geschreven in Neo4j's krachtig Cypher taal:

Resultaat resultaat = graphDb.execute ("MATCH (c: auto) <- [eigenaar] - (p: persoon)" + "WAAR c.make = 'tesla'" + "RETURN p.firstName, p.lastName");

Hier vragen we om een ​​auto-eigenaar te vinden voor elke auto waarvan het merk Tesla is en ons zijn / haar voornaam en achternaam terug te geven. Het is niet verwonderlijk dat dit terugkeert: {p.firstName = baeldung, p.lastName = baeldung}

3. Cypher Query Language

Neo4j biedt een zeer krachtige en redelijk intuïtieve zoektaal die alle functies ondersteunt die men van een database mag verwachten. Laten we eens kijken hoe we die standaard taken kunnen maken, ophalen, bijwerken en verwijderen.

3.1. Maak een knooppunt

Sleutelwoord maken kan worden gebruikt om zowel knooppunten als relaties te maken.

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

Hier hebben we een bedrijf opgericht met één eigendom naam. Een knooppuntdefinitie wordt gemarkeerd door haakjes en de eigenschappen ervan staan ​​tussen accolades. In dit geval, zelf is een alias voor het knooppunt en Bedrijf is een knooppuntlabel.

3.2. Creëer een relatie

Het is mogelijk om een ​​knooppunt en een relatie met dat knooppunt allemaal in één enkele query te maken:

Resultaat resultaat = graphDb.execute ("CREATE (baeldung: Bedrijf {naam: \" Baeldung \ "})" + "- [: bezit] -> (tesla: Auto {merk: 'tesla', model: 'modelX'} ) "+" RETURN baeldung, tesla ");

Hier hebben we knooppunten gemaakt baeldung en Tesla en vestigde een eigendomsrelatie tussen hen. Het leggen van relaties met reeds bestaande knooppunten is natuurlijk ook mogelijk.

3.3. Informatie ophalen

BIJ ELKAAR PASSEN trefwoord wordt gebruikt om gegevens te vinden in combinatie met TERUGKEER om te bepalen welke gegevenspunten worden geretourneerd. De WAAR clausule kan worden gebruikt om alleen die knooppunten uit te filteren die de eigenschappen hebben die we wensen.

Laten we de naam achterhalen van het bedrijf dat tesla modelX bezit:

Resultaat resultaat = graphDb.execute ("MATCH (company: Company) - [: owns] -> (car: Car)" + "WHERE car.make = 'tesla' en car.model = 'modelX'" + "RETURN company .naam");

3.4. Update knooppunten

SET trefwoord kan worden gebruikt voor het bijwerken van knooppunteigenschappen of labels. Laten we kilometers aan onze Tesla toevoegen:

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

Hier voegen we een nieuwe eigenschap toe met de naam kilometers, wijzig labels zodat ze beide zijn Auto en Elektro en tot slot verwijderen we model- eigendom helemaal.

3.5. Verwijder knooppunten

Het sleutelwoord DELETE kan worden gebruikt voor het permanent verwijderen van knooppunten of relaties uit de grafiek:

graphDb.execute ("MATCH (bedrijf: Bedrijf)" + "WAAR company.name = 'Baeldung'" + "DELETE bedrijf");

Hier hebben we een bedrijf met de naam Baeldung verwijderd.

3.6. Parameter bindend

In de bovenstaande voorbeelden hebben we hardgecodeerde parameterwaarden, wat niet de beste praktijk is. Gelukkig, Neo4j biedt een mogelijkheid om variabelen aan een query te binden:

Mapparams = nieuwe HashMap (); params.put ("naam", "baeldung"); params.put ("make", "tesla"); params.put ("model", "modelS"); Resultaat resultaat = graphDb.execute ("CREATE (baeldung: Company {name: $ name})" + "- [: owns] -> (tesla: Car {make: $ make, model: $ model})" + "RETURN baeldung, tesla ", params);

4. Java-stuurprogramma

Tot nu toe hebben we gekeken naar de interactie met een embedded Neo4j Voor productie zouden we echter naar alle waarschijnlijkheid een stand-alone server willen draaien en er verbinding mee maken via een bijgeleverd stuurprogramma. Eerst moeten we nog een afhankelijkheid toevoegen aan onze maven pom.xml:

 org.neo4j.driver neo4j-java-driver 1.6.2 

U kunt deze link volgen om te controleren op de nieuwste versie van deze driver.

Nu kunnen we een verbinding tot stand brengen:

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

Maak vervolgens een sessie:

Sessiesessie = driver.session ();

Ten slotte kunnen we enkele zoekopdrachten uitvoeren:

session.run ("CREATE (baeldung: Company {name: \" Baeldung \ "})" + "- [: owns] -> (tesla: auto {merk: 'tesla', model: 'modelX'})" + "RETURN baeldung, tesla");

Als we klaar zijn met al ons werk, moeten we zowel de sessie als de driver sluiten:

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

5. JDBC-stuurprogramma

Het is ook mogelijk om met Neo4j via een JDBC-stuurprogramma. Nog een andere afhankelijkheid voor ons pom.xml:

 org.neo4j neo4j-jdbc-stuurprogramma 3.4.0 

U kunt deze link volgen om de nieuwste versie van deze driver te downloaden.

Laten we vervolgens een JDBC-verbinding tot stand brengen:

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

Hier con is een normale JDBC-verbinding die kan worden gebruikt voor het maken en uitvoeren van statements of voorbereide statements:

try (Statement stmt = con. stmt.execute ("CREATE (baeldung: Company {name: \" Baeldung \ "})" + "- [: owns] -> (tesla: Car {merk: 'tesla', model: 'modelX'}) "+" RETURN baeldung, tesla ") ResultSet rs = stmt.executeQuery (" MATCH (bedrijf: Bedrijf) - [: bezit] -> (auto: Auto) "+" WAAR car.make = 'tesla 'and car.model =' modelX '"+" RETURN company.name "); while (rs.next ()) {rs.getString (" company.name ");}}

6. Object-Graph-mapping

Object-Graph-Mapping of OGM is een techniek die ons in staat stelt om onze domein POJO's te gebruiken als entiteiten in de Neo4j database. Laten we eens kijken hoe dit werkt. De eerste stap, zoals gewoonlijk, voegen we nieuwe afhankelijkheden toe aan onze pom.xml:

 org.neo4j neo4j-ogm-core 3.1.2 org.neo4j neo4j-ogm-embedded-driver 3.1.2 

U kunt de OGM Core Link en OGM Embedded Driver Link controleren om te controleren op de nieuwste versies van deze bibliotheken.

Ten tweede annoteren we onze POJO's met OGM-annotaties:

@NodeEntity openbare klasse Bedrijf {privé Lange id; private String naam; @Relationship (type = "owns") privéauto auto; } @NodeEntity openbare klasse Auto {privé Lange id; private String maken; @Relationship (direction = "INCOMING") besloten vennootschap; }

@NodeEntity informeert Neo4j dat dit object moet worden weergegeven door een knoop in de resulterende grafiek. @Relatie communiceert de noodzaak om een ​​relatie te creëren met een knooppunt dat het gerelateerde type vertegenwoordigt. In dit geval een bedrijf bezit een auto.

Houd er rekening mee dat Neo4j vereist dat elke entiteit een primaire sleutel heeft, met een veld met de naam ID kaart wordt standaard opgehaald. Een alternatief genoemd veld kan worden gebruikt door het te annoteren met @Id @GeneratedValue.

Vervolgens moeten we een configuratie maken die zal worden gebruikt om op te starten Neo4j‘S OGM. Laten we voor de eenvoud een embedded in-memory only database gebruiken:

Configuratie conf = nieuwe Configuration.Builder (). Build ();

Daarna initialiseren we SessionFactory met de configuratie die we hebben gemaakt en een pakketnaam waarin onze geannoteerde POJO's zich bevinden:

SessionFactory factory = nieuwe SessionFactory (conf, "com.baeldung.graph");

Ten slotte kunnen we een Sessie en begin het te gebruiken:

Sessiesessie = factory.openSession (); Car tesla = nieuwe auto ("tesla", "modelS"); Bedrijf baeldung = nieuw bedrijf ("baeldung"); baeldung.setCar (tesla); session.save (baeldung);

Hier hebben we een sessie gestart, onze POJO's gemaakt en de OGM-sessie gevraagd om ze voort te zetten. Neo4j OGM runtime heeft objecten transparant geconverteerd naar een set van Cypher queries die de juiste knooppunten en randen in de database creëerden.

Als dit proces u bekend voorkomt, is dat omdat het zo is! Dat is precies hoe JPA werkt, het enige verschil is of het object wordt vertaald in rijen die worden bewaard in een RDBMS, of een reeks knooppunten en randen in een grafiekdatabase.

7. Conclusie

Dit artikel behandelde enkele basisprincipes van een grafiekgeoriënteerde database Neo4j.

Zoals altijd is de code in dit artikel allemaal beschikbaar op Github.