Spring Data Neo4j 3 REST Exporter – Konvertieren der Spring Boot JAR-Anwendung in WAR

Dieses Tutorial ist die Fortsetzung des vorherigen Tutorials zum Erstellen der eigenständigen Anwendung mit Spring Boot. Dieser Leitfaden führt Sie durch den Prozess der Konvertierung einer ausführbaren JAR-Anwendung, die mit Spring Boot erstellt wurde, in eine WAR-Datei, die Sie in jedem Standard-Servlet-Container ausführen können. Sie nehmen eine einfache Spring MVC-Webanwendung und erstellen mit Spring Boot eine WAR-Datei.

Lesen Sie auch:

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

1. Java Beans

Es sind die Entitäten, die zur Darstellung der persistenten Knoten verwendet 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;
	}
}

2. Spring Data Neo4j-Repositorys

Es sind die Repositorys, die für den Betrieb der Diagrammdatenbank durch verschiedene Vorgänge verwendet werden.

EmployeeRepository.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>{

}

AddressRepository.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>{

}

3. Federregler

Mit dem Spring MVC-Controller können Sie schnell Controller für Ihre Website erstellen. Der Controller ist sehr einfach, da die Annotation @Controller dem Container mitteilt, dass diese Klasse Webanwendungspfade enthält. Die Annotation @RequestMapping stellt sicher, dass die HTTP-Anfrage an /query der Abfragemethode und /execute der Ausführungsmethode zugeordnet wird.

DataController.java

package net.javabeat.springdata.controller;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class DataController {

    @RequestMapping(value="/execute", method=RequestMethod.GET,params="query")
    public String execute(@RequestParam ("query")String query,HttpServletRequest request, HttpServletResponse response) {
    	try {
    		response.getWriter().write("<h1>JavaBeat Tutorials</h1>");
    		response.getWriter().write("<h2>Neo4j + REST + Spring Boot WAR Application</h2>");
			URL url = new URL("http", "localhost",8080,"/JavaBeat-Neo4j-REST/"+request.getParameter("query"));
			HttpURLConnection c = (HttpURLConnection)url.openConnection();
		        c.setRequestProperty("Content-length", "0");
		        c.setUseCaches(false);
		        c.setAllowUserInteraction(false);
		        c.connect();
		        int status = c.getResponseCode();

		        switch (status) {
		            case 200:
		            case 201:
		                BufferedReader br = new BufferedReader(new InputStreamReader(c.getInputStream()));
		                String line;
		                while ((line = br.readLine()) != null) {
		                    response.getWriter().append(line+"\n");
		                }
		                br.close();
		                response.flushBuffer();
		                return "resultTemplate";
		        }

		} catch (MalformedURLException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
        return "resultTemplate";
    }

    @RequestMapping(value="/query", method=RequestMethod.GET)
    public String query(HttpServletRequest request, HttpServletResponse response) {
		try {
			response.getWriter().write("<h1>JavaBeat Tutorials</h1>");
			response.getWriter().write("<h2>Neo4j + REST + Spring Boot WAR Application</h2>");
		} catch (IOException e) {
			e.printStackTrace();
		}
    	return "queryTemplate";
    }
}

4. Thymeleaf-Vorlagen

Spring Boot automatisch hinzugefügt Thymianblatt Beans in den Anwendungskontext, um eine Anfrage für die zu konvertieren Thymianblatt Vorlage befindet sich unter

  • src/main/resource/templates/queryTemplate.html, der für die Erfassung der Anfrage des Benutzers verantwortlich ist.
  • src/main/resource/templates/resultTemplate.html, die für die Anzeige des Ergebnisses der Abfragen zuständig ist.

Diese Vorlagen enthalten sehr einfache HTML-Elemente und keine tatsächlichen Thymianblatt Code.

queryTemplate.html

<html>
<body>
	<form id="form" action="execute" method="GET">
		<p>Enter Query You Want To Be Executed Right Below:</p>
		<br />
		<input id="query" name="query" type="text" value=""/>
		<input type="submit" value="Query !"/>
	</form>
</body>
</html>

resultTemplate.html

<!-- It's filled by using the controller response.getWriter() -->

4. Ausführbare Anwendung

Im ersten Teil dieses Tutorials haben Sie die Anwendung bereits in eine ausführbare JAR-Datei umgewandelt. Sie verpacken alles in einer einzigen, ausführbaren JAR-Datei, die von der main()-Methode gesteuert wird. Nebenbei nutzen Sie die Unterstützung von Spring für die Einbettung des Tomcat-Servlet-Containers als HTTP-Laufzeit, anstatt ihn auf einer externen Instanz bereitzustellen. In diesem Teil des Tutorials erfahren Sie, wie Sie eine WAR-Datei erstellen, um sie in einem Standardcontainer auszuführen.

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.ComponentScan;
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;
@ComponentScan("net.javabeat")
@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. Führen Sie den Dienst aus

Wenn Sie den Dienst mit java -jar oder mit der Eclipse-IDE ausgeführt haben, auf der eine Java-Anwendung ausgeführt wirdkönnen Sie den Inhalt der Vorlage mithilfe einer Ressourcenkennung anzeigen, die mit beginnt http://localhost:8080/query.

Führen Sie die Spring Boot-Anwendung mit JAVA aus

Aber selbst wenn Sie die angezeigte Eingabe in einer Abfrage wie „Mitarbeiter“ eingegeben haben, können Sie das Ergebnis nicht sehen, da die verbleibende Funktionalität die verbleibende Konfiguration für die Webanwendung erfordert.

6. WAR-Datei erstellen

Die Anwendung, die Sie bis hierhin erstellt haben, ist so konfiguriert, dass sie ein JAR-Artifcat generiert. Um es auf eine WAR-Datei umzustellen, müssen Sie die ändern Verpackung Attribut in der pom.xml in war. Wenn Sie die WAR-Datei außerdem in einem externen Container bereitstellen möchten, müssen Sie auch die Abhängigkeiten des eingebetteten Containers als markieren bereitgestellt.

7. Initialisieren Sie das Servlet

Zuvor enthielt die Anwendung eine öffentliche statische void main()-Methode, die bei der Verwendung eine Spring Boot-Konfiguration berücksichtigte Java -jar Befehl. Durch Konvertieren in eine WAR-Datei mit kein XML Dateien benötigen Sie eine andere Nachricht an den Servlet-Container, wie die Anwendung gestartet wird. Sie müssen also Ihre eigene WebXML-Java-Klasse bereitstellen.

WebXML.java

package net.javabeat.springdata.webXML;

import net.javabeat.springdata.executable.Executable;

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.web.SpringBootServletInitializer;

public class WepXML extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Executable.class);
    }
}

WebXML ist eine reine Java-Klasse, die eine Alternative zum Erstellen einer web.xml bietet. Es erweitert die SpringServletInitializer-Klasse. Diese Erweiterung bietet viele konfigurierbare Optionen durch Überschreiben von Methoden. Aber eine erforderliche Methode ist konfigurieren().

„Configure()“ bietet die Möglichkeit, die Klassen zu registrieren, die zum Starten der Anwendung erforderlich sind. Hier geben Sie einen Griff für Ihr Gerät an Ausführbar Aufbau. Auch wenn public static void main() nicht mehr benötigt wird, können Sie diesen Code beibehalten.

8. Führen Sie die WAR-Datei aus

Es ist die Demonstration, die wir Ihnen geben würden, um Ihnen alles klar zu machen. Erstellen Sie einfach Ihre Anwendung und stellen Sie sicher, dass Maven Ihre WAR erstellt hat. Legen Sie Ihre WAR-Datei im Webapp-Ordner von Tomcat 8 ab und starten Sie Tomcat. Eine andere Möglichkeit besteht darin, Ihre Eclipse-IDE in Tomcat 8 zu integrieren, mit der rechten Maustaste auf den Projektordner zu klicken und „Ausführen als“ zu verwenden.

Neo4j REST WAR wird am Standardstandort ausgeführt Neo4j REST WAR-Abfrageseite wird ausgeführt Neo4j REST WAR Ausführen der Ausführungsseite

Neo4j REST WAR führt Abfrageseitenadresse aus Neo4j REST WAR führt Seitenadresse aus

Laden Sie den Quellcode herunter

Symbol

Spring Data Neo4j Rest Exporter mit Spring-Boot

1 Datei(en) 14,40 KB Download

Kommentar verfassen

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

Nach oben scrollen