Spring Data Neo4j-Tutorial

Dieses Tutorial stellt eine gut erläuterte Beispielanwendung für die Verwendung vor Frühlingsdaten Neo4j. In meinem vorherigen Artikel habe ich die Installation der Neo4j-Datenbank in Ihrem Windows 7-System erläutert. Es sind einfach Knoten und Bögen; Die Knoten stellen die Geschäftsdomäne oder -einheiten dar, während die Bögen als Beziehungen zwischen diesen definierten Einheiten dienen.

Um die vielen Worte zusammenzufassen, die zu diesem Thema geschrieben werden könnten, sehen wir uns die folgenden Schnappschüsse an, die Ihnen die Darstellung von Benutzer- und Adressentitäten zeigen, die in den Augen von jeweils über eine Beziehung mit dem Namen „Adresse“ miteinander verbunden sind Neo4j.

Als Knoten dargestellte Entitäten

  • Innerhalb Neo4j In der Datenbank werden die Entitäten mithilfe des Knotenkonzepts gebildet, wobei jeder Knoten die Eigenschaften und seine dargestellten Typen trägt.

Benutzerknoten

  • Wenn Sie auf den Knoten Nummer 10 klicken, wird ein Dialog angezeigt, der Ihnen die Eigenschaften und den Typ des gedrückten Knotens anzeigt. Wie Sie sehen, ist dieser Knoten vom Typ „Benutzer“ und verfügt über die Eigenschaften „Status“, „Alter“ und „FullName“.

Adressknoten

  • Wenn Sie hingegen auf den Knoten Nummer 11 klicken, sollten Sie die Details einer Adressentität erhalten, und die einzige Eigenschaft, die hier angezeigt wird, ist „addressValue“.
  • Das verbleibende Element, das hervorgehoben werden sollte, ist die Beziehung, die den Benutzer mit seiner Adresse korreliert. Sie heißt Adresse und enthält keine Eigenschaften. Graph Database hat das Konzept der Eigenschaften bereitgestellt, die in der definierten Beziehung enthalten sind.

Das Vorgehen bei der Erklärung ist jetzt viel einfacher als vor dieser grafischen Einführung. Diagrammdaten bestehen also aus Knoten, die durch gerichtete und beschriftete Beziehungen verbunden sind. In Eigenschaftsdiagrammen können sowohl Knoten als auch Beziehungen beliebige Schlüssel/Wert-Paare enthalten.

Übersicht über die Graphdatenbank

  • Wie bereits erwähnt, ist Neo4j die führende Implementierung einer Eigenschaftsdiagrammdatenbank. Es ist überwiegend in Java geschrieben und nutzt ein benutzerdefiniertes Speicherformat und die Funktionen der Java Transaction Architecture (JTA), um XA-Transaktionen bereitzustellen.
  • Die Java API bietet eine objektorientierte Möglichkeit, mit den Knoten und Beziehungen des Graphen zu arbeiten (siehe Beispiel). Durchläufe werden mit einer fließenden API ausgedrückt.
  • Da es sich um eine Graphdatenbank handelt, Neo4j bietet eine Reihe von Graph-Traversal-Algorithmen wie Shortest Path, Dijkstra oder A* sofort einsatzbereit.

Der Neo4j wurde in zwei Hauptkategorien unterteilt:

  • Eingebettet Neo4j
  • Eigenständige Neo4j Server, auf den über das HTTP-Protokoll zugegriffen wird.
  • In diesem Tutorial würde ich beide Konzepte erklären.

    Spring Data Neo4j-Konfigurationen

    • Bevor Sie mit dem Schreiben Ihrer ersten Anwendung auf Neo4j beginnen, müssen Sie den Spring Container einrichten. Die erforderliche Konfiguration hängt vom Typ des Neo4j ab, den Ihre Anwendung verwenden möchte.
    • Für eingebettetes Neo4j müssen Sie ein Store-Verzeichnis bereitstellen, während Sie bei der Verwendung eines eigenständigen Neo4j-Servers eine Verbindung zu diesem Server herstellen müssen, indem Sie die erforderlichen Verbindungsdaten angeben.
    • Sehen wir uns den zweiten an, während der erste nicht mehr weit von dem entfernt ist, was Sie mit dem Standalone Neo4j-Server gemacht haben.

    SpringContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:context="http://www.springframework.org/schema/context"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:neo4j="http://www.springframework.org/schema/data/neo4j"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
     http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context.xsd
     http://www.springframework.org/schema/data/neo4j
     http://www.springframework.org/schema/data/neo4j/spring-neo4j.xsd
     http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx.xsd">
    <context:component-scan base-package="net.javabeat.springdata.beans"></context:component-scan>
     <bean id="graphDatabaseService"  >
     <constructor-arg value="http://localhost:7474/db/data/" />
     </bean>
     <neo4j:config graphDatabaseService="graphDatabaseService" />
     <neo4j:repositories base-package="net.javabeat.springdata.repo" />
    </beans>
    
    • Um neo4j in Ihren Spring-Container zu integrieren, sollte der Namespace von neo4j importiert werden.
    • Die gut bekannten Komponenten-Scan wird zum Scannen der Spring Bean bereitgestellt.
    • Die Bohne von graphDatabaseService sollte für die Verbindung des Standalone-neo4j-Servers verwendet werden.
    • Die verbleibenden neo4j:repositories und neo4j:config sollten zum Scannen der später verwendeten Repositorys bzw. zum Konfigurieren des Datenbankdienstes verwendet werden.

    Maven-Abhängigkeiten für Spring Data Neo4j

    Unten finden Sie eine pom.xml-Datei, die alle erforderlichen Bibliotheken für die Neo4j-Verbindung enthält, entweder eingebettet oder mit einem Server.
    pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>net.javabeat.springdata</groupId>
    	<artifactId>SpringData-JPA</artifactId>
    	<version>1.0</version>
    	<packaging>jar</packaging>
    
    	<name>Spring Data</name>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-compiler-plugin</artifactId>
    				<version>3.1</version>
    				<configuration>
    					<source>1.6</source>
    					<target>1.6</target>
    					<encoding>UTF-8</encoding>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>
    
    	<dependencies>
    		<!-- SLF4J dependency -->
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-log4j12</artifactId>
    			<version>1.6.1</version>
    		</dependency>
    		<!-- Neo4j support for Spring Data -->
    		<dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-neo4j</artifactId>
    			<version>2.3.5.RELEASE</version>
    		</dependency>
    		<!-- Advanced Mapping support for Spring Data Neo4j -->
    		<dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-neo4j-aspects</artifactId>
    			<version>2.3.5.RELEASE</version>
    		</dependency>
    		<!-- Neo4j transaction library -->
    		<dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-neo4j-tx</artifactId>
    			<version>2.3.5.RELEASE</version>
    		</dependency>
                    <!-- Required Libraries for Neo4j-->
    		<dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-neo4j-aspects</artifactId>
    			<version>2.3.5.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-neo4j-rest</artifactId>
    			<version>2.3.5.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-tx</artifactId>
    			<version>4.0.0.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>javax.validation</groupId>
    			<artifactId>validation-api</artifactId>
    			<version>1.0.0.GA</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    			<version>4.0.0.RELEASE</version>
    		</dependency>
    		<!-- Spring Data commons -->
    		<dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-commons</artifactId>
    			<version>1.5.0.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-asm</artifactId>
    			<version>3.1.4.RELEASE</version>
    		</dependency>
    	</dependencies>
    </project>
    

    Domänenklasse

    Grundsätzlich enthält die Domänenklasse zwei Hauptentitäten: den Benutzer und die Adresse. Wobei der Benutzer über eine als @RelatedTo gekennzeichnete Adressreferenz eine direkte Zuordnung zur Adresse hat.

    Benutzer.java

    package net.javabeat.springdata.jpa.data;
    import org.springframework.data.neo4j.annotation.GraphId;
    import org.springframework.data.neo4j.annotation.NodeEntity;
    import org.springframework.data.neo4j.annotation.RelatedTo;
    
    @NodeEntity
    public class User {
    	@GraphId
    	private Long id;
    	private String fullName;
    	private String age;
    	private String status;
    	@RelatedTo
    	private Address address;
    	public String getFullName() {
    		return fullName;
    	}
    	public void setFullName(String fullName) {
    		this.fullName = fullName;
    	}
    	public String getAge() {
    		return age;
    	}
    	public void setAge(String age) {
    		this.age = age;
    	}
    	public String getStatus() {
    		return status;
    	}
    
    	public void setStatus(String status) {
    		this.status = status;
    	}
    	public Long getId() {
    		return id;
    	}
    	public void setId(Long id) {
    		this.id = id;
    	}
    
    	public Address getAddress() {
    		return address;
    	}
    	public void setAddress(Address address) {
    		this.address = address;
    	}
    	public String toString() {
    		return this.id + &quot;,&quot; + this.fullName;
    	}
    }
    

    Adresse.java

    package net.javabeat.springdata.jpa.data;
    import org.springframework.data.neo4j.annotation.GraphId;
    import org.springframework.data.neo4j.annotation.NodeEntity;
    @NodeEntity
    public class Address {
    	@GraphId
    	private Long addressId;
    	private String addressValue;
    	public Long getAddressId() {
    		return addressId;
    	}
    	public void setAddressId(Long addressId) {
    		this.addressId = addressId;
    	}
    	public String getAddressValue() {
    		return addressValue;
    	}
    	public void setAddressValue(String addressValue) {
    		this.addressValue = addressValue;
    	}
    }
    
    • Neo4j bietet viele Arten von Annotationen, die zum Annotieren der benutzerdefinierten Klassen verwendet werden können
    • @GraphId verhält sich wie @Id, wird dieses Mal jedoch zum Definieren der Knotenidentifizierungseigenschaft verwendet, deren Wert vom Container zugewiesen wird
    • @Bezüglich Wird zur Definition der Assoziation (Beziehung) zwischen zwei Entitäten verwendet.

    Definieren des Spring Data Repository

    Spring Data stellt den Spring-Entwicklern eine Abstraktionsschicht für den Umgang mit den verschiedenen Datenbanktypen zur Verfügung. Das Repository, das Sie gerade gesehen hätten, ist dasselbe Repository, das bereits zuvor definiert wurde.

    UserRepository.java

    package net.javabeat.springdata.repo;
    import net.javabeat.springdata.jpa.data.User;
    import org.springframework.data.repository.CrudRepository;
    import org.springframework.stereotype.Repository;
    @Repository
    public interface UserRepository extends CrudRepository<User, String>{}
    
    • An dem zuvor verwendeten definierten Repository wurde nichts geändert
    • @Repository Annotation, die zum Definieren eines Spring Data-Repositorys verwendet wird

    Beispielanwendung für Spring Data Neo4j

    Bei der ausführbaren Anwendung handelt es sich lediglich um eine beispielhafte eigenständige Java-Anwendung, die dem Spring-Entwickler den wichtigsten Code bereitstellt, der zum Definieren und Ausführen verschiedener Vorgänge für die Neo4j-Grafikdatenbank verwendet werden sollte.

    Ausführbare Datei.java

    package net.javabeat.springdata.executable;
    
    import net.javabeat.springdata.beans.RegistrationBean;
    import net.javabeat.springdata.jpa.data.Address;
    import net.javabeat.springdata.jpa.data.User;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Executable {
    	public static RegistrationBean registrationBean;
    	public static ClassPathXmlApplicationContext context;
    
    	static {
    		// Acquire Context
    		context = new ClassPathXmlApplicationContext("SpringContext.xml");
    	}
    
    	public static void main(String () args) throws Exception{
    		// Create User
    		createUser();
    	}
    
    	public static void createUser(){
    		User user = new User();
    		user.setFullName("Susa Richard");
    		user.setStatus("A");
    		user.setAge("30");
    		Address address = new Address();
    		address.setAddressValue("UK/Manchester");
    		user.setAddress(address);
    		RegistrationBean bean = (RegistrationBean)context.getBean("registrationBean");
    		bean.getRepository().save(user);
    	}
    }
    

    Eingebettete Neo4j-Grafikdatenbank

    Unabhängig davon, ob Sie den eigenständigen neo4j-Server installiert haben oder nicht, sollte der eingebettete Neo4j reibungslos laufen. Sie müssen einfach den Spring-Kontext wie folgt ändern:

    SpringContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:neo4j="http://www.springframework.org/schema/data/neo4j"
    	xmlns:tx="http://www.springframework.org/schema/tx"
    	xsi:schemaLocation="
           	http://www.springframework.org/schema/beans
           	http://www.springframework.org/schema/beans/spring-beans.xsd
    		http://www.springframework.org/schema/context
    		http://www.springframework.org/schema/context/spring-context.xsd
    		http://www.springframework.org/schema/data/neo4j
    		http://www.springframework.org/schema/data/neo4j/spring-neo4j.xsd
    		http://www.springframework.org/schema/tx
    		http://www.springframework.org/schema/tx/spring-tx.xsd">
    	<neo4j:config
                 storeDirectory="target/db"
                 base-package="net.javabeat.springdata.jpa.data"/>
    	<context:component-scan
                 base-package="net.javabeat.springdata.beans">
           </context:component-scan>
    	<neo4j:repositories base-package="net.javabeat.springdata.repo" />
    </beans>
    

    Geben Sie in der oben bereitgestellten Konfiguration die Verwendung von Embedded an, indem Sie die konfigurieren neo4j:config um seine Daten in einem Speicherverzeichnis zu speichern, das bereits auf einen echten Ordner in Ihrem Projekt verweist.

    Die Anwendung sollte auch dann funktionieren, wenn Ihr eigenständiger Neo4j-Datenbankserver nicht gestartet wurde, und Ihre gespeicherten Daten sollten sich am angegebenen Speicherort im befinden storeDirecoty.

    Gespeicherte Daten über eingebetteten Server

    Zusammenfassung

    Spring Data bietet eine praktische Möglichkeit, Daten mithilfe des Spring Data Neo4j-Moduls mit der Neo4j-Datenbank zu verbinden und zu speichern. Dieser Artikel soll dem Spring-Entwickler die obligatorischen Informationen für die Verbindung von Neo4j über die eigenständige Neo4j-Datenbank oder mithilfe der eingebetteten Version liefern. Hoffe das hilft!!

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen