TOC

Guide sur GemFire ​​avec les données de printemps

Guide de GemFire ​​avec Spring Data

1. Vue d'ensemble

GemFire est une infrastructure de gestion de données distribuée hautes performances qui se situe entre le cluster d'applications et les sources de données principales.

Avec GemFire, les données peuvent être gérées en mémoire, ce qui rend l’accès plus rapide. Spring Data provides an easy configuration and access to GemFire from Spring application.

Dans cet article, nous allons voir comment nous pouvons utiliser GemFire ​​pour répondre aux exigences de mise en cache de notre application.

2. Dépendances Maven

Pour utiliser le support Spring Data GemFire, nous devons d'abord ajouter la dépendance suivante dans nospom.xml: 


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

La dernière version de cette dépendance peut être trouvéehere.

3. Fonctionnalités de base de GemFire

3.1. Cache

Le cache dans GemFire ​​fournit les services de gestion de données essentiels ainsi que la connectivité à d'autres homologues.

La configuration du cache (cache.xml) décrit comment les données seront réparties entre les différents nœuds: 


    
        
            
                
                ...
                
            
        
    
    ...

3.2. Régions

Les régions de données constituent un regroupement logique au sein d'un cache pour un seul jeu de données.

En termes simples,a region lets us store data in multiple VMs in the system sans tenir compte du nœud sur lequel les données sont stockées dans le cluster.

Les régions sont classées en trois grandes catégories:

  • Replicated region contient l'ensemble complet de données sur chaque nœud. Cela donne une performance de lecture élevée. Les opérations d'écriture sont plus lentes car la mise à jour des données doit être propagée à chaque nœud:

  • Partitioned region distribue les données de sorte que chaque nœud ne stocke qu'une partie du contenu de la région. Une copie des données est stockée sur l'un des autres nœuds. Il fournit une bonne performance en écriture.

  • Local region réside sur le nœud de membre définissant. Il n'y a pas de connectivité avec les autres nœuds du cluster.

3.3. Interroger le cache

GemFire ​​fournit un langage de requête appelé OQL (Object Query Language) qui nous permet de faire référence aux objets stockés dans les régions de données GemFire. Ceci est très similaire à SQL dans la syntaxe. Voyons à quoi ressemble une requête très basique:

SELECT DISTINCT * FROM exampleRegion

LesQueryService de GemFire ​​fournissent des méthodes pour créer l'objet de requête.

3.4. Sérialisation des données

Pour gérer la sérialisation-désérialisation des données, GemFire ​​fournit des options autres que la sérialisation Java qui offre des performances plus élevées, une plus grande flexibilité pour le stockage et le transfert de données, ainsi que la prise en charge de différentes langues.

Dans cet esprit, GemFire ​​a défini le format de données Portable Data eXchange (PDX). PDX est un format de données multilingue qui permet une sérialisation et une désérialisation plus rapides en stockant les données dans le champ nommé auquel on peut accéder directement sans qu'il soit nécessaire de désérialiser complètement l'objet.

3.5. Exécution de la fonction

Dans GemFire, une fonction peut résider sur un serveur et peut être appelée à partir d'une application client ou d'un autre serveur sans qu'il soit nécessaire d'envoyer le code de fonction lui-même.

L'appelant peut diriger une fonction dépendant des données vers un ensemble de données particulier ou amener une fonction de données indépendante à fonctionner sur un serveur, un membre ou un groupe de membres particulier.

3.6. Requête continue

Avec une interrogation continue, les clients s'abonnent à des événements côté serveur à l'aide d'un filtrage de requête de type SQL. Le serveur envoie tous les événements qui modifient les résultats de la requête. La distribution d'événements par interrogation continue utilise la structure d'abonnement client / serveur.

La syntaxe d'une requête continue est similaire à celle des requêtes de base écrites en OQL. Par exemple, une requête qui fournit les dernières données boursières de la régionStock peut être écrite comme suit: 

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

Pour obtenir la mise à jour de l'état de cette requête, une implémentation deCQListener doit être attachée avec lesStockRegion: 


    
            ...
            
                ...
            
        ...

4. Prise en charge de Spring Data GemFire

4.1. Configuration Java

Pour simplifier la configuration, Spring Data GemFire ​​fournit diverses annotations permettant de configurer les principaux composants de GemFire: 

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

Pour configurer le cache et la région GemFire, nous devons d’abord configurer quelques propriétés spécifiques. Ici,mcast-port est mis à zéro, ce qui indique que ce nœud GemFire ​​est désactivé pour la découverte et la distribution multicast. Ces propriétés sont ensuite transmises àCacheFactoryBean pour créer une instanceGemFireCache.

En utilisant le beanGemFireCache, une instance deLocalRegionFatcoryBean est créée qui représente la région dans le cache pour les instancesEmployee.

4.2. Cartographie d'entité

La bibliothèque prend en charge les objets de carte à stocker dans la grille GemFire. Les métadonnées de mappage sont définies en utilisant des annotations au niveau des classes de domaine: 

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

Dans l'exemple ci-dessus, nous avons utilisé les annotations suivantes:

  • @*Region*, pour spécifier l'instance de région de la classeEmployee

  • @Id, pour annoter la propriété qui sera utilisée comme clé de cache

  • @PersistenceConstructor, qui permet de marquer le seul constructeur qui sera utilisé pour créer des entités, au cas où plusieurs constructeurs seraient disponibles

4.3. Dépôts GemFire

Ensuite, examinons un composant central de Spring Data - le référentiel: 

@Configuration
@EnableGemfireRepositories(basePackages
  = "com.example.spring.data.gemfire.repository")
public class GemfireConfiguration {

    @Autowired
    EmployeeRepository employeeRepository;

    // ...
}

4.4. Prise en charge des requêtes Oql

Les référentiels permettent à la définition de méthodes de requête d'exécuter efficacement les requêtes OQL sur la région vers laquelle l'entité gérée est mappée: 

@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. Prise en charge de l'exécution des fonctions

Nous avons également un support d'annotation disponible - pour simplifier l'utilisation de l'exécution de la fonction GemFire.

Il y a deux préoccupations à prendre en compte lorsque nous utilisons les fonctions, la mise en œuvre et l'exécution.

Voyons comment un POJO peut être exposé en tant que fonction GemFire ​​à l'aide des annotations Spring Data: 

@Component
public class FunctionImpl {

    @GemfireFunction
    public void greeting(String message){
        // some logic
    }

    // ...
}

Nous devons activer explicitement le traitement des annotations pour que@GemfireFunction fonctionne: 

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

Pour l'exécution d'une fonction, un processus appelant une fonction distante doit fournir des arguments d'appel, une fonctionid, la cible d'exécution (onServer,onRegion,onMember, etc.): 

@OnRegion(region="employee")
public interface FunctionExecution {

    @FunctionId("greeting")
    public void execute(String message);

    // ...
}

Pour activer le traitement des annotations d'exécution de la fonction, nous devons ajouter pour l'activer à l'aide des capacités d'analyse des composants de Spring: 

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

5. Conclusion

Dans cet article, nous avons exploré les fonctionnalités essentielles de GemFire ​​et examiné comment les API fournies par Spring Data facilitent son utilisation.

Le code complet de cet article est disponibleover on GitHub.

Related