Een gids voor GemFire ​​met Spring Data

1. Overzicht

GemFire ​​is een hoogwaardige infrastructuur voor gedistribueerd gegevensbeheer die zich tussen toepassingsclusters en back-endgegevensbronnen bevindt.

Met GemFire ​​kunnen gegevens in het geheugen worden beheerd, wat de toegang sneller maakt. Spring Data biedt een eenvoudige configuratie en toegang tot GemFire ​​vanuit de Spring-applicatie.

In dit artikel zullen we bekijken hoe we GemFire ​​kunnen gebruiken om te voldoen aan de cachevereisten van onze applicatie.

2. Maven afhankelijkheden

Om gebruik te kunnen maken van de Spring Data GemFire-ondersteuning, moeten we eerst de volgende afhankelijkheid toevoegen aan onze pom.xml:

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

De laatste versie van deze afhankelijkheid is hier te vinden.

3. GemFire ​​basisfuncties

3.1. Cache

De cache in de GemFire ​​biedt de essentiële gegevensbeheerdiensten en beheert de connectiviteit met andere peers.

De cacheconfiguratie (cache.xml) beschrijft hoe de gegevens over verschillende knooppunten worden verdeeld:

     ...     ... 

3.2. Regio's

Datagebieden zijn een logische groepering binnen een cache voor een enkele dataset.

Simpel gezegd, een regio stelt ons in staat gegevens op meerdere VM's in het systeem op te slaan zonder rekening te houden met welk knooppunt de gegevens in het cluster zijn opgeslagen.

Regio's zijn ingedeeld in drie brede categorieën:

  • Gerepliceerde regio bevat de volledige set gegevens op elk knooppunt. Het geeft een hoge leesprestatie. Schrijfbewerkingen zijn langzamer omdat de gegevensupdate moet worden doorgegeven aan elk knooppunt:
  • Gepartitioneerde regio verdeelt de gegevens zodat elk knooppunt slechts een deel van de regio-inhoud opslaat. Een kopie van de gegevens wordt opgeslagen op een van de andere knooppunten. Het biedt goede schrijfprestaties.
  • Lokale regio bevindt zich op het definiërende lidknooppunt. Er is geen connectiviteit met andere knooppunten binnen het cluster.

3.3. Vraag de cache

GemFire ​​biedt een querytaal genaamd OQL (Object Query Language) waarmee we kunnen verwijzen naar de objecten die zijn opgeslagen in GemFire-gegevensregio's. Dit lijkt qua syntaxis sterk op SQL. Laten we eens kijken hoe een heel eenvoudige zoekopdracht eruit ziet:

SELECTEER DISTINCT * UIT exampleRegion

GemFire's QueryService biedt methoden om het query-object te maken.

3.4. Serialisatie van gegevens

Om de data-serialisering-deserialisatie te beheren, biedt GemFire ​​andere opties dan Java-serialisering die hogere prestaties biedt, meer flexibiliteit biedt voor data-opslag en data-overdracht, en ook ondersteuning voor verschillende talen.

Met dat in gedachten heeft GemFire ​​het gegevensformaat Portable Data eXchange (PDX) gedefinieerd. PDX is een meertalige gegevensindeling die een snellere serialisering en deserialisatie biedt door de gegevens op te slaan in het genoemde veld dat direct toegankelijk is zonder dat het object volledig gedeserialiseerd hoeft te worden.

3.5. Functie-uitvoering

In GemFire ​​kan een functie zich op een server bevinden en kan worden aangeroepen vanaf een clienttoepassing of een andere server zonder dat de functiecode zelf hoeft te worden verzonden.

De beller kan een data-afhankelijke functie laten werken op een bepaalde dataset of kan een onafhankelijke datafunctie laten werken op een bepaalde server, lid of ledengroep.

3.6. Continu zoeken

Bij continue query's abonneren de clients zich op gebeurtenissen aan de serverzijde door gebruik te maken van SQL-type queryfiltering. De server verzendt alle gebeurtenissen die de queryresultaten wijzigen. De continue levering van querygebeurtenissen maakt gebruik van het client / server-abonnementsraamwerk.

De syntaxis voor een continue query is vergelijkbaar met standaardquery's die in OQL zijn geschreven. Bijvoorbeeld een query die de laatste voorraadgegevens van Voorraad regio kan worden geschreven als:

SELECTEER * van StockRegion s waarbij s.stockStatus = 'active';

Om de statusupdate van deze query te krijgen, is een implementatie van CQListener moeten worden bevestigd met de Voorraadregio:

   ...  ...  ...   

4. Spring Data GemFire-ondersteuning

4.1. Java-configuratie

Om de configuratie te vereenvoudigen, biedt Spring Data GemFire ​​verschillende annotaties voor het configureren van de belangrijkste GemFire-componenten:

@Configuration openbare klasse GemfireConfiguration {@Bean Properties gemfireProperties () {Properties gemfireProperties = new Properties (); gemfireProperties.setProperty ("naam", "SpringDataGemFireApplication"); gemfireProperties.setProperty ("mcast-port", "0"); gemfireProperties.setProperty ("log-level", "config"); terug gemfireProperties; } @Bean CacheFactoryBean gemfireCache () {CacheFactoryBean gemfireCache = nieuwe CacheFactoryBean (); gemfireCache.setClose (true); gemfireCache.setProperties (gemfireProperties ()); retourneer gemfireCache; } @Bean (naam = "werknemer") LocalRegionFactoryBean getEmployee (laatste GemFireCache-cache) {LocalRegionFactoryBean employeeRegion = nieuwe LocalRegionFactoryBean (); employeeRegion.setCache (cache); employeeRegion.setName ("werknemer"); // ... terugkeer employeeRegion; }}

Om de GemFire-cache en -regio in te stellen, moeten we eerst enkele specifieke eigenschappen instellen. Hier mcast-poort is ingesteld op nul, wat aangeeft dat dit GemFire-knooppunt is uitgeschakeld voor multicast-detectie en distributie. Deze eigenschappen worden vervolgens doorgegeven aan CacheFactoryBean om een GemFireCache voorbeeld.

Gebruik makend van GemFireCache bean, een instantie van LocalRegionFatcoryBean wordt gemaakt die de regio binnen de cache voor het Werknemer gevallen.

4.2. Entiteitstoewijzing

De bibliotheek biedt ondersteuning voor het in kaart brengen van objecten die in het GemFire-raster moeten worden opgeslagen. De metagegevens van de toewijzing worden gedefinieerd door annotaties te gebruiken bij de domeinklassen:

@Region ("werknemer") openbare klasse Werknemer {@Id openbare tekenreeksnaam; publiek dubbel salaris; @PersistenceConstructor openbare werknemer (String naam, dubbel salaris) {this.name = naam; this.salary = salaris; } // standaard getters / setters}

In het bovenstaande voorbeeld hebben we de volgende annotaties gebruikt:

  • @Regio, om de regio-instantie van het Werknemer klasse
  • @ID kaart, om de eigenschap te annoteren die zal worden gebruikt als een cachesleutel
  • @BuienRadarNL, wat helpt om de enige constructor te markeren die zal worden gebruikt om entiteiten te maken, voor het geval er meerdere constructors beschikbaar zijn

4.3. GemFire-opslagplaatsen

Laten we vervolgens eens kijken naar een centraal onderdeel in Spring Data - de repository:

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

4.4. Oql Query-ondersteuning

Met de repositories kunnen querymethoden worden gedefinieerd om de OQL-query's efficiënt uit te voeren op de regio waaraan de beheerde entiteit is toegewezen:

@Repository openbare interface EmployeeRepository breidt CrudRepository uit {Employee findByName (String naam); Iterable findBySalaryGreaterThan (dubbel salaris); Iterable findBySalaryLessThan (dubbel salaris); Iterable findBySalaryGreaterThanAndSalaryLessThan (dubbel salaris1, dubbel salaris2); }

4.5. Ondersteuning voor functie-uitvoering

We hebben ook ondersteuning voor annotaties om het werken met GemFire-functie-uitvoering te vereenvoudigen.

Er zijn twee zorgen die we moeten aanpakken wanneer we gebruik maken van functies: de implementatie en de uitvoering.

Laten we eens kijken hoe een POJO kan worden weergegeven als een GemFire-functie met behulp van Spring Data-annotaties:

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

We moeten de annotatieverwerking expliciet activeren voor @GemfireFunction werken:

@Configuration @EnableGemfireFunctions openbare klasse GemfireConfiguration {// ...}

Voor het uitvoeren van een functie moet een proces dat een externe functie aanroept, aanroepende argumenten, een functie, leveren ID kaart, het executiedoel (onServer, onRegion, opMember, enz.):

@OnRegion (regio = "werknemer") openbare interface FunctionExecution {@FunctionId ("groet") openbare ongeldige uitvoering (String-bericht); // ...}

Om de annotatieverwerking van de functie-uitvoering mogelijk te maken, moeten we deze toevoegen om deze te activeren met de mogelijkheden voor het scannen van componenten van Spring:

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

5. Conclusie

In dit artikel hebben we de essentiële functies van GemFire ​​verkend en onderzocht hoe de door Spring Data geleverde API's het gemakkelijk maken om ermee te werken.

De volledige code voor dit artikel is beschikbaar op GitHub.