La dernière fois, j'ai utilisé SpringDataGeode pour créer une application SpringBoot qui utilise une grille de données en mémoire, et je l'ai implémentée afin que le traitement des événements puisse être effectué lorsque les données sont synchronisées avec le serveur.
Création d'une application à l'aide de SpringDataGeode
Implémentation du traitement des événements à l'aide de SpringDataGeode
Cette fois, en utilisant la fonction de Spring Data Geode, nous conserverons les données enregistrées dans le cache en mémoire sur le disque local, et lorsque le serveur d'applications intégré au cache démarrera, nous chargerons le fichier de persistance et enregistrerons les données dans le cache. ..
Après enquête, il semble que cela puisse être réalisé simplement en ajoutant une annotation.
--Ajoutez l'annotation suivante à SpringBootApplication.
ServerGeodeApplication.java
package spring.geode.server.geodeServer;
import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.Region;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.gemfire.ReplicatedRegionFactoryBean;
import org.springframework.data.gemfire.config.annotation.EnableDiskStore;
import org.springframework.data.gemfire.config.annotation.EnableDiskStore.DiskDirectory;
import org.springframework.data.gemfire.config.annotation.EnableLocator;
import org.springframework.data.gemfire.config.annotation.EnableManager;
import org.springframework.data.gemfire.config.annotation.PeerCacheApplication;
import org.springframework.data.gemfire.repository.config.EnableGemfireRepositories;
import spring.geode.geodeCommon.model.User;
import spring.geode.geodeCommon.region.UserRegion;
import spring.geode.server.geodeServer.repository.UserRepository;
@SpringBootApplication
@PeerCacheApplication(name = "SpringGeodeServerApplication", locators = "localhost[40404]")
@EnableGemfireRepositories(basePackageClasses = UserRepository.class)
//Annotation de persistance des données ajoutée cette fois
@EnableDiskStore(
name="SimpleDiskStore",
autoCompact=true,
diskDirectories = @DiskDirectory(location="/hoge/fuga/SpringGeodeData")
)
public class GeodeServerApplication {
public static void main(String[] args) {
SpringApplication.run(GeodeServerApplication.class, args);
}
@Configuration
@EnableLocator(port = 40404)
@EnableManager(start = true)
static class LocatorManagerConfiguration {
}
@Configuration
static class CacheInitializer {
@Bean
Region<Integer, User> userRegion(final GemFireCache cache) {
return new UserRegion().createUserRegion(cache);
}
@Bean
public ReplicatedRegionFactoryBean<Integer, User> replicatedRegion(GemFireCache cache) {
return new UserRegion().createUserRegionFactory(cache);
}
}
}
En activant @ EnableDiskStore, le fichier de persistance sera craché à l'emplacement du chemin absolu spécifié par diskDirectories.
Pour une raison quelconque, le fichier n'a pas été généré. .. J'ai essayé de trouver un moyen de le résoudre avec des annotations, mais cela n'a pas fonctionné. ..
Je ne pouvais pas m'en empêcher, alors j'ai décidé de le régler directement sur Bean. ..
UserRegion.java
package spring.geode.geodeCommon.region;
import java.io.File;
import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.Region;
import org.springframework.data.gemfire.ReplicatedRegionFactoryBean;
import spring.geode.geodeCommon.listener.UserRegionListener;
import spring.geode.geodeCommon.model.User;
/**
*Gérer les utilisateurs{@link Region}Créer des paramètres pour
*
*/
public class UserRegion {
/**
* {@link Region}Créer
* @param cache
* @return
*/
public Region<Integer, User> createUserRegion(final GemFireCache cache) {
return cache.<Integer, User>getRegion("Users");
}
/**
* {@link Region}Définissez les paramètres pour
* @param cache
* @return
*/
public ReplicatedRegionFactoryBean<Integer, User> createUserRegionFactory(GemFireCache cache) {
ReplicatedRegionFactoryBean<Integer, User> replicatedRegionFactory = new ReplicatedRegionFactoryBean<>();
UserRegionListener[] listeners = { new UserRegionListener() };
listeners[0] = new UserRegionListener();
replicatedRegionFactory.setCacheListeners(listeners);
replicatedRegionFactory.setClose(false);
replicatedRegionFactory.setCache(cache);
replicatedRegionFactory.setRegionName("Users");
replicatedRegionFactory.setPersistent(true);
return replicatedRegionFactory;
}
/**
* {@link Region}Définir la persistance des fichiers pour
* @param cache
* @param regionFactory
* @return
*/
public ReplicatedRegionFactoryBean<Integer, User> configDiskStore(GemFireCache cache,
ReplicatedRegionFactoryBean<Integer, User> regionFactory) {
File[] files = { new File("/hoge/fuga/SpringGeode/persistenceFile") };
cache.createDiskStoreFactory()//
.setAllowForceCompaction(true)//
.setAutoCompact(true)//
.setDiskDirs(files)//
.create("SimpleDiskStore");
regionFactory.setDiskStoreName("SimpleDiskStore");
return regionFactory;
}
}
Le paramètre de persistance est effectué par la méthode configDiskStore.
Un DiskStore est créé dans Cache, et les paramètres liés aux diverses méthodes de persistance et aux chemins de fichiers de persistance sont définis.
En appelant cette méthode dans l'application et en enregistrant le bean, la persistance est enfin terminée.
GeodeServerApplication.java
package spring.geode.server.geodeServer;
import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.Region;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.gemfire.ReplicatedRegionFactoryBean;
import org.springframework.data.gemfire.config.annotation.EnableLocator;
import org.springframework.data.gemfire.config.annotation.EnableManager;
import org.springframework.data.gemfire.config.annotation.PeerCacheApplication;
import org.springframework.data.gemfire.repository.config.EnableGemfireRepositories;
import spring.geode.geodeCommon.model.User;
import spring.geode.geodeCommon.region.UserRegion;
import spring.geode.server.geodeServer.repository.UserRepository;
@SpringBootApplication
@PeerCacheApplication(name = "SpringGeodeServerApplication", locators = "localhost[40404]")
@EnableGemfireRepositories(basePackageClasses = UserRepository.class)
public class GeodeServerApplication {
public static void main(String[] args) {
SpringApplication.run(GeodeServerApplication.class, args);
}
@Configuration
@EnableLocator(port = 40404)
@EnableManager(start = true)
static class LocatorManagerConfiguration {
}
@Configuration
static class CacheInitializer {
@Bean
Region<Integer, User> userRegion(final GemFireCache cache) {
return new UserRegion().createUserRegion(cache);
}
@Bean
public ReplicatedRegionFactoryBean<Integer, User> replicatedRegion(GemFireCache cache) {
UserRegion region = new UserRegion();
return region.configDiskStore(cache, region.createUserRegionFactory(cache));
}
}
}
Avec cela, vous pouvez définir le paramètre de persistance pour chaque région, et lorsque vous démarrez l'application, vous pouvez charger les données du jeu de fichiers dans DiskStore et les enregistrer dans le cache.
Je voulais l'implémenter rapidement avec des annotations, mais je regrette que cela n'ait pas fonctionné. .. Ne devrais-je pas personnaliser moi-même le ReplicatedRegionFactoryBean? ..
Quoi qu'il en soit, c'est bien car cela peut être rendu permanent.
Je serais heureux si je pouvais définir RDB comme cible de persistance, mais je ne pouvais pas obtenir les informations que SpringDataGeode fournirait une telle fonction, j'ai donc utilisé la fonction de persistance de fichier une fois pour la rendre persistante. Vu.
Recommended Posts