Spring Data Neo4j 3 REST Exporter (Java-Anwendung)

Dieses Tutorial führt Sie durch den Prozess der Erstellung einer Anwendung, die über ein Hypermedia-basiertes RESTful-Frontend auf graphbasierte Daten zugreift. Sie erstellen eine Spring-Anwendung, mit der Sie mithilfe von Spring Data REST Mitarbeiter- und Adressobjekte erstellen und abrufen können, die in einer Neo4j NoSQL-Datenbank (Neo4j Server) gespeichert sind. Sie verwenden das nicht eingebettete Neo4j, um den Exporter zu erreichen, und Tomcat 8, um die Spring Boot-Anwendung auszuführen.

Lesen Sie auch:

  • Spring Roo + Spring Data JPA-Repositories + Eclipse-Integration
  • Spring Data JPA + Querydsl
  • Spring Data + MongoDB

1. Installieren Sie das Eclipse Tomcat 8-Plugin

Sie müssen Tomcat 8 und JDK 1.7 installieren und verwenden, um die in diesem Tutorial verwendete Beispielanwendung auszuführen. Eclipse IDE stellt Ihnen das Tomcat 8-Plugin zur Verfügung, das Sie hier herunterladen können Hier. Tomcat 8-Unterstützung wird Eclipse nicht hinzugefügt zum Zeitpunkt des Schreibens dieses Tutorials. Laden Sie also Eclipse über den angegebenen Link herunter und verwenden Sie es.

Nach dem Herunterladen des Plugins müssen Sie die folgenden Schritte ausführen, um die Plugin-Installation abzuschließen:

  • Kopieren Sie die heruntergeladene Datei neben Ihren Root-Eclipse-Ordner. Wenn Sie Eclipse unter D:\eclipse installiert haben, sollte sich die ZIP-Datei neben Eclipse und nicht darin befinden.
  • Extrahieren Sie die ZIP-Datei mit hier entpacken.
  • Starten Sie die Eclipse-Idee neu.
  • Installieren Sie Tomcat 8 von Hier.
  • Extrahieren Sie Ihren heruntergeladenen Tomcat in Ihren bevorzugten Ordner.
  • Fügen Sie mit dem Assistenten für neue Server einen neuen Server hinzu und stellen Sie sicher, dass Sie Tomcat 8 ausgewählt haben.
  • Während Sie Tomcat 8 über den Assistenten installieren, werden Sie aufgefordert, ein JDK .17 zum Abschließen der Installation zu verwenden.

Tomcat 8 wird in diesem Tutorial nicht gezeigt, wird aber im nächsten Teil wichtig sein, wenn eine reine Spring Boot-Java-Anwendung in WAR konvertiert wird. Die Mindestvoraussetzung für die Ausführung von Tomcat 8 ist jedoch Java 7.

2. Java Beans

Es sind die Beans (Adresse und Mitarbeiter), die für den REST-Exportprozess verwendet werden, durch den alle persistenten Entitäten in der Neo4j-Datenbank über HTTP verfügbar gemacht werden.

Adresse.java

package net.javabeat.springdata.data;

import org.springframework.data.neo4j.annotation.GraphId;
import org.springframework.data.neo4j.annotation.NodeEntity;

@NodeEntity
public class Address{

	@GraphId
	private Long id;

	private String addressCountry;

	private String addressCity;

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getAddressCountry() {
		return addressCountry;
	}

	public void setAddressCountry(String addressCountry) {
		this.addressCountry = addressCountry;
	}

	public String getAddressCity() {
		return addressCity;
	}

	public void setAddressCity(String addressCity) {
		this.addressCity = addressCity;
	}
}

Employee.java

package net.javabeat.springdata.data;

import org.springframework.data.neo4j.annotation.Fetch;
import org.springframework.data.neo4j.annotation.GraphId;
import org.springframework.data.neo4j.annotation.NodeEntity;
import org.springframework.data.neo4j.annotation.RelatedTo;

@NodeEntity
public class Employee{
	@GraphId
	private Long id;

	private String employeeName;

	@Fetch
	@RelatedTo(type="Address")
	private Address address = new Address();

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getEmployeeName() {
		return employeeName;
	}

	public void setEmployeeName(String employeeName) {
		this.employeeName = employeeName;
	}

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}
}

3. Spring-Datenrepositorys

Erstellen Sie die Spring-Data-Repositorys für jeden Persistenztyp und überlassen Sie die eigentliche Implementierung der Spring-Data-Laufzeit.

EmployeeRepositories.java

package net.javabeat.springdata.repo;

import net.javabeat.springdata.data.Employee;

import org.springframework.data.neo4j.repository.GraphRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;

@RepositoryRestResource(collectionResourceRel = "employee", path = "employee")
public interface EmployeeRepository extends GraphRepository<Employee>{}

AddressRepositories.java

package net.javabeat.springdata.repo;

import net.javabeat.springdata.data.Address;

import org.springframework.data.neo4j.repository.GraphRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;

@RepositoryRestResource(collectionResourceRel = "address", path = "address")
public interface AddressRepository extends GraphRepository<Address>{}

4. Ausführbare Anwendung

Es ist die Hauptanwendung, die das verwendet Spring Boot-Konzept um die Spring-Anwendung auszuführen. Es enthält die gesamte Konfiguration, die zum Einrichten des Kontexts erforderlich ist, sowie alle erforderlichen Informationen wie z GraphDatabaseService, Basispaket und das Repositories-Paket. Die ausführbare Hauptklasse wurde mit der normalen Ausführung für jede Java-Klasse ausgeführt, die eine Hauptmethode enthält. Spring Boot verwendet den eingebetteten Tomcat

Ausführbare Datei.java

package net.javabeat.springdata.executable;

import org.neo4j.graphdb.GraphDatabaseService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.neo4j.config.EnableNeo4jRepositories;
import org.springframework.data.neo4j.config.Neo4jConfiguration;
import org.springframework.data.neo4j.rest.SpringRestGraphDatabase;
import org.springframework.data.rest.webmvc.config.RepositoryRestMvcConfiguration;

@Configuration
@EnableNeo4jRepositories("net.javabeat.springdata.repo")
@Import(RepositoryRestMvcConfiguration.class)
@EnableAutoConfiguration
public class Executable extends Neo4jConfiguration {

	public Executable() {
	}

	@Bean(destroyMethod = "shutdown")
	public GraphDatabaseService graphDatabaseService() {
		SpringRestGraphDatabase service = new SpringRestGraphDatabase("http://localhost:7474/db/data/");
		this.setBasePackage("net.javabeat");
		return service;
	}

	public static void main(String() args) {
		SpringApplication.run(Executable.class, args);
	}
}

5. Maven-Abhängigkeiten

Diese pom.xml-Maven-Datei definiert alle in diesem Tutorial verwendeten Abhängigkeiten.

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/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>next.javabeat.jsf</groupId>
	<artifactId>JavaBeat-Neo4j-REST</artifactId>
	<packaging>jar</packaging>
	<version>1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.0.2.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-neo4j</artifactId>
            <version>3.0.1.RELEASE</version>
        </dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-neo4j-rest</artifactId>
			<version>3.0.1.RELEASE</version>
		</dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-rest-webmvc</artifactId>
        </dependency>
    </dependencies>

    <properties>
        <!-- use UTF-8 for everything -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <start-class>net.javabeat.springdata.executable.Executable</start-class>
    </properties>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/libs-snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/libs-snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

</project>

6. Neo4j REST-Demo

Es handelt sich lediglich um eine Demonstration der Form der JSON-Antwort, sobald eine HTTP-Anfrage vom Browser gesendet wurde. Zum Offenlegen der JSON-Antwort haben wir das Google HTTP DEV-Plugin verwendet.

Neo4j REST

Neo4j-REST-ADRESSE

Neo4j-REST-EMPLOYEE

Laden Sie den Quellcode herunter

Symbol

Spring Data Neo4j Rest Exporter Beispielanwendung

1 Datei(en) 56,44 KB Download

Kommentar verfassen

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

Nach oben scrollen