En guide til Neo4J med Java

1. Introduksjon

Denne artikkelen handler om Neo4j - en av de mest modne og fullverdige grafdatabasene på markedet i dag. Grafdatabaser nærmer seg oppgaven med datamodellering med det syn at mange ting i livet egner seg til å bli representert som en samling av noder (V) og forbindelser mellom dem kalt kanter (E).

2. Innebygd Neo4j

Den enkleste måten å komme i gang med Neo4j er å bruke den innebygde versjonen der Neo4j kjører i samme JVM som søknaden din.

Først må vi legge til en Maven-avhengighet:

 org.neo4j neo4j 3.4.6 

Du kan sjekke denne lenken for å laste ned den nyeste versjonen.

La oss deretter lage en fabrikk:

GraphDatabaseFactory graphDbFactory = ny GraphDatabaseFactory ();

Til slutt oppretter vi en innebygd database:

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

Nå kan den virkelige handlingen begynne! Først må vi lage noen noder i grafen vår, og for det må vi starte en transaksjon siden Neo4j vil avvise enhver destruktiv operasjon med mindre en transaksjon er startet:

graphDb.beginTx ();

Når vi har en pågående transaksjon, kan vi begynne å legge til noder:

Node bil = graphDb.createNode (Label.label ("Car")); car.setProperty ("make", "tesla"); car.setProperty ("modell", "modell3"); Node eier = graphDb.createNode (Label.label ("Person")); owner.setProperty ("fornavn", "baeldung"); owner.setProperty ("etternavn", "baeldung");

Her la vi til en node Bil med egenskaper gjøre og modell samt node Person med egenskaper fornavn og etternavn

Nå kan vi legge til et forhold:

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

Uttalelsen ovenfor la til en kant som forbinder de to nodene med en Eieren merkelapp. Vi kan bekrefte dette forholdet ved å kjøre et spørsmål skrevet inn Neo4j's kraftig Cypher Språk:

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

Her ber vi om å finne en bileier for enhver bil som er tesla og gi oss fornavnet og etternavnet. Ikke overraskende returnerer dette: {p.firstName = baeldung, p.lastName = baeldung}

3. Cypher Query Language

Neo4j gir et veldig kraftig og ganske intuitivt spørrespråk som støtter hele spekteret av funksjoner man forventer fra en database. La oss undersøke hvordan vi kan oppnå den standarden, opprette, hente, oppdatere og slette oppgaver.

3.1. Opprett node

Opprett nøkkelord kan brukes til å opprette både noder og relasjoner.

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

Her har vi opprettet et selskap med en enkelt eiendom Navn. En node-definisjon er markert med parenteser og dens egenskaper er omsluttet av krøllete bukseseler. I dette tilfellet, selv- er et alias for noden og Selskap er en node-etikett.

3.2. Lag forhold

Det er mulig å opprette en node og et forhold til den noden alt i ett spørsmål:

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

Her har vi opprettet noder baeldung og tesla og etablert et eierforhold mellom dem. Å skape relasjoner til eksisterende noder er selvfølgelig også mulig.

3.3. Hent data

KAMP nøkkelord brukes til å finne data i kombinasjon med KOMME TILBAKE for å kontrollere hvilke datapunkter som returneres. De HVOR klausul kan brukes til å filtrere ut bare de nodene som har egenskapene vi ønsker.

La oss finne ut navnet på selskapet som eier tesla modelX:

Resultatresultat = graphDb.execute ("MATCH (selskap: selskap) - [: eier] -> (bil: bil)" + "HVOR car.make = 'tesla' og car.model = 'modelX'" + "RETUR selskap .Navn");

3.4. Oppdater noder

SETT nøkkelord kan brukes til å oppdatere nodeegenskaper eller etiketter. La oss legge til kjørelengde på teslaen vår:

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 legger vi til en ny eiendom som heter milage, endre etiketter for å være begge deler Bil og Elektro og til slutt sletter vi modell eiendom helt.

3.5. Slett noder

SLETT nøkkelord kan brukes til permanent fjerning av noder eller forhold fra grafen:

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

Her slettet vi et selskap som heter Baeldung.

3.6. Parameterbinding

I eksemplene ovenfor har vi hardkodede parameterverdier som ikke er den beste fremgangsmåten. Heldigvis, Neo4j gir en mulighet for å binde variabler til et spørsmål:

Kartparametere = nye HashMap (); params.put ("navn", "baeldung"); params.put ("make", "tesla"); params.put ("modell", "modellS"); Resultatresultat = graphDb.execute ("CREATE (baeldung: Company {name: $ name})" + "- [: owns] -> (tesla: Car {make: $ make, model: $ model})" + "RETURN baeldung, tesla ", params);

4. Java-driver

Så langt har vi sett på å samhandle med en innebygd Neo4j for eksempel, etter all sannsynlighet for produksjon, vil vi kjøre en frittstående server og koble til den via en gitt driver. Først må vi legge til en annen avhengighet i vår maven pom.xml:

 org.neo4j.driver neo4j-java-driver 1.6.2 

Du kan følge denne lenken for å se etter den nyeste versjonen av denne driveren.

Nå kan vi opprette en forbindelse:

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

Opprett deretter en økt:

Sessionsøkt = driver.session ();

Til slutt kan vi kjøre noen spørsmål:

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

Når vi er ferdige med alt arbeidet vårt, må vi lukke både økten og sjåføren:

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

5. JDBC-driver

Det er også mulig å samhandle med Neo4j via en JDBC-driver. Nok en avhengighet for vår pom.xml:

 org.neo4j neo4j-jdbc-driver 3.4.0 

Du kan følge denne lenken for å laste ned den nyeste versjonen av denne driveren.

La oss deretter opprette en JDBC-forbindelse:

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

Her lure er en vanlig JDBC-forbindelse som kan brukes til å opprette og utføre uttalelser eller utarbeidede uttalelser:

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

6. Kartlegging av objekt-graf

Object-Graph-Mapping eller OGM er en teknikk som gjør det mulig for oss å bruke domene våre POJOer som enheter i Neo4j database. La oss undersøke hvordan dette fungerer. Det første trinnet, som vanligvis, legger vi til nye avhengigheter til vår pom.xml:

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

Du kan sjekke OGM Core Link og OGM Embedded Driver Link for å se etter de nyeste versjonene av disse bibliotekene.

For det andre kommenterer vi våre POJO-er med OGM-merknader:

@NodeEntity offentlig klasse Company {private Long id; privat strengnavn; @Relationship (type = "eier") privat bilbil; } @NodeEntity offentlig klasse bil {privat Lang id; privat streng merkevare; @Relationship (direction = "INCOMING") privat selskapsselskap; }

@NodeEntity informerer Neo4j at dette objektet må representeres av en node i den resulterende grafen. @Forhold kommuniserer behovet for å opprette et forhold med en node som representerer den relaterte typen. I dette tilfellet, a selskap eier en bil.

Vær oppmerksom på at Neo4j krever at hver enhet har en primærnøkkel, med et felt som heter id blir plukket opp som standard. Et alternativt navngitt felt kan brukes ved å kommentere det med @Id @GeneratedValue.

Deretter må vi lage en konfigurasjon som skal brukes til å starte opp Neo4j’OGM. For enkelhets skyld, la oss bruke en innebygd bare minne i databasen:

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

Etter det initialiserer vi SessionFactory med konfigurasjonen vi opprettet og et pakkenavn der våre merkede POJO-er ligger:

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

Endelig kan vi lage en Økt og begynn å bruke den:

Sessionsøkt = fabrikk.openSession (); Car tesla = ny bil ("tesla", "modelS"); Firma baeldung = nytt selskap ("baeldung"); baeldung.setCar (tesla); session.save (baeldung);

Her startet vi en økt, opprettet våre POJOer og ba OGM-økten om å fortsette dem. Neo4j OGM-kjøretid konverterte objekter transparent til et sett med Cypher spørsmål som opprettet passende noder og kanter i databasen.

Hvis denne prosessen virker kjent, er det fordi den er det! Det er nettopp slik JPA fungerer, den eneste forskjellen er om objektet blir oversatt til rader som er vedvarende til en RDBMS, eller om en serie noder og kanter fortsatte til en grafdatabase.

7. Konklusjon

Denne artikkelen så på noen grunnleggende om en graforientert database Neo4j.

Som alltid er koden i denne oppskriften tilgjengelig på Github.