Zugriff auf Daten mit Spring Data GemFire

VFabric GemFire ​​(GemFire) ist eine kommerziell lizenzierte Datenverwaltungsplattform, die Zugriff auf Daten aus den verteilten Architekturen bietet. Es ist als eigenständiges Produkt und als Komponente von erhältlich VMware vFabric Suite.

Basierend auf der Kurzfassung bietet GemFire ​​eine in Erinnerung Datenraster, das extrem hohen Durchsatz, Datenzugriff mit geringer Latenz und Skalierbarkeit bietet. Über einen verteilten Cache hinaus bietet GemFire ​​erweiterte Funktionen, darunter:

  • Ereignisbenachrichtigung
  • OQL-Abfragesyntax (Object Query Language).
  • Kontinuierliche Abfragen
  • Transaktionsunterstützung
  • Remote-Funktionsausführung
  • WAN-Kommunikation
  • Effiziente und portable Objektserialisierung (PDX)
  • Tools, die Systemadministratoren bei der Verwaltung und Konfiguration des verteilten GemFire ​​unterstützen
    System

Dieses Tutorial soll den Lesern die Grundidee der Verwendung vermitteln GemFire für den Zugriff auf die Daten durch Lesen von Entitäten beim Schreiben in den Speicher. Vor jeder weiteren Erklärung ist es wichtig, ein Konzept zu kennen, das bei der Diskussion des GemFire ​​verwendet wird Regionen.

Lesen Sie auch:

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

Wenn Sie diesem Tutorial folgen, können Sie gerne Ihre Kommentare schreiben, wenn Sie Fragen oder Hilfe haben. Außerdem habe ich am Ende dieses Tutorials den Download des Quellcodes angehängt.

1. Region

Zum Speichern und Abrufen von Daten aus dem Cache ist eine Region erforderlich. Region ist eine Schnittstelle, die erweitert wird java.util.Map um einen grundlegenden Datenzugriff mithilfe der bekannten Schlüssel-/Wert-Semantik durchzuführen. Die Region-Schnittstelle ist mit Klassen verbunden, die sie benötigen, sodass der eigentliche Regionstyp vom Programmiermodell entkoppelt ist. Normalerweise ist jede Region einem Domänenobjekt zugeordnet, ähnlich einer Tabelle in einer relationalen Datenbank. Wenn Sie sich die Beispielnachricht ansehen, sehen Sie eine definierte Nachricht @Region.

Es ist sehr wichtig für Sie zu wissen, dass GemFire ​​weder die Zuordnungen verwaltet noch die relationale Integrität zwischen Regionen erzwingt.

2. Java Beans (Geschäftsdomäne)

Wie bereits erwähnt, arbeitet GemFire ​​mit Daten, die gespeichert, abgerufen und aus dem Speicher gelöscht werden. Diese Daten sind identisch mit denen, die bereits beispielhaft in Spring Data/JPA definiert wurden.

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;
	}
}

3. GemFire-Repository

Es handelt sich um dasselbe Konzept des Spring-Daten-Repositorys, das in den vorherigen Tutorials besprochen wurde, aber dieses Mal wird das Repository mithilfe der GemFire-Bibliothek definiert.

MessageReposirory.java

package net.javabeat.springdata.repo;

import net.javabeat.springdata.data.Message;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface MessageRepository extends CrudRepository<Message,Integer>{

}

4. Spring Bean-Definition

Es ist die Spring-Bean-Definition, die zum Konfigurieren des Spring-Kontexts verwendet wird. Wo in den Beans Repositorys, Eigenschaften und mehrere andere konfigurierbare Objekte definiert werden. Hier verwenden wir dieses XML-Dokument zum Definieren und Auffinden der GemFire-Repositorys. Schauen wir uns die folgenden Konfigurationen an, um zu erfahren, wie das Gemfire-Repository in der Spring-Konfigurationsdatei konfiguriert ist.

SpringContxt.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"
	xsi:schemaLocation="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>

5. Spring Data + GemFire-Beispielanwendung

Es handelt sich um die ausführbare Java-Anwendung, die eine Hauptimplementierung enthält, die direkt mit der GemFire-Engine kommuniziert.

Ausführbare Datei.java

package net.javabeat.springdata.executable;

import java.util.ArrayList;
import java.util.List;

import net.javabeat.springdata.bean.GemFireBean;
import net.javabeat.springdata.data.Message;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

import com.google.common.collect.Lists;

public class Executable {
	// Getting spring context
	public static ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new ClassPathResource("SpringContext.xml").getPath());

	// GemFireBean declaration, it's just a normal spring bean that contains a reference for MessageRepository
	public static GemFireBean gfb;

	public static void main(String() args) {
		// Acquiring the GemFireBean
		gfb = (GemFireBean)context.getBean("gemFireBean");
		System.out.println("Before Linking GemFire ... Initialized Message Objects");
		Message mess1 = new Message("1","Hello JavaBeat !");
		Message mess2 = new Message("2","Hello Spring Data !");
		Message mess3 = new Message("3","Hello Spring Data - GemFire !");
		Message mess4 = new Message("4","Just Hello !");
		List<Message> messages = new ArrayList<Message>();
		messages.add(mess1);
		messages.add(mess2);
		messages.add(mess3);
		messages.add(mess4);
		System.out.println("Print out all Created Messages");
		for(Message m : messages){
			System.out.println("Created Message ID :: "+m.getMessageId()+" :: With Content :: "+m.getMessage());
		}
		System.out.println("Linking GemFire for Persisting Messages ...");
		gfb.getMessageRepository().save(messages);
		System.out.println("Persisting Process finsihed succesfully ...");
		// Reset the messages list
		messages = null;
		System.out.println("Linking GemFire for Retrieving Messages ...");
		messages = Lists.newArrayList(gfb.getMessageRepository().findAll());
		for(Message m : messages){
			System.out.println("Retrieved Message ID :: "+m.getMessageId()+" :: With Content :: "+m.getMessage());
		}

		System.out.println("End ::");
	}
}

6. GemFire ​​Maven-Abhängigkeiten

Die Verwendung von GemFire ​​kann entweder durch die Verwendung des GemFire ​​vFabric-Produkts erfolgen, das über den oben genannten Link installiert werden kann, oder durch Hinzufügen der GemFire-Abhängigkeit zu Ihrem pom.xml. Sobald Sie die GemFire-Abhängigkeit hinzugefügt und definiert haben CacheFactoryBean und LocalRegionFactoryBeanist das GemFire ​​betriebsbereit.

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</artifactId>
	<version>1.0</version>
	<packaging>jar</packaging>

	<name>Spring Data</name>
	<!-- Just for including the Spring framework necessary libraries in one shot -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.0.2.RELEASE</version>
	</parent>

	<dependencies>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-gemfire</artifactId>
			<version>1.3.4.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>com.gemstone.gemfire</groupId>
			<artifactId>gemfire</artifactId>
			<version>7.0.1</version>
		</dependency>
		<!-- Google List API -->
		<dependency>
			<groupId>com.google.collections</groupId>
			<artifactId>google-collections</artifactId>
			<version>1.0</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>

7. Zugriff auf Daten per GemFire-Demo

Durch Ausführen der Hauptanwendung erhalten Sie eine große Menge an GemFire-Ausgaben in der Konsole. Nachfolgend finden Sie Ihre Bewerbungsnachrichten:

(info 2014/05/23 12:27:29.268 EEST  <main> tid=0x1) Initializing region PdxTypes
12:27:29.279 (main) INFO  o.s.d.g.CacheFactoryBean - Connected to Distributed System () as Member (mohammad-amr-lt:4894) on Host (mohammad-amr-lt).
12:27:29.279 (main) INFO  o.s.d.g.CacheFactoryBean - Created new GemFire v.7.0.1 Cache ().
12:27:29.331 (main) INFO  n.j.s.e.Executable$1 - Created new cache region (messages)
12:27:29.440 (main) INFO  o.s.c.s.DefaultLifecycleProcessor - Starting beans in phase 2147483647
Before Linking GemFire ... Initialized Message Objects
Print out all Created Messages
Created Message ID :: 1 :: With Content :: Hello JavaBeat !
Created Message ID :: 2 :: With Content :: Hello Spring Data !
Created Message ID :: 3 :: With Content :: Hello Spring Data - GemFire !
Created Message ID :: 4 :: With Content :: Just Hello !
Linking GemFire for Persisting Messages ...
Persisting Process finsihed succesfully ...
Linking GemFire for Retrieving Messages ...
Retrieved Message ID :: 4 :: With Content :: Just Hello !
Retrieved Message ID :: 2 :: With Content :: Hello Spring Data !
Retrieved Message ID :: 3 :: With Content :: Hello Spring Data - GemFire !
Retrieved Message ID :: 1 :: With Content :: Hello JavaBeat !
End ::
12:27:29.557 (main) INFO  n.j.s.e.Executable - Started Executable in 7.911 seconds (JVM running for 8.36)

8. Zusammenfassung

GemFire ​​ist ein Spring-Framework, das zur Bearbeitung der Daten im Speicher verwendet wird. Es wird als Cache-Framework verwendet, wie Sie in den nächsten Tutorials sehen werden. In diesem Tutorial haben Sie die grundlegende Verwendung von GemFrie kennengelernt, indem Sie ein Nachrichtenobjekt in einem definierten Bereich namens „ Mitteilungen. Die persistenten Nachrichten wurden vom Druckvorgang auf der JVM-Konsole gelesen.

Laden Sie den Quellcode herunter

(wpdm_file id=102)

Kommentar verfassen

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

Nach oben scrollen