Spring Data REST + GemFire ​​+ Rest.js-Integration

In unseren vorherigen Tutorials habe ich die Spring Data REST + GemFire ​​+ jQuery-Integration und die backbone.js-Integration erklärt. REST (Representational State Transfer) ist eine der effektivsten Möglichkeiten, die Spring Data REST für die Nutzung von Diensten bereitstellt. Als Client können clientseitige Frameworks wie AngularJS, jQuery, Backbone und Rest-Bibliotheken verwendet werden. In diesem Tutorial erfahren Sie, wie Sie es verwenden Rest.js-Framework für den Zugriff auf die GemFire ​​REST-Dienste.

1. Projektstruktur

Spring Data REST – GemFire ​​– Rest.js – Projektstruktur

2. Verwendete Werkzeuge

  • JDK 1.6.
  • Apache Tomcat 7.
  • GemFire ​​7.0.1-Plattform (JAR-Verteilung)
  • Maven 3.
  • Rest.js
  • Eclipse-IDE
  • Frühlingsdaten
  • Frühlingsrahmen

3. Geschäftsdomäne

Wir haben eine Nachrichtenentität oder ein Nachrichtenobjekt, das für den Restful-Dienst verwendet werden muss. Dies ist die primäre Entitätsklasse für dieses Tutorial.

Message.java

package net.javabeat.springdata.data;

import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.PersistenceConstructor;
import org.springframework.data.gemfire.mapping.Region;

@Region("messages")
public class Message {
	@Id
	private String messageId;
	private String message;

	public Message() {
	}

	@PersistenceConstructor
	public Message(String id, String message) {
		this.messageId = id;
		this.message = message;
	}

	public String getMessageId() {
		return messageId;
	}

	public void setMessageId(String messageId) {
		this.messageId = messageId;
	}

	public String getMessage() {
		return message;
	}

	public void setMessage(String message) {
		this.message = message;
	}
}

4. Spring Data Repository

Das Repository bietet Ihnen eine Abstraktionsschicht, in der Sie noch nie eine Implementierung für Ihre CRUD-Operationen bereitgestellt haben, selbst wenn es nur ein kleiner Teil des Codes war. Was Sie tun müssen, ist, Ihre eigene Schnittstelle zu erstellen, die das spezielle Repository von Spring Data erweitert, und die verbleibende Arbeit bleibt dem Spring-Framework überlassen, um die erforderliche Implementierung abzuschließen. Daher sollten Sie ein Repository wie unten bereitstellen müssen. Wenn Sie sich die folgende Klasse MessageRepository ansehen, erweitert sie die CrudeRepository Dabei handelt es sich um die Schnittstelle der Spring-Daten, die die Methoden für die CRUD-Operationen definiert.

MessageRepository.java

package net.javabeat.springdata.repo;

import net.javabeat.springdata.data.Message;

import org.springframework.data.repository.CrudRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;

@RepositoryRestResource(collectionResourceRel="messages",path="messages")
public interface MessageRepository extends CrudRepository<Message,Integer> {}

Wie Sie bemerkt haben, ist das Nachrichten-Repository lediglich eine Schnittstelle, die als Erweiterung für das spezielle Spring-Daten-Repository betrachtet wird. Sie haben erwähnt, dass das Repository auf den Typ „Message Business Object“ einwirkt, in dem das Repository damit umgehen würde, um die erforderlichen CRUD-Vorgänge auszuführen.

5. GemFire ​​Frühlingsbohne

Es handelt sich lediglich um eine normale Spring Bean, die zur Bereitstellung von Dummy-Nachrichten verwendet wird, die von den Diensten verwendet werden.

GemFireBean.java

package net.javabeat.springdata.bean;

import net.javabeat.springdata.data.Message;
import net.javabeat.springdata.repo.MessageRepository;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class GemFireBean {

	MessageRepository messageRepository;

	public GemFireBean(){

	}

	public MessageRepository getMessageRepository() {
		return messageRepository;
	}

	@Autowired
	public void setMessageRepository(MessageRepository messageRepository) {
		// Message repository has been set
		this.messageRepository = messageRepository;

		// Add some messages into GemFire for being seen
		Message message = new Message();
		message.setMessageId("1");
		message.setMessage("Hello JavaBeat !");

		messageRepository.save(message);

		// Add
		message = new Message();
		message.setMessageId("2");
		message.setMessage("Hello GemFire REST");
		messageRepository.save(message);
		System.out.println("Messages are filled");
	}
}

6. Spring Bean-Definition

Dies ist die einfache XML-Konfiguration für die Spring Beans.

SpringContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:gfe-data="http://www.springframework.org/schema/data/gemfire"
	xmlns:gfe="http://www.springframework.org/schema/gemfire"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/data/gemfire http://www.springframework.org/schema/data/gemfire/spring-data-gemfire.xsd http://www.springframework.org/schema/gemfire http://www.springframework.org/schema/gemfire/spring-gemfire.xsd">
	<!-- Search for spring components -->
	<context:component-scan base-package="net.javabeat"></context:component-scan>
	<!-- Declare GemFire Cache -->
	<gfe:cache/>
	<!-- Local region for being used by the Message -->
	<gfe:local-region id="messages" value-constraint="net.javabeat.springdata.data.Message"/>
	<!-- Search for GemFire repositories -->
	<gfe-data:repositories base-package="net.javabeat.springdata.repo"/>
</beans>

7. Repository Rest Dispatcher Servlet und Webbereitstellungsdeskriptor

Um Spring Data Rest neben Ihrer vorhandenen Webanwendung zu installieren, müssen Sie die entsprechende Konfiguration einschließen.

  • Die Spring Data REST-Konfiguration wird in einer Klasse namens definiert RepositoryRestMvcConfiguration.
  • Da es sich bei Spring Data REST einfach um eine Spring-MVC-Anwendung handelt, müssen Sie nur das RepositoryRestDispatcherServlet einbinden, um die REST-Funktionalität zu nutzen, wenn wir das Spring-Framework mit XML-Konfigurationen verwenden.

Der Web-Bereitstellungsdeskriptor sieht wie folgt aus.

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" metadata-complete="true" version="3.0">
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/spring-config/SpringContext.xml</param-value>
	</context-param>
	<servlet>
		<servlet-name>rest</servlet-name>
		<servlet-class>org.springframework.data.rest.webmvc.RepositoryRestDispatcherServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>rest</servlet-name>
		<url-pattern>/rest/*</url-pattern>
	</servlet-mapping>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
</web-app>

8. Greifen Sie auf GemFire-Repositorys zu

Es handelt sich lediglich um einen Schritt zum Offenlegen der GemFire-Repositorys mithilfe von Google Dev HTTP. Befolgen Sie dazu einfach die folgenden Schritte:

  • Laden Sie die herunter SoapUI für die Nutzung eines REST-Dienstes.
  • Geben Sie Ihren Host ein, gefolgt von der Portnummer und dem Webkontext für die bereitgestellte Anwendung, was zum Token führen sollte http://localhost:8080/SpringData-GemFire-REST-1.0.
  • Um die Nachrichtenressourcen zu nutzen, müssen Sie die im Abschnitt erwähnte RepositoryRestDispactherServlet-Zuordnungs-URL hinzufügen web.xml und sein /ausruhen/ was zu einem URL-Wert wie folgt führt http://localhost:8080/SpringData-GemFire-REST-Rest.js-1.0/rest/
  • Fügen Sie das Pfadsegment hinzu, unter dem diese Ressource exportiert werden soll. Dieser Wert wurde mithilfe von bereitgestellt Weg -Eigenschaft im Header des MessageRepository, um die Nachrichtenressource wie unten dargestellt verfügbar machen zu können.

Spring Data REST – GemFire ​​– Ressourcen exportieren

Wie Sie bemerkt haben, wird den Nachrichtenressourcen das restliche Wort vorangestellt, das dem zugeordnet ist RepositoryRestDispatcherServlet.

9. Setup-Umgebung – Erstellen Sie Bower-Konfigurationsdateien

Erstellen Sie zunächst ein Bower-Steuerelement (Bower ist ein Paketmanager), das dem Bower mitteilt, wo die JavaScript-Abhängigkeiten abgelegt werden sollen. Dazu müssen Sie die folgenden Schritte ausführen.

  • Herunterladen Git (ist ein kostenloses und quelloffenes verteiltes Versionskontrollsystem DVCS) und installieren Sie es auf Ihrem Computer. Falls Sie ein Linux oder ein anderes Betriebssystem verwendet haben, versuchen Sie, die gewünschte Version zu installieren, indem Sie die besuchen Git Website.
  • Laden Sie die herunter node.js Plattform (ist eine Softwareplattform, die eine sichere Möglichkeit bietet, leistungsstarke und skalierbare Netzwerkanwendungen in JavaScript zu erstellen).
  • Nachdem Sie die Installation von Git und node.js abgeschlossen haben, wird als nächstes die Befehlszeile verwendet. Öffnen Sie also die Befehlszeile und navigieren Sie durch sie zu den Webanwendungen in Ihrem eigenen Projekt. In unserem Fall ist der Standort D:\Krishna\EclipseLink\Workspace\SpringData-GemFire-REST-Rest.js-1.0\src\main\webapp.
  • Typ Knoten -v um sicherzustellen, dass Sie node.js erfolgreich installiert haben. Sie sollten die Version der installierten node.js-Plattform finden. In unserem Fall ist die Version v0.10.28.
  • Typ npm -v um sicherzustellen, dass der npm (Node Package Manager) ordnungsgemäß installiert ist. Knotenpaketmanager zur Verwaltung der JavaScript-Abhängigkeiten, in dem JavaScript-Bibliotheken installiert und JavaScript-Programme veröffentlicht wurden. In unserem Fall haben wir 1.4.9 Ausführung.
  • Typ Bower-Init zum Erstellen einer Datei „bower.json“, die jedes für das Projekt erforderliche JavaScript-Paket beschreibt. Bower fragt nach mehreren Informationen wie Projektname, Lizenz usw. Im Zweifelsfall drücken Sie einfach die Eingabetaste, um die Standardeinstellung zu akzeptieren.
  • Als nächstes verwenden Sie Bower, um Backbone (da wir JavaScript-Module verwenden, verwenden wir die AMD-Version von Backbone) und einen Loader wie curl.js zu installieren.

Spring Data REST – GemFire ​​– Rest.js-Integration – Bower Init – Befehlsausführung

Die resultierende Datei sollte „bower.json“ sein und die erforderlichen Informationen zu JavaScript-Abhängigkeiten enthalten. Und die Projektstruktur sollte so sein.

Spring Data REST – GemFire ​​– Rest.js-Integration – Bower Init – Befehlsergebnis

Geben Sie in der Befehlszeile Folgendes ein:

  • Bower Install –Save Rest#~1
  • Bower Install –save Curl#~0.8

Bower installiert diese Pakete im Verzeichnis.

Spring Data REST – GemFire ​​– Rest.js-Integration – Bower-Installationspakete – Befehlsausführung

Wo sieht die Struktur des Projekts aus?

Spring Data REST – GemFire ​​– Rest.js-Integration – Bower Install Packages – Befehlsergebnis

Und die Datei „bower.json“ sollte so aussehen

Bower.json

{
  "name": "SpringData-GemFire-REST-Rest.js",
  "version": "0.0.1",
  "description": "Spring Data REST - GemFire - Rest.js Integration",
  "main": "applicationModule",
  "authors": (
    "JavaBeat"
  ),
  "license": "MIT",
  "ignore": (
    "**/.*",
    "node_modules",
    "bower_components",
    "test",
    "tests"
  ),
  "dependencies": {
    "rest": "~1",
    "curl": "~0.8"
  }
}

Jetzt können Sie mit dem Schreiben von Rest.js-Komponenten beginnen.

10. Rest.js-Rendermodul

Erstellen Sie zunächst eine Renderfunktion, um Daten in ein HTML-Dokument einzufügen.

render.js

define(function (require) {

    var ready = require('curl/domReady');

    return render;

    function render (entity) {
        ready(function () {
            var idElement, nameElement;
            placeHolder = document.querySelector('(data-name="placeHolder")');
			var messages = entity._embedded.messages;
			for(var i = 0 ; i < messages.length;i++){
				var index = i + 1;
				placeHolder.innerHTML += "Message # "+index+" :: " + messages(i).message + " :: <a href="https://javabeat.net/spring-data-rest-gemfire-rest-js-integration/"+messages(i)._links.self.href+"">Message Link</a><br>";
			}
        });
    }
});

Dieses AMD-Modul verwendet einfache DOM-Abfragen und -Manipulationen, um Text in das Dokument einzufügen. Um sicherzustellen, dass das DOM nicht verwendet wird, bevor es fertig ist, importiert und verwendet das Rendermodul die Datei „curl.js“. domReady Funktionsmodul.

11. Entwickeln Sie das Rest.js-Kompositionsanwendungsmodul

Als nächstes erstellen Sie ein Modul, das die Anwendung zusammenstellt. Beachten Sie, dass das Kompositionsanwendungsmodul als Bower Init bezeichnet wurde Hauptdatei aufgerufen.

applicationModule.js

define(function (require) {
    var rest = require('rest');
    var mime = require('rest/interceptor/mime');
    var entity = require('rest/interceptor/entity');
    var render = require('./render');
    var endpointUrl, client;
    endpointUrl="http://localhost:8080/SpringData-GemFire-REST-Rest.js-1.0/rest/messages";
    client = rest.chain(mime, { mime: 'application/json' }).chain(entity);
    client({ path: endpointUrl}).then(render);
});

Das Hauptmodul liest die Abfragezeichenfolge aus dem Standortobjekt des Dokuments, konfiguriert einen rest.js-Mime-Client und ruft den REST-Endpunkt auf.

rest.js gibt ein Promises/A+-Versprechen zurück, das das aufruft machen Funktionsmodul, wenn der Endpunkt Daten zurückgibt. Der machen Die Funktion erwartet die Entität, aber der rest.js-Client gibt normalerweise ein Antwortobjekt zurück. Der „Rest/Interceptor/Entity“-Interceptor entnimmt der Antwort die Entität und leitet sie an die weiter machen Funktion.

12. Rest.js-Boot-Skript

Als nächstes erstellen Sie das Boot-Skript. boot.js:

var curl;
(function () {

    curl.config({
        main: 'applicationModule',
        packages: {
            // Third-party packages
            curl: { location: 'bower_components/curl/src/curl' },
            rest: { location: 'bower_components/rest', main: 'rest' },
            when: { location: 'bower_components/when', main: 'when' }
        }
    });

}());

Dieses Skript konfiguriert den AMD-Loader: curl.config(). Der hauptsächlich Die Konfigurationseigenschaft teilt curl.js mit, wo sich das Hauptmodul der Anwendung befindet, das automatisch abgerufen und ausgewertet wird. Der Pakete Das Konfigurationsobjekt teilt curl.js mit, wo Module in den Paketen unserer Anwendung oder in Paketen von Drittanbietern zu finden sind.

13. Beispielanwendung (index.html)

Erstellen Sie abschließend eine index.html Datei und fügen Sie den folgenden HTML-Code hinzu:

index.html

<!doctype html>
<html>
    <head>
		<title>JavaBeat Tutorials</title>
        <script data-curl-run="boot.js" src="bower_components/curl/src/curl.js"></script>
    </head>
    <body>
        <div>
			<h2>JavaBeat Tutorial !</h2>
			<h3>Spring Data REST - GemFire - Rest.js Demo</h3>
            <p data-name="placeHolder">

			</p>
        </div>
    </body>
</html>

Der Skript Das Element lädt „curl.js“ und anschließend ein Anwendungsstartskript mit dem Namen „ boot.js. Das Boot-Skript initialisiert und konfiguriert eine AMD-Modulumgebung und startet dann den clientseitigen Anwendungscode.

14. Demo von Spring Data REST und Rest.js

Durch Aufrufen der index.html durch Eingabe der http://localhost:8080/SpringData-GemFire-REST-Rest.js-1.0/index.html Geben Sie im Browser den Adressbereich ein. Sie erhalten das folgende Ergebnis.

Spring Data REST – GemFire ​​– Rest.js-Integration – Demo

15. Zusammenfassung

Sie haben gerade eine Anwendung entwickelt, die ein Spring Data Rest + GemFire-Repository bereitstellt, auf das über HTTP und ein Rest.js-JavaScript-Framework zugegriffen werden kann. Wenn Sie Fragen haben, schreiben Sie diese bitte in den Kommentarbereich.

Laden Sie den Quellcode herunter

(wpdm_file id=110)

Kommentar verfassen

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

Nach oben scrollen