Spring Data REST + GemFire ​​+ AngularJS-Integration

Dieses Tutorial erklärt die Integration zwischen Spring Data REST, GemFire ​​und AngularJS Rahmen. Wir werden einen REST-Dienst entwickeln, der die JSON-Antwort zurückgibt und auf den über die AngularJS-Webseite zugegriffen wird.

1. Erforderliche Werkzeuge

Wir haben dieses Tutorial mithilfe der folgenden Tools entwickelt:

  • JDK 1.6.
  • Tomcat 7.
  • Maven 3.
  • GemFire ​​7.0.1.
  • AngularJS

2. Projektstruktur

Hier ist die Projektstruktur, die für dieses Tutorial verwendet wird.

Spring REST – GemFire ​​– Eclipse-Projektverzeichnis

3. Geschäftsdomäne

Message ist das Persistenzobjekt, das zum Speichern der Daten im In-Memory-Speicher von GemFire ​​verwendet wird. Für dieses Tutorial verwenden wir nur diese Entität. Wenn Sie sich den folgenden Code ansehen, importiert die Entität die org.springframework.data.gemfire.mapping.Region, die der Tabelle in der relationalen Datenbank entspricht. Diese Regionsklasse dient als Segment im Arbeitsspeicher und weist den Speicher für die Daten zu.

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

Es sind die Repositorys, die die CRUD-Operationen für die Geschäftsdomäne ermöglichen. In unserem vorherigen Tutorial habe ich die Spring Data und die Verwendung der Repositorys für die CRUD-Operationen erklärt.

MessageReposirory.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> {}

5. Frühlingsbohne

Es handelt sich um eine normale Spring Bean, die zum Füllen von Dummy-Daten innerhalb der GemFire-Plattform verwendet wird.

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-Kontextkonfigurationen

Es handelt sich um die Spring XML-Konfigurationsdatei, in der die Spring Beans, Repositorys und der GemFire-Cache definiert sind.

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. Maven-Build

Es ist die POM-Datei, die die benötigten Bibliotheken enthält.

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-GemFire-REST</artifactId>
<version>1.0</version>
<packaging>war</packaging>

<name>Spring Data</name>

<dependencies>
<!-- Spring Data GemFire Library -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-gemfire</artifactId>
<version>1.3.4.RELEASE</version>
</dependency>
<!-- GemFire Platform -->
<dependency>
<groupId>com.gemstone.gemfire</groupId>
<artifactId>gemfire</artifactId>
<version>7.0.1</version>
</dependency>
<!-- Spring Data REST MVC -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-rest-webmvc</artifactId>
<version>2.0.2.RELEASE</version>
</dependency>
<!-- Google List API -->
<dependency>
<groupId>com.google.collections</groupId>
<artifactId>google-collections</artifactId>
<version>1.0</version>
</dependency>
<!-- Required Libraries -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
<version>1.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>1.1.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.0.1.Final</version>
</dependency>

</dependencies>

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

<repositories>
<repository>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>http://repo.spring.io/libs-snapshot</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
<repository>
<id>gemstone</id>
<url>http://dist.gemstone.com.s3.amazonaws.com/maven/release/</url>
</repository>
</repositories>

<pluginRepositories>
<pluginRepository>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>http://repo.spring.io/libs-snapshot</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
</project>

8. Web-Bereitstellungsdeskriptor

Es handelt sich um den Webdeskriptor, der für die Anwendungskonfiguration für den JavaEE-Container verwendet wird. Eine wichtige Sache, um die Sie sich kümmern müssen, ist das Servlet des Spring MVC REST, das die Anfragen verarbeitet, die nach GemFire-Repositorys gefragt haben.

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>

RepositoryRestDispatcherServlet ist eine Spring-MVC-Ressource, die in Verbindung mit Spring Data REST arbeitet, um die REST-Ressourcen verfügbar zu machen. Im obigen Abschnitt haben Sie gesehen, wie Sie REST-Ressourcen mithilfe von Spring Boot verfügbar machen, indem Sie @import zum Importieren der RepositoryRestMvcConfiguration verwendet haben. Wenn Sie die Spring-Old-Fashion-Konfigurations-XML-Datei zum Offenlegen des Spring Data REST verwenden möchten, sollten Sie zum Exportieren der Ressourcen das RepositoryRestDispatcherServlet mit seiner Zuordnung verwenden, wie Sie oben erwähnt haben.

9. GemFire-Repositorys direkt verfügbar machen

In diesem Abschnitt wird erläutert, wie Sie über Google Dev HTTP auf die REST-Dienste zugreifen. Befolgen Sie 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 zur URL führen sollte http://localhost:8080/SpringData-GemFire-REST-1.0.
  • Um die Nachrichtenressourcen zu verbrauchen, müssen Sie Folgendes hinzufügen RepositoryRestDispactherServlet Zuordnungs-URL, die in der erwähnt wird web.xml und sein /ausruhen/ was zu einem URL-Wert wie folgt führt http://localhost:8080/SpringData-GemFire-REST-AngularJS-1.0./rest/
  • Fügen Sie das Pfadsegment hinzu, unter dem diese Ressource exportiert werden soll. Dieser Wert wurde mithilfe von bereitgestellt Weg Eigenschaft in der Kopfzeile der MessageRepository um die Nachrichtenressource wie unten verfügbar zu machen.

Spring Data REST AngularJS-Demo

Wie Sie bemerkt haben, sind den Nachrichtenressourcen das Präfix vorangestellt ausruhen Wort, das dem zugeordnet ist RepositoryRestDispatcherServlet.

10. Zugriff auf GemFire ​​REST mit AngularJS

AngularJS ist ein JavaScript-Framework zum Erstellen der Webanwendung, die am besten für mobile Geräte und Responsi geeignet ist. Es ist vollständig erweiterbar und funktioniert gut mit anderen Bibliotheken. Um die AngularJS-Bibliothek in Ihre Seite einzubinden, eine JavaScript-Bibliotheks-URL https://ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.min.js sollte innerhalb eines Skript-Tags hinzugefügt werden. Dies ist der Content Deliver Network (CDN)-Ansatz zur Verwendung von AngularJS, ohne die Bibliotheken herunterzuladen. Dies kann am besten nur für die Entwicklungsanwendung geeignet sein, für die Produktion müssen Sie die Bibliotheken herunterladen.

Im folgenden Beispiel wird die AngualrJS-Bibliothek in den Header der Seite importiert, um sie beim REST-Ressourcenverbrauch zu verwenden.

index.html

<html ng-app>
<head>
<title>JavaBeat Tutorial</title>
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.min.js"></script>
<script src="messages.js"></script>
</head>
<body>
<div style="width:50%">
<h2>JavaBeat Tutorial</h2>
<h2>GemFire + REST + AngularJS</h2>
<div ng-controller="fetch">
<h2>full json response:</h2>
<p>{{messages}}</p>
<h2>Messages:</h2>
<ul ng-repeat="message in messages">
<p>Message:</p>
<p>{{message.message}}</p>
<a href="https://javabeat.net/spring-data-rest-gemfire-angularjs/{{message("_links")("self")("href")}}">Go To Page Addressed Message : {{message._links.self.href}}</a>
</ul>
</div>
</div>
</body>
</html>

message.js

function fetch($scope, $http) {
$http.get('http://localhost:8080//SpringData-GemFire-REST-1.0/rest/messages').
success(function(data) {
$scope.messages = data("_embedded")("messages");
});
}

11. Spring Data REST – GemFire ​​– AngularJS Demo

Spring REST GemFire ​​AngularJS-Demo

11.Zusammenfassung

GemFire ​​ist eine Plattform für den In-Memory-Persistent-Store und wird hauptsächlich zum Caching verwendet. In diesem Tutorial wurde eine WAR-Datei generiert, die für Tomcat 7 bereitgestellt wurde. Auf die GemFire-Repositorys wird zugegriffen und deren Daten werden über einen HTTP-REST mithilfe von AngularJS abgerufen.

AngularJS ist ein bekanntes JavaScript-Framework, das das Geparste lesen, analysieren und konvertieren kann JSON Antwort in objektbasierter Form. Durch analysierte Objekte wird mithilfe von navigiert Punkt Betreiber wie das Beispiel mitmachen. AngularJS kann in Spring Data REST integriert werden. In diesem Tutorial haben Sie eine Spring Data REST-Anwendung entwickelt, die mit der GemFire-Plattform verbunden wird, und AngularJS wird in der Präsentation zum Anzeigen der abgerufenen Nachrichten verwendet.

Laden Sie den Quellcode herunter

(wpdm_file id=106)

Kommentar verfassen

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

Nach oben scrollen