Inleiding tot Spring Data Neo4j

1. Overzicht

Dit artikel is een inleiding tot Spring Data Neo4j, de populaire grafiekdatabase.

Spring Data Neo4j maakt ontwikkeling op basis van POJO mogelijk voor de Neo4j Graph Database en maakt gebruik van bekende Spring-concepten zoals sjabloonklassen voor kern-API-gebruik en biedt een op annotatie gebaseerd programmeermodel.

Ook weten veel ontwikkelaars niet echt of Neo4j daadwerkelijk een goede match zal zijn voor hun specifieke behoeften; hier is een solide overzicht van Stackoverflow waarin wordt besproken waarom Neo4j moet worden gebruikt en wat de voor- en nadelen zijn.

2. Maven afhankelijkheden

Laten we beginnen met het declareren van de Spring Data Neo4j-afhankelijkheden in het pom.xml. De onderstaande Spring-modules zijn ook vereist voor Spring Data Neo4j:

 org.springframework.data spring-data-neo4j 5.0.1.RELEASE org.neo4j neo4j-ogm-test 3.1.2 test 

Deze afhankelijkheden omvatten ook de vereiste modules voor testen.

Merk op dat de laatste afhankelijkheid wordt ingedeeld als ‘test '. Maar houd er ook rekening mee dat in een echte applicatie-ontwikkeling de kans groter is dat een volledige Neo4J-server draait.

Als we de embedded server willen gebruiken, moeten we ook de afhankelijkheid toevoegen:

 org.neo4j neo4j-ogm-embedded-stuurprogramma 3.1.2 

De afhankelijkheden spring-data-neo4j, neo4j-ogm-test en neo4j-ogm-embedded-driver zijn beschikbaar op Maven Central.

3. Neo4Jj-configuratie

De Neo4j-configuratie is erg ongecompliceerd en definieert de verbindingsinstelling voor de applicatie om verbinding te maken met de server. Net als bij de meeste andere veergegevensmodules, is dit een veerconfiguratie die kan worden gedefinieerd als XML- of Java-configuratie.

In deze zelfstudie gebruiken we alleen op Java gebaseerde configuratie:

openbare statische uiteindelijke string-URL = System.getenv ("NEO4J_URL")! = null? System.getenv ("NEO4J_URL"): "// neo4j: [e-mail beveiligd]: 7474"; @Bean openbare org.neo4j.ogm.config.Configuration getConfiguration () {retourneer nieuwe Builder (). Uri (URL) .build (); } @Bean openbare SessionFactory getSessionFactory () {retourneer nieuwe SessionFactory (getConfiguration (), "com.baeldung.spring.data.neo4j.domain"); } @Bean openbare Neo4jTransactionManager transactionManager () {retourneer nieuwe Neo4jTransactionManager (getSessionFactory ()); }

Zoals hierboven vermeld, is de configuratie eenvoudig en bevat deze slechts twee instellingen. Eerst de SessionFactory is verwijzend naar de modellen die we hebben gemaakt om de data-objecten weer te geven. Vervolgens de verbindingseigenschappen met de servereindpunten en toegangsreferenties.

Neo4j zal de driver class afleiden op basis van het protocol van de URI, in ons geval "http".

Houd er rekening mee dat in dit voorbeeld de verbindinggerelateerde eigenschappen rechtstreeks op de server worden geconfigureerd; in een productietoepassing moeten deze echter correct worden geëxternaliseerd en deel uitmaken van de standaardconfiguratie van het project.

4. Neo4j-opslagplaatsen

In lijn met het Spring Data-framework ondersteunt Neo4j het abstractiegedrag van de Spring Data-repository. Dat betekent dat toegang tot het onderliggende persistente mechanisme wordt geabstraheerd in het ingebouwde Neo4jRepository waar een project het direct kan uitbreiden en de geleverde operaties out-of-the-box kan gebruiken.

De repositories zijn uitbreidbaar met geannoteerde, benoemde of afgeleide zoekmethoden. Ondersteuning voor Spring Data Neo4j Repositories is ook gebaseerd op Neo4jTemplate, dus de onderliggende functionaliteit is identiek.

4.1. Het creëren van het MovieRepository & PersonRepository

We gebruiken twee opslagplaatsen in deze zelfstudie voor gegevenspersistentie:

@Repository openbare interface MovieRepository breidt Neo4jRepository {Movie findByTitle (@Param ("title") String-titel) uit; @Query ("MATCH (m: Movie) WHERE m.title = ~ ('(? I). *' + {Title} + '. *') RETURN m") Verzameling findByTitleContaining (@Param ("title") String titel); @Query ("MATCH (m: Movie) <- [: ACTED_IN] - (a: Person) RETURN m.title als film, verzamel (a.name) als cast LIMIT {limit}") Lijst graph (@Param ("limit") int limit); } 

Zoals je kunt, bevat de repository enkele aangepaste bewerkingen evenals de standaardbewerkingen die zijn geërfd van de basisklasse.

Vervolgens hebben we de eenvoudiger PersonRepository, die alleen de standaardbewerkingen heeft:

@Repository openbare interface PersonRepository breidt Neo4jRepository uit {//}

Dat is je misschien al opgevallen PersonRepository is gewoon de standaard Spring Data-interface. Dit komt omdat, in dit eenvoudige voorbeeld, het bijna voldoende is om de ingebouwde bewerkingen in feite te gebruiken, aangezien onze bewerkingsset gerelateerd is aan de Film entiteit. U kunt hier echter altijd aangepaste bewerkingen toevoegen die enkele / meer ingebouwde bewerkingen kunnen bevatten.

4.2. Neo4j configurerenOpslagplaatsen

Als volgende stap moeten we Spring op de hoogte stellen van de relevante repository door het aan te geven in het Neo4jConfiguration klasse gemaakt in sectie 3:

@Configuration @ComponentScan ("com.baeldung.spring.data.neo4j") @ EnableNeo4jRepositories (basePackages = "com.baeldung.spring.data.neo4j.repository") openbare klasse MovieDatabaseNeo4jConfiguration {//}

5. Het volledige gegevensmodel

We begonnen al naar het datamodel te kijken, dus laten we het nu allemaal op een rijtje zetten - het volledige Film, rol en Persoon. De Persoon entiteit verwijst naar het Film entiteit via de Rol relatie.

@NodeEntity film van openbare klasse {@Id @GeneratedValue Lange id; private String-titel; private int vrijgegeven; private String slogan; @Relationship (type = "ACTED_IN", direction = Relationship.INCOMING) privélijstrollen; // standaard constructor, getters en setters}

Merk op hoe we hebben geannoteerd Film met @NodeEntity om aan te geven dat deze klasse direct is toegewezen aan een knooppunt in Neo4j.

@JsonIdentityInfo (generator = JSOGGenerator.class) @NodeEntity openbare klasse Persoon {@Id @GeneratedValue Lange id; private String naam; privé int geboren; @Relationship (type = "ACTED_IN") privélijst films; // standaard constructor, getters en setters} @JsonIdentityInfo (generator = JSOGGenerator.class) @RelationshipEntity (type = "ACTED_IN") openbare klasse Rol {@Id @GeneratedValue Lange id; privécollectierollen; @StartNode privé Persoon persoon; @EndNode privéfilmfilm; // standaard constructor, getters en setters}

Natuurlijk zijn deze laatste paar klassen op dezelfde manier geannoteerd en de -films referentie is linken Persoon naar Film class door de "ACTED_IN" -relatie.

6. Gegevenstoegang met MovieRepository

6.1. Een nieuw filmobject opslaan

Laten we wat gegevens opslaan - eerst een nieuwe film, dan een persoon en natuurlijk een rol - inclusief alle relatiegegevens die we hebben:

Movie italianJob = nieuwe film (); italianJob.setTitle ("De Italiaanse baan"); italianJob.setReleased (1999); movieRepository.save (italianJob); Persoonsteken = nieuwe persoon (); mark.setName ("Mark Wahlberg"); personRepository.save (markeren); Rol charlie = nieuwe rol (); charlie.setMovie (italianJob); charlie.setPerson (mark); Verzameling roleNames = nieuwe HashSet (); roleNames.add ("Charlie Croker"); charlie.setRoles (roleNames); Lijst met rollen = nieuwe ArrayList (); rollen.add (Charlie); italianJob.setRoles (rollen); movieRepository.save (italianJob);

6.2. Een bestaand filmobject ophalen op titel

Laten we nu de ingevoegde film verifiëren door deze op te halen met de gedefinieerde titel, wat een aangepaste bewerking is:

Filmresultaat = movieRepository.findByTitle (titel);

6.3. Een bestaand filmobject ophalen op basis van een deel van de titel

Het is mogelijk om te zoeken naar een bestaande film met een deel van de titel:

Verzamelingsresultaat = movieRepository.findByTitleContaining ("Italiaans");

6.4. Alle films ophalen

Alle films kunnen één keer worden opgehaald en kunnen worden gecontroleerd op de juiste telling:

Verzamelingsresultaat = (Verzameling) movieRepository.findAll ();

Er zijn echter een aantal zoekmethoden met standaardgedrag dat handig is voor douanevereisten en die hier niet allemaal worden beschreven.

6.5. Tel de bestaande filmobjecten

Nadat we verschillende filmobjecten hebben ingevoegd, kunnen we een spannend aantal films krijgen:

lange movieCount = movieRepository.count ();

6.6. Een bestaande film verwijderen

movieRepository.delete (movieRepository.findByTitle ("De Italiaanse baan"));

Nadat we de ingevoegde film hebben verwijderd, kunnen we naar het filmobject zoeken en controleren of het resultaat nul is:

assertNull (movieRepository.findByTitle ("The Italian Job"));

6.7. Verwijder alle ingevoegde gegevens

Het is mogelijk om alle elementen in de database te verwijderen waardoor de database leeg wordt:

movieRepository.deleteAll ();

Het resultaat van deze bewerking verwijdert snel alle gegevens uit een tabel.

7. Conclusie

In deze tutorial hebben we de basisprincipes van Spring Data Neo4j doorgenomen aan de hand van een heel eenvoudig voorbeeld.

Neo4j is echter in staat om te voorzien in zeer geavanceerde en complexe applicaties met een enorme reeks relaties en netwerken. En Spring Data Neo4j biedt ook geavanceerde functies om geannoteerde entiteitsklassen toe te wijzen aan de Neo4j Graph Database.

De implementatie van de bovenstaande codefragmenten en voorbeelden is te vinden in het GitHub-project - dit is een op Maven gebaseerd project, dus het moet gemakkelijk te importeren en uit te voeren zijn zoals het is.