[JAVA] Introduction à Spring Boot + In-Memory Data Grid
Après avoir étudié la grille de données en mémoire, je me demandais ce qui se passerait si je l'incorporais réellement dans l'application, alors j'ai essayé de commencer.
Qu'est-ce qu'une grille de données en mémoire?
- Un mécanisme de gestion distribuée des données sur plusieurs serveurs.
- Si tous les serveurs peuvent avoir des données en double (méthode de réplication), la fiabilité flexible des données peut être assurée en gérant les données en double requises uniquement pour un certain groupe de serveurs au sein de ce groupe (méthode de partition). Pouvez.
- Puisque les E / S de disque ne se produisent pas comme DB, vous pouvez effectuer l'opération CRUD des données et la synchronisation des données du P2P à grande vitesse.
- Architecture fiable et rapide. Il semble.
Apprenez en vous référant à l'article suivant
Créons une application avec SpringBoot + Apach GEODE
Comme je voulais le faire après avoir zappé divers articles, il existe un projet appelé SpringDataGeode dans le référentiel git de Spring, je vais donc essayer d'expérimenter la grille de données en mémoire avec Spring Boot en l'utilisant.
-
Créé en supposant une application serveur qui effectue l'enregistrement et la recherche d'utilisateurs.
Créer une application avec le modèle client / serveur d'Apache GEODE
-Créez un modèle pour les applications client et serveur avec Spring Initializer.
--Sélectionnez uniquement Web et lombok.
--Cette fois, créez un projet avec gradle.
Créer une application côté client
--Ajout de spring-data-geode à la dépendance de build.gradle.
build.gradle
dependencies {
implementation('org.springframework.boot:spring-boot-starter-web'){
//la bibliothèque log4j est le printemps-data-Exclus car il entre en conflit avec la bibliothèque log4j dépendante de la géode
exclude group: 'org.springframework.boot', module:'spring-boot-starter-logging'
}
//Ajouter un projet qui gère le modèle de domaine en tant que dépendance
compile project(':geodeCommon')
compileOnly('org.projectlombok:lombok')
compile(group: 'org.springframework.data', name: 'spring-data-geode', version: '2.1.3.RELEASE')
}
--Code de classe de démarrage
GeodeClientApplication.java
package spring.geode.client.geodeClient;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.gemfire.config.annotation.ClientCacheApplication;
import org.springframework.data.gemfire.config.annotation.EnableEntityDefinedRegions;
import org.springframework.data.gemfire.config.annotation.EnablePdx;
import org.springframework.data.gemfire.repository.config.EnableGemfireRepositories;
import spring.geode.client.geodeClient.repository.UserRepository;
import spring.geode.geodeCommon.model.User;
@SpringBootApplication
@ClientCacheApplication(name = "SpringGeodeClientApplication") //①
@EnableGemfireRepositories(basePackageClasses = UserRepository.class) //②
@EnableEntityDefinedRegions(basePackageClasses = User.class) //③
@EnablePdx //④
public class GeodeClientApplication {
public static void main(String[] args) {
SpringApplication.run(GeodeClientApplication.class, args);
}
}
--Explication des annotations
--①: Paramètre pour démarrer en tant qu'application client dans ʻApache GEODE -②: Paramètre pour que la classe spécifiée fonctionne comme un accesseur de données de ʻApache GEODE
--③: Paramètre pour créer automatiquement la région spécifiée (tableau en RDB)
-④: Paramètres de sérialisation / désérialisation des données de ʻApache GEODE` (non requis)
- Classe de contrôleur
UserController.java
package spring.geode.client.geodeClient.controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import lombok.RequiredArgsConstructor;
import spring.geode.client.geodeClient.service.UserService;
import spring.geode.geodeCommon.model.User;
import spring.geode.geodeCommon.model.UserRequest;
@RestController
@RequiredArgsConstructor
public class UserController {
private final UserService userService;
//API de recherche d'utilisateurs par nom
@RequestMapping(path = "/find/user/{name}", method = RequestMethod.GET)
public User findById(@PathVariable String name) {
return userService.findByName(name);
}
//API de recherche de tous les utilisateurs
@RequestMapping("/findAll")
public List<User> findAll() {
return userService.findAll();
}
//Nouvelle API d'enregistrement d'utilisateur
@RequestMapping(path = "/register/user", method = RequestMethod.POST)
public String register(@RequestBody UserRequest request) {
return userService.register(request).getName();
}
}
- classe de service
UserService.java
package spring.geode.server.geodeServer.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
import spring.geode.geodeCommon.model.User;
import spring.geode.geodeCommon.model.UserRequest;
import spring.geode.server.geodeServer.repository.UserRepository;
@RequiredArgsConstructor
@Service
public class UserService {
private final UserRepository rep;
public User findByName(String name) {
User user=rep.findByName(name).get(0);
return user;
}
public User register(UserRequest request) {
User commited = rep.save(new User(request));
return commited;
}
public List<User> findAll(){
List<User> users=new ArrayList<>();
rep.findAll().forEach(user -> users.add(user));;
return users;
}
}
Classe de référentiel
UserRepository.java
package spring.geode.server.geodeServer.repository;
import java.util.List;
import org.springframework.data.gemfire.repository.GemfireRepository;
import spring.geode.geodeCommon.model.User;
public interface UserRepository extends GemfireRepository<User, Integer> {
List<User> findByName(String name);
}
- fichier de réglage
application.properties
spring.data.gemfire.pool.locators=localhost[40404]
server.port=9000
client Définissez l'adresse IP et le port du localisateur auquel l'application se connecte.
Cette fois, spécifiez localhost pour démarrer le localisateur avec les paramètres de l'application serveur.
«La relation entre le client, le serveur et le localisateur dans Apache GEODE» est décrite dans l'article suivant. Présentation d'Apache GEODE
À ce stade, l'application cliente a été implémentée. Puisqu'il est nécessaire d'utiliser une classe commune pour les projets client et serveur, les objets de données (classe utilisateur) à gérer seront regroupés dans le projet commun et créés ultérieurement.
Créer une application côté serveur
À l'exception de la classe de démarrage, vous pouvez importer le code d'application client tel quel dans le projet d'application serveur.
- Classe de démarrage
GeodeServerApplication.java
package spring.geode.server.geodeServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.gemfire.config.annotation.CacheServerApplication;
import org.springframework.data.gemfire.config.annotation.EnableEntityDefinedRegions;
import org.springframework.data.gemfire.config.annotation.EnableLocator;
import org.springframework.data.gemfire.config.annotation.EnableManager;
import org.springframework.data.gemfire.config.annotation.EnablePdx;
import org.springframework.data.gemfire.repository.config.EnableGemfireRepositories;
import spring.geode.geodeCommon.model.User;
import spring.geode.server.geodeServer.repository.UserRepository;
@SpringBootApplication
@CacheServerApplication(locators = "localhost[40404]") //①
@EnableGemfireRepositories(basePackageClasses = UserRepository.class)
@EnableEntityDefinedRegions(basePackageClasses = User.class)
@EnablePdx
public class GeodeServerApplication {
public static void main(String[] args) {
SpringApplication.run(GeodeServerApplication.class, args);
}
@Configuration
@EnableLocator(port = 40404) //②
@EnableManager(start = true) //③
static class LocatorManagerConfiguration {
}
}
--Explication des annotations
--①: ʻParamétrage pour démarrer en tant qu'application serveur dans Apache GEODE. Définissez le localisateur de connexion sur le port 40404 de localhost`.
--②: Paramètre pour démarrer le localisateur sur le port 40404
--③: Paramètre pour démarrer le service qui surveille l'application client / serveur
À ce stade, l'application serveur a été implémentée.
Créer un modèle de données
- Modèle de demande du client dans l'application Web (différent du client dans ʻApache GEODE`)
UserRequest.java
package spring.geode.geodeCommon.model;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserRequest implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int age;
}
--ʻLe modèle de domaine a persisté dans Apache GEODE`
User.java
package spring.geode.geodeCommon.model;
import java.io.Serializable;
import java.util.UUID;
import org.springframework.data.gemfire.mapping.annotation.Region;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Region("Users") //①
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
private String name;
private int age;
public User(UserRequest request) {
this.name=request.getName();
this.age=request.getAge();
this.id=UUID.randomUUID().hashCode();
}
}
--Explication des annotations --①: définissez la région à laquelle ce modèle est associé.
- Puisque le projet qui implémente le modèle de données dépend du projet des applications client et serveur, le contenu suivant est décrit dans
settings.gradledes applications client et serveur.
settings.gradle
//geodeCommon doit être lu comme le nom du projet que vous avez créé
include ':geodeCommon'
project(':geodeCommon').projectDir = new File('../geodeCommon')
À ce stade, la mise en œuvre du modèle de données est terminée.
Essayez de commencer
Étant donné que l'application cliente se connecte au localisateur au démarrage, il est nécessaire de démarrer d'abord l'application serveur.
--Démarrez l'application serveur (Tomacat intégré commence par le numéro de port 9090)
--client application start (Tomcat intégré commence par le numéro de port 9000)
Si les deux applications peuvent être démarrées normalement, le client, le localisateur et le serveur doivent être connectés.
Essayez d'enregistrer l'utilisateur avec l'application client
curl -H "Content-Type: application/json" -X POST -d '{"name":"John","age":23}' http://localhost:9000/register/user/;
curl -H "Content-Type: application/json" -X POST -d '{"name":"Bob","age":10}' http://localhost:9000/register/user/;
Essayez de rechercher un utilisateur à partir de l'application serveur
curl -i http://localhost:9090/findAll
C'est OK si l'utilisateur enregistré dans l'application cliente peut être recherché dans les résultats de la recherche
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Transfer-Encoding: chunked
Date: Sat, 26 Jan 2019 17:10:37 GMT
[{"id":-1174841827,"name":"Bob","age":10},{"id":-516984913,"name":"John","age":23}]
Juste au cas où, recherchez également en spécifiant le nom
curl -i http://localhost:9090/find/user/John;
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Transfer-Encoding: chunked
Date: Sat, 26 Jan 2019 17:12:33 GMT
{"id":-516984913,"name":"John","age":23}
J'ai pu confirmer que les données étaient synchronisées sur le client et le serveur. Je l'ai implémenté en référence au document officiel suivant. https://geode.apache.org/docs/
À l'avenir, j'essaierai de créer des applications avec le modèle homologue, la configuration des applications sur AWS, la persistance asynchrone, etc.
Recommended Posts