Spring Data REST + GemFire ​​+ jQuery-Integration

In diesem Tutorial wird erläutert, wie Sie die Frameworks Spring Data REST, GemFire ​​und JQuery integrieren. Zur Nutzung der Dienste können mehrere JavaScript-Frameworks in Spring Data REST integriert werden. Wir haben die Integration zwischen Spring Data REST und AngularJS erklärt, wobei eine GemFire-In-Memory-Plattform zur Darstellung des Daten-Repositorys verwendet wurde.

Lesen Sie auch:

  • Spring Data JPA
  • Spring Data JPA + Querydsl
  • Spring Data + MongoDB

In diesem Tutorial untersuchen wir jedoch die Integration zwischen Spring Data REST und der jQuery-Bibliothek. Die hier verwendete jQuery-Bibliothek ist 1.10.2, die eine spätere Version berücksichtigt. Aber selbst wenn Sie sich für die Verwendung einer anderen Version von jQuery entschieden haben, müssen Sie in diesem Tutorial nur dieselbe Anwendung verwenden, die ohne Probleme funktioniert. Wenn Sie Fragen haben, schreiben Sie diese bitte in den Kommentarbereich.

1. Verwendete Werkzeuge

  • JDK 1.6.
  • Tomcat 7.
  • Maven 3.
  • Spring Data REST.
  • GemFire ​​7.0.1-Plattform (JAR-Verteilung).
  • JQuery 1.10.2

2. Projektstruktur

Hier ist die Projektstruktur, die für die Entwicklung der Spring Data REST-, GemFire- und JQuery-Anwendung verwendet wird.

Spring Data REST GemFire ​​jQuery-Projektstruktur

3. Geschäftsdomäne

Hier ist die in diesem Tutorial verwendete Domänenklasse. In diesem Tutorial haben wir eine Nachrichtenentität oder ein Nachrichtenobjekt, das über den Restful-Dienst genutzt werden muss. Schauen Sie sich die Implementierung unten an. Die Annotation @Region muss verwendet werden, um anzugeben, dass diese Klasse den GemFire-Speicher verwendet. Dies entspricht der Tabelle in der relationalen Datenbank.

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 Abstraktionsebene, in der Sie noch nie eine Implementierung für Ihr Projekt bereitgestellt haben CRUD Operationen, auch 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 das CrudeRepository, 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 verbraucht 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-Kontextkonfiguration

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 in den Bereitstellungsdeskriptor aufnehmen. Die Spring Data REST-Konfiguration wird in einer Klasse namens RepositoryRestMvcConfiguration definiert. 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 nutzen zu können, wenn es darum geht, das Spring-Framework mithilfe von XML zu konfigurieren. 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="2.5">
<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. GemFire-Repositorys direkt verfügbar machen

Es ist nur ein Versuch, die GemFire-Repositorys über Google Dev HTTP verfügbar zu machen. Befolgen Sie dazu einfach die folgenden Schritte:

  • Öffnen Sie im Chrome-Browser den Dev HTTP Client.
  • 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-jQuery/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 ​​jQuery-Verbrauch

9. Spring Data REST- und jQuery-Integration

Wie wir alle wussten, jQuery ist eine schnelle, kleine und funktionsreiche JavaScript-Bibliothek. Mit einer benutzerfreundlichen API, die in mehreren Browsern funktioniert, werden Dinge wie das Durchlaufen und Bearbeiten von HTML-Dokumenten, die Ereignisbehandlung, Animation und Ajax viel einfacher. Außerdem wird die JSON-Antwort verwendet, wie Sie sehen würden. Schauen Sie sich das folgende JQuery-Beispiel an, um zu erfahren, wie Sie über jQUEry auf Spring Data REST-Dienste zugreifen.

index.html

<html>
<head>
<title>JavaBeat Tutorial</title>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
<script src="messages.js"></script>
</head>
<body>
<div style="width:50%">
<h2>JavaBeat Tutorial</h2>
<h2>GemFire + REST + JQuery</h2>
<div id="messages">

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

message.js

$(document).ready(function() {
$.ajax({
url: "http://localhost:8080/SpringData-GemFire-REST-JQuery-1.0/rest/messages"
}).then(function(data) {
var messages = data("_embedded")("messages");
var value = "";
$("#messages").html("Message #1 :: Message Content :: " + messages(0).message + " :: Message Link :: <a href="https://javabeat.net/spring-data-rest-jquery/"+messages(0)._links.self.href+"">Link</a>" + '<br>' +
"Message #2 :: Message Content :: " + messages(1).message + " :: Message Link :: <a href=""+messages(1)._links.self.href+"">Link</a>");
});
});

10. Spring Data REST- und jQuery-Demo

Spring Data REST- und jQuery-Verbrauch

Spring Data REST-Verbrauch

11. Zusammenfassung

In diesem Tutorial wird der Spring Data REST-Dienst mithilfe der jQuery-Bibliothek genutzt und das Ergebnis der Nutzung wurde auf einer HTML-Seite angezeigt. In unserem vorherigen Tutorial haben wir Ähnliches erklärt Auf Spring Data REST kann über die AngularJS-Bibliothek zugegriffen werden. Wenn Sie Fragen haben, schreiben Sie diese bitte in den Kommentarbereich.

Laden Sie den Quellcode herunter

(wpdm_file id=107)

Kommentar verfassen

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

Nach oben scrollen