En guide til Neo4J med Java

1. Introduktion

Denne artikel handler om Neo4j - en af ​​de mest modne og komplette grafdatabaser på markedet i dag. Grafdatabaser nærmer sig opgaven med datamodellering med den opfattelse, at mange ting i livet egner sig til at blive repræsenteret som en samling af noder (V) og forbindelser mellem dem kaldes kanter (E).

2. Indlejret Neo4j

Den nemmeste måde at komme i gang med Neo4j er at bruge den integrerede version, hvor Neo4j kører i samme JVM som din applikation.

Først skal vi tilføje en Maven-afhængighed:

 org.neo4j neo4j 3.4.6 

Du kan tjekke dette link for at downloade den nyeste version.

Lad os derefter oprette en fabrik:

GraphDatabaseFactory graphDbFactory = ny GraphDatabaseFactory ();

Endelig opretter vi en integreret database:

GraphDatabaseService graphDb = graphDbFactory.newEmbeddedDatabase (ny fil ("data / biler"));

Nu kan den virkelige handling begynde! Først skal vi oprette nogle noder i vores graf, og til det er vi nødt til at starte en transaktion siden Neo4j afviser enhver destruktiv handling, medmindre en transaktion er startet:

graphDb.beginTx ();

Når vi har en igangværende transaktion, kan vi begynde at tilføje noder:

Node bil = graphDb.createNode (Label.label ("Car")); car.setProperty ("make", "tesla"); car.setProperty ("model", "model3"); Node ejer = graphDb.createNode (Label.label ("Person")); owner.setProperty ("fornavn", "baeldung"); owner.setProperty ("efternavn", "baeldung");

Her tilføjede vi en knude Bil med egenskaber lave og model samt knude Person med egenskaber fornavn og efternavn

Nu kan vi tilføje et forhold:

owner.createRelationshipTo (bil, RelationshipType.withName ("ejer"));

Erklæringen ovenfor tilføjede en kant, der forbinder de to knudepunkter med en ejer etiket. Vi kan bekræfte dette forhold ved at køre en forespørgsel, der er skrevet ind Neo4j's magtfulde Cypher Sprog:

Resultat resultat = graphDb.execute ("MATCH (c: Car) <- [ejer] - (p: Person)" + "WHERE c.make = 'tesla'" + "RETURNER p.firstName, p.lastName");

Her beder vi om at finde en bilejer til enhver bil, hvis mærke er tesla og give os hans / hendes fornavn og efternavn tilbage. Ikke overraskende returnerer dette: {p.firstName = baeldung, p.lastName = baeldung}

3. Cypher Query Language

Neo4j giver et meget kraftigt og ret intuitivt forespørgselssprog, der understøtter hele spektret af funktioner, man kan forvente af en database. Lad os undersøge, hvordan vi kan udføre denne standard, oprette, hente, opdatere og slette opgaver.

3.1. Opret node

Opret nøgleord kan bruges til at oprette både noder og relationer.

CREATE (selv: Virksomhed {navn: "Baeldung"}) RETUR selv

Her har vi oprettet et firma med en enkelt ejendom navn. En node-definition er markeret med parenteser, og dens egenskaber er lukket i krøllede seler. I dette tilfælde, selv er et alias for noden og Selskab er en node-etiket.

3.2. Opret forhold

Det er muligt at oprette en node og en relation til den node i en enkelt forespørgsel:

Resultat resultat = graphDb.execute ("CREATE (baeldung: Company {name: \" Baeldung \ "})" + "- [: ejer] -> (tesla: Car {make: 'tesla', model: 'modelX'} ) "+" RETUR baeldung, tesla ");

Her har vi oprettet noder baeldung og tesla og etablerede et ejerskabsforhold mellem dem. Oprettelse af relationer til allerede eksisterende noder er selvfølgelig også muligt.

3.3. Hent data

MATCH nøgleord bruges til at finde data i kombination med VEND TILBAGE for at kontrollere, hvilke datapunkter der returneres. Det HVOR klausul kan kun bruges til at filtrere de noder, der har de egenskaber, vi ønsker.

Lad os finde ud af navnet på det firma, der ejer tesla modelX:

Resultat resultat = graphDb.execute ("MATCH (firma: firma) - [: ejer] -> (bil: bil)" + "HVOR car.make = 'tesla' og car.model = 'modelX'" + "RETURNER firma .navn");

3.4. Opdater noder

SÆT nøgleord kan bruges til opdatering af nodeegenskaber eller etiketter. Lad os tilføje kilometertal til vores tesla:

Resultat resultat = graphDb.execute ("MATCH (bil: bil)" + "HVOR car.make = 'tesla'" + "SET car.milage = 120" + "SET car: Car: Electro" + "SET car.model = NULL "+" RETUR bil ");

Her tilføjer vi en ny egenskab kaldet milage, rediger etiketter, så de er begge Bil og Elektro og til sidst sletter vi model ejendom helt.

3.5. Slet noder

SLET nøgleord kan bruges til permanent fjernelse af noder eller relationer fra grafen:

graphDb.execute ("MATCH (firma: Company)" + "WHERE company.name = 'Baeldung'" + "SLET firma");

Her slettede vi et firma ved navn Baeldung.

3.6. Parameterbinding

I ovenstående eksempler har vi hårdkodede parameterværdier, hvilket ikke er den bedste praksis. Heldigvis Neo4j giver mulighed for at binde variabler til en forespørgsel:

Kortparametre = nyt HashMap (); params.put ("navn", "baeldung"); params.put ("make", "tesla"); params.put ("model", "modelS"); Resultatresultat = graphDb.execute ("CREATE (baeldung: Company {name: $ name})" + "- [: ejer] -> (tesla: Car {make: $ make, model: $ model})" + "RETURN baeldung, tesla ", params);

4. Java-driver

Indtil videre har vi set på at interagere med en integreret Neo4j For eksempel vil vi med stor sandsynlighed for produktion køre en enkeltstående server og oprette forbindelse til den via en leveret driver. Først skal vi tilføje en anden afhængighed i vores maven pom.xml:

 org.neo4j.driver neo4j-java-driver 1.6.2 

Du kan følge dette link for at kontrollere den nyeste version af denne driver.

Nu kan vi oprette en forbindelse:

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

Opret derefter en session:

Session session = driver.session ();

Endelig kan vi køre nogle forespørgsler:

session.run ("CREATE (baeldung: Company {name: \" Baeldung \ "})" + "- [: ejer] -> (tesla: Car {make: 'tesla', model: 'modelX'})" + "TILBAGE baeldung, tesla");

Når vi er færdige med alt vores arbejde, skal vi lukke både sessionen og chaufføren:

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

5. JDBC-driver

Det er også muligt at interagere med Neo4j via en JDBC-driver. Endnu en afhængighed for vores pom.xml:

 org.neo4j neo4j-jdbc-driver 3.4.0 

Du kan følge dette link for at downloade den nyeste version af denne driver.

Lad os derefter oprette en JDBC-forbindelse:

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

Her con er en regelmæssig JDBC-forbindelse, der kan bruges til at oprette og udføre udsagn eller udarbejdede udsagn:

prøv (Statement stmt = con. stmt.execute ("CREATE (baeldung: Company {name: \" Baeldung \ "})" + "- [: ejer] -> (tesla: Car {make: 'tesla', model: 'modelX'}) "+" RETURN baeldung, tesla ") ResultSet rs = stmt.executeQuery (" MATCH (firma: Company) - [: ejer] -> (bil: Car) "+" WHERE car.make = 'tesla 'and car.model =' modelX '"+" RETURN company.name "); while (rs.next ()) {rs.getString (" company.name ");}}

6. Objekt-graf-kortlægning

Object-Graph-Mapping eller OGM er en teknik, der gør det muligt for os at bruge vores domæne POJO'er som enheder i Neo4j database. Lad os undersøge, hvordan dette fungerer. Det første trin, som normalt, tilføjer vi nye afhængigheder til vores pom.xml:

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

Du kan tjekke OGM Core Link og OGM Embedded Driver Link for at se efter de nyeste versioner af disse biblioteker.

For det andet kommenterer vi vores POJO'er med OGM-kommentarer:

@NodeEntity public class Company {privat Lang id; privat strengnavn; @Relationship (type = "ejer") privat bilbil; } @NodeEntity offentlig klasse bil {privat Lang id; private String mærke; @Relationship (direction = "INCOMING") privat virksomhedsselskab; }

@NodeEntity informerer Neo4j at dette objekt skal repræsenteres af en node i den resulterende graf. @Forhold kommunikerer behovet for at skabe et forhold med en node, der repræsenterer den relaterede type. I dette tilfælde a Selskab ejer en bil.

Bemærk, at Neo4j kræver, at hver enhed har en primær nøgle med et felt med navnet id bliver samlet op som standard. Et alternativt navngivet felt kunne bruges ved at kommentere det med @Id @GeneratedValue.

Derefter er vi nødt til at oprette en konfiguration, der vil blive brugt til bootstrap Neo4j'S OGM. For nemheds skyld skal vi bruge en indbygget kun hukommelsesdatabase:

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

Derefter initialiseres vi SessionFactory med den konfiguration, vi oprettede, og et pakkenavn, hvor vores kommenterede POJO er:

SessionFactory fabrik = ny SessionFactory (conf, "com.baeldung.graph");

Endelig kan vi oprette en Session og begynd at bruge det:

Sessionssession = fabrik.openSession (); Car tesla = ny bil ("tesla", "modelS"); Firma baeldung = nyt selskab ("baeldung"); baeldung.setCar (tesla); session.save (baeldung);

Her startede vi en session, oprettede vores POJO'er og bad OGM-sessionen om at fortsætte dem. Neo4j OGM-runtime konverterede transparente objekter til et sæt Cypher forespørgsler, der skabte passende noder og kanter i databasen.

Hvis denne proces virker velkendt, er det fordi den er! Det er netop sådan, hvordan JPA fungerer, den eneste forskel er, om objekt bliver oversat til rækker, der er vedvarende til en RDBMS, eller om en række noder og kanter fortsatte til en grafdatabase.

7. Konklusion

Denne artikel kiggede på nogle grundlæggende i en graforienteret database Neo4j.

Som altid er koden i denne opskrivning tilgængelig på Github.