Eine Anleitung zu GemFire ​​mit Frühlingsdaten

1. Übersicht

GemFire ​​ist eine leistungsstarke verteilte Datenverwaltungsinfrastruktur, die sich zwischen Anwendungscluster und Back-End-Datenquellen befindet.

Mit GemFire ​​können Daten im Speicher verwaltet werden, wodurch der Zugriff beschleunigt wird. Spring Data bietet eine einfache Konfiguration und Zugriff auf GemFire ​​über die Spring-Anwendung.

In diesem Artikel sehen wir uns an, wie wir GemFire ​​verwenden können, um die Caching-Anforderungen unserer Anwendung zu erfüllen.

2. Maven-Abhängigkeiten

Um die Spring Data GemFire-Unterstützung nutzen zu können, müssen wir zunächst die folgende Abhängigkeit in unsere pom.xml einfügen:

 org.springframework.data spring-data-gemfire 1.9.1.RELEASE 

Die neueste Version dieser Abhängigkeit finden Sie hier.

3. GemFire-Grundfunktionen

3.1. Zwischenspeicher

Der Cache im GemFire ​​bietet die wesentlichen Datenverwaltungsdienste sowie die Konnektivität zu anderen Peers.

Die Cache-Konfiguration ( cache.xml ) beschreibt, wie die Daten auf verschiedene Knoten verteilt werden:

     ...     ... 

3.2. Regionen

Datenbereiche sind eine logische Gruppierung innerhalb eines Caches für einen einzelnen Datensatz.

Einfach ausgedrückt, können wir in einer Region Daten auf mehreren VMs im System speichern, ohne zu berücksichtigen, auf welchem ​​Knoten die Daten im Cluster gespeichert sind.

Regionen werden in drei große Kategorien eingeteilt:

  • Die replizierte Region enthält den vollständigen Datensatz auf jedem Knoten. Es gibt eine hohe Leseleistung. Schreibvorgänge sind langsamer, da die Datenaktualisierung an jeden Knoten weitergegeben werden muss:
  • Die partitionierte Region verteilt die Daten so, dass jeder Knoten nur einen Teil des Regionsinhalts speichert. Eine Kopie der Daten wird auf einem der anderen Knoten gespeichert. Es bietet eine gute Schreibleistung.
  • Die lokale Region befindet sich auf dem definierenden Mitgliedsknoten. Es besteht keine Verbindung zu anderen Knoten innerhalb des Clusters.

3.3. Fragen Sie den Cache ab

GemFire ​​bietet eine Abfragesprache namens OQL (Object Query Language), mit der wir auf die in GemFire-Datenregionen gespeicherten Objekte verweisen können. Dies ist SQL in der Syntax sehr ähnlich. Mal sehen, wie eine sehr einfache Abfrage aussieht:

SELECT DISTINCT * FROM exampleRegion

Der QueryService von GemFire bietet Methoden zum Erstellen des Abfrageobjekts.

3.4. Datenserialisierung

Um die Serialisierung und Deserialisierung der Daten zu verwalten, bietet GemFire ​​andere Optionen als die Java-Serialisierung, die eine höhere Leistung bieten, eine größere Flexibilität bei der Datenspeicherung und Datenübertragung bieten und auch verschiedene Sprachen unterstützen.

Aus diesem Grund hat GemFire ​​das PDX-Datenformat (Portable Data eXchange) definiert. PDX ist ein sprachübergreifendes Datenformat, das eine schnellere Serialisierung und Deserialisierung ermöglicht, indem die Daten in dem benannten Feld gespeichert werden, auf das direkt zugegriffen werden kann, ohne dass das Objekt vollständig deserialisiert werden muss.

3.5. Funktionsausführung

In GemFire ​​kann sich eine Funktion auf einem Server befinden und von einer Clientanwendung oder einem anderen Server aufgerufen werden, ohne dass der Funktionscode selbst gesendet werden muss.

Der Anrufer kann eine datenabhängige Funktion anweisen, einen bestimmten Datensatz zu bearbeiten, oder eine unabhängige Datenfunktion veranlassen, auf einem bestimmten Server, Mitglied oder einer bestimmten Mitgliedergruppe zu arbeiten.

3.6. Kontinuierliche Abfrage

Bei kontinuierlicher Abfrage abonnieren die Clients serverseitige Ereignisse mithilfe der SQL-Abfragefilterung. Der Server sendet alle Ereignisse, die die Abfrageergebnisse ändern. Die kontinuierliche Abfrage von Ereignisereignissen verwendet das Client / Server-Abonnement-Framework.

Die Syntax für eine fortlaufende Abfrage ähnelt den in OQL geschriebenen grundlegenden Abfragen. Eine Abfrage, die die neuesten Bestandsdaten aus der Bestandsregion bereitstellt, kann beispielsweise wie folgt geschrieben werden:

SELECT * from StockRegion s where s.stockStatus='active';

Um die Statusaktualisierung dieser Abfrage zu erhalten, muss eine Implementierung von CQListener an die StockRegion angehängt werden:

   ...  ...  ...   

4. Spring Data GemFire-Unterstützung

4.1. Java-Konfiguration

Um die Konfiguration zu vereinfachen, bietet Spring Data GemFire ​​verschiedene Anmerkungen zum Konfigurieren der GemFire-Kernkomponenten:

@Configuration public class GemfireConfiguration { @Bean Properties gemfireProperties() { Properties gemfireProperties = new Properties(); gemfireProperties.setProperty("name","SpringDataGemFireApplication"); gemfireProperties.setProperty("mcast-port", "0"); gemfireProperties.setProperty("log-level", "config"); return gemfireProperties; } @Bean CacheFactoryBean gemfireCache() { CacheFactoryBean gemfireCache = new CacheFactoryBean(); gemfireCache.setClose(true); gemfireCache.setProperties(gemfireProperties()); return gemfireCache; } @Bean(name="employee") LocalRegionFactoryBean getEmployee(final GemFireCache cache) { LocalRegionFactoryBean employeeRegion = new LocalRegionFactoryBean(); employeeRegion.setCache(cache); employeeRegion.setName("employee"); // ... return employeeRegion; } }

Um den GemFire-Cache und die Region einzurichten, müssen zunächst einige spezifische Eigenschaften eingerichtet werden. Hier wird mcast-port auf Null gesetzt, was darauf hinweist, dass dieser GemFire-Knoten für die Multicast-Erkennung und -Verteilung deaktiviert ist. Diese Eigenschaften werden dann an CacheFactoryBean übergeben , um eine GemFireCache- Instanz zu erstellen .

Mit der GemFireCache- Bean wird eine Instanz von LocalRegionFatcoryBean erstellt, die die Region im Cache für die Employee- Instanzen darstellt.

4.2. Entitätszuordnung

Die Bibliothek bietet Unterstützung für die Zuordnung von Objekten, die im GemFire-Raster gespeichert werden sollen. Die Zuordnungsmetadaten werden mithilfe von Anmerkungen in den Domänenklassen definiert:

@Region("employee") public class Employee { @Id public String name; public double salary; @PersistenceConstructor public Employee(String name, double salary) { this.name = name; this.salary = salary; } // standard getters/setters }

Im obigen Beispiel haben wir die folgenden Anmerkungen verwendet:

  • @ Region , um die Regionsinstanz der Employee- Klasse anzugeben
  • @Id, um die Eigenschaft zu kommentieren, die als Cache-Schlüssel verwendet werden soll
  • @PersistenceConstructor , mit dessen Hilfe der eine Konstruktor markiert werden kann, der zum Erstellen von Entitäten verwendet wird, falls mehrere Konstruktoren verfügbar sind

4.3. GemFire-Repositorys

Schauen wir uns als nächstes eine zentrale Komponente in Spring Data an - das Repository:

@Configuration @EnableGemfireRepositories(basePackages = "com.baeldung.spring.data.gemfire.repository") public class GemfireConfiguration { @Autowired EmployeeRepository employeeRepository; // ... }

4.4. Oql Query Support

Die Repositorys ermöglichen die Definition von Abfragemethoden, um die OQL-Abfragen effizient für die Region auszuführen, der die verwaltete Entität zugeordnet ist:

@Repository public interface EmployeeRepository extends CrudRepository { Employee findByName(String name); Iterable findBySalaryGreaterThan(double salary); Iterable findBySalaryLessThan(double salary); Iterable findBySalaryGreaterThanAndSalaryLessThan(double salary1, double salary2); }

4.5. Unterstützung für die Funktionsausführung

Wir bieten auch Unterstützung für Anmerkungen an, um die Arbeit mit der Ausführung von GemFire-Funktionen zu vereinfachen.

Bei der Verwendung von Funktionen sind zwei Probleme zu berücksichtigen: die Implementierung und die Ausführung.

Mal sehen, wie ein POJO mithilfe von Spring Data-Annotationen als GemFire-Funktion verfügbar gemacht werden kann:

@Component public class FunctionImpl { @GemfireFunction public void greeting(String message){ // some logic } // ... }

Wir müssen die Annotationsverarbeitung explizit aktivieren, damit @GemfireFunction funktioniert:

@Configuration @EnableGemfireFunctions public class GemfireConfiguration { // ... }

Für die Funktionsausführung muss ein Prozess, der eine Remote-Funktion aufruft, aufrufende Argumente, eine Funktions- ID und das Ausführungsziel ( onServer , onRegion , onMember usw.) bereitstellen :

@OnRegion(region="employee") public interface FunctionExecution { @FunctionId("greeting") public void execute(String message); // ... }

Um die Verarbeitung von Funktionsausführungsanmerkungen zu aktivieren, müssen wir hinzufügen, um sie mithilfe der Komponenten-Scanfunktionen von Spring zu aktivieren:

@Configuration @EnableGemfireFunctionExecutions( basePackages = "com.baeldung.spring.data.gemfire.function") public class GemfireConfiguration { // ... }

5. Schlussfolgerung

In diesem Artikel haben wir die wesentlichen Funktionen von GemFire ​​untersucht und untersucht, wie die von Spring Data bereitgestellten APIs die Arbeit damit vereinfachen.

Der vollständige Code für diesen Artikel ist auf GitHub verfügbar.