TOC

Eine Anleitung zu GemFire ​​mit Spring Data

Ein Leitfaden für GemFire ​​mit Frühlingsdaten

1. Überblick

GemFire ist eine hochleistungsfähige verteilte Datenverwaltungsinfrastruktur, die sich zwischen Anwendungscluster und Back-End-Datenquellen befindet.

Mit GemFire ​​können Daten im Arbeitsspeicher verwaltet werden, was den Zugriff beschleunigt. Spring Data provides an easy configuration and access to GemFire from Spring application.

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 folgenden Abhängigkeiten in unserepom.xml: einfügen 


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

Die neueste Version dieser Abhängigkeit befindet sich inhere.

3. GemFire-Grundfunktionen

3.1. Zwischenspeicher

Der Cache in GemFire ​​stellt die wesentlichen Datenverwaltungsdienste bereit und verwaltet 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 in einem Cache für einen einzelnen Datensatz.

Einfach ausgedrückt,a region lets us store data in multiple VMs in the system ohne Berücksichtigung, auf welchem ​​Knoten die Daten im Cluster gespeichert sind.

Regionen werden in drei große Kategorien eingeteilt:

  • Replicated 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:

  • Partitioned 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.

  • Local region befindet sich auf dem definierenden Mitgliedsknoten. Es besteht keine Konnektivität mit 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-Datenbereichen 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

QueryServicevon GemFire ​​bietet Methoden zum Erstellen des Abfrageobjekts.

3.4. Datenserialisierung

Zur Verwaltung der Serialisierung und Deserialisierung von Daten bietet GemFire ​​andere Optionen als die Java-Serialisierung, die eine höhere Leistung, größere Flexibilität bei der Speicherung und Übertragung von Daten sowie Unterstützung für verschiedene Sprachen bieten.

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 im 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 Client-Anwendung oder einem anderen Server aus aufgerufen werden, ohne dass der Funktionscode selbst gesendet werden muss.

Der Aufrufer kann eine datenabhängige Funktion anweisen, mit einem bestimmten Datensatz zu arbeiten, oder eine unabhängige Datenfunktion anweisen, mit 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 fortlaufende Abfrage der Ereigniszustellung verwendet das Client / Server-Abonnement-Framework.

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

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

Um die Statusaktualisierung aus dieser Abfrage zu erhalten, muss eine Implementierung vonCQListener mitStockRegion: angehängt werden 


    
            ...
            
                ...
            
        ...

4. Spring Data GemFire-Unterstützung

4.1. Java-Konfiguration

Zur Vereinfachung der Konfiguration bietet Spring Data GemFire ​​verschiedene Anmerkungen zur Konfiguration 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 GemFire-Region einzurichten, müssen zunächst einige bestimmte Eigenschaften eingerichtet werden. Hier wirdmcast-port auf Null gesetzt, was anzeigt, dass dieser GemFire-Knoten für die Multicast-Erkennung und -Verteilung deaktiviert ist. Diese Eigenschaften werden dann anCacheFactoryBean übergeben, um eineGemFireCache-Instanz zu erstellen.

MitGemFireCache Bean wird eine Instanz vonLocalRegionFatcoryBean erstellt, die den Bereich innerhalb des Caches für dieEmployee Instanzen darstellt.

4.2. Mandantenzuordnung

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 KlasseEmployee 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.example.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 für den Bereich effizient auszuführen, dem 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 der GemFire-Funktion zu vereinfachen.

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

Lassen Sie uns 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 Funktionid, 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 Spring-Komponenten-Scanfunktionen zu aktivieren: 

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

5. Fazit

In diesem Artikel haben wir uns mit den wichtigsten Funktionen von GemFire ​​befasst und untersucht, wie die von Spring Data bereitgestellten APIs die Arbeit damit vereinfachen.

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

Related