[JAVA] Einführung in Spring Boot + In-Memory Data Grid

Nachdem ich das In-Memory-Datenraster studiert hatte, fragte ich mich, was passieren würde, wenn ich es tatsächlich in die App integrieren würde, also startete ich es.

Was ist ein In-Memory-Datenraster?

• Ein Mechanismus zur verteilten Verwaltung von Daten auf mehreren Servern.
• Wenn alle Server doppelte Daten haben können (Replikationsmethode), kann eine flexible Datenzuverlässigkeit sichergestellt werden, indem doppelte Daten verwaltet werden, die nur für eine bestimmte Gruppe von Servern innerhalb dieser Gruppe erforderlich sind (Partitionsmethode). Können.
• Da die Festplatten-E / A nicht wie bei der Datenbank auftritt, können Sie den CRUD-Betrieb von Daten und die Datensynchronisation von P2P mit hoher Geschwindigkeit ausführen.
• Zuverlässige und schnelle Architektur. Es scheint.

Weitere Informationen finden Sie im folgenden Artikel

• Empfohlen, um sich einen Überblick zu verschaffen
• Spezifischer Architekturtyp

Lassen Sie uns eine App mit SpringBoot + Apach GEODE erstellen

――Da ich es tatsächlich schaffen wollte, nachdem ich verschiedene Artikel gezappt hatte, gibt es ein Projekt namens "SpringDataGeode" im Git-Repository von Spring, daher werde ich versuchen, das speicherinterne Datenraster mit Spring Boot zu erleben.

• Erstellt unter der Annahme einer Serveranwendung, die die Benutzerregistrierung und -suche durchführt.

• Spring-Data-Geode-Projekt

Erstellen Sie eine App mit dem Client / Server-Modell von Apache GEODE

• Erstellen Sie mit Spring Initializer eine Vorlage für Client- und Server-Apps. --Wählen Sie nur Web und Lombok.
• Erstellen Sie dieses Mal ein Projekt mit "gradle".

Erstellen Sie eine clientseitige App

• Der Abhängigkeit von build.gradle wurde "spring-data-geode" hinzugefügt.

build.gradle

dependencies {
	implementation('org.springframework.boot:spring-boot-starter-web'){
      //Die log4j-Bibliothek ist Frühling-data-Ausgeschlossen, da dies mit der abhängigen log4j-Bibliothek der Geode in Konflikt steht
	  exclude group: 'org.springframework.boot', module:'spring-boot-starter-logging'
	}
    //Fügen Sie ein Projekt hinzu, das das Domänenmodell als Abhängigkeit behandelt
	compile project(':geodeCommon')
	compileOnly('org.projectlombok:lombok')
	compile(group: 'org.springframework.data', name: 'spring-data-geode', version: '2.1.3.RELEASE')
}

• Klassencode starten

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

}

• Erläuterung der Anmerkungen --①: Einstellung zum Starten als Client-Anwendung in Apache GEODE -②: Einstellung, damit die angegebene Klasse als Datenzugriff von Apache GEODE fungiert --③: Einstellung zum automatischen Erstellen der angegebenen Region (Tabelle in RDB) -④: Einstellungen für die Serialisierung / Deserialisierung von Daten, die von Apache GEODE verarbeitet werden (nicht erforderlich)

• Controller-Klasse

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;
    //Benutzersuch-API nach Namen
	@RequestMapping(path = "/find/user/{name}", method = RequestMethod.GET)
	public User findById(@PathVariable String name) {
		return userService.findByName(name);
	}
    //Benutzer alle Such-API
	@RequestMapping("/findAll")
    public List<User> findAll() {
        return userService.findAll();
    }
    //Neue Benutzerregistrierungs-API
	@RequestMapping(path = "/register/user", method = RequestMethod.POST)
	public String register(@RequestBody UserRequest request) {
		return userService.register(request).getName();
	}
}

• Serviceklasse

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

Repository-Klasse

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

• Einstellungsdatei

application.properties

spring.data.gemfire.pool.locators=localhost[40404]
server.port=9000

Client Legen Sie die IP und den Port des Locators fest, mit dem die Anwendung eine Verbindung herstellt. Geben Sie dieses Mal "localhost" an, um den Locator mit den Einstellungen der Serveranwendung zu starten.

Die Beziehung zwischen Client, Server und Locator in "Apache GEODE" wird im folgenden Artikel beschrieben. Übersicht über Apache GEODE

Zu diesem Zeitpunkt wurde die Client-Anwendung implementiert. Da für die Client- und Serverprojekte eine gemeinsame Klasse verwendet werden muss, werden die zu behandelnden Datenobjekte (Benutzerklasse) im Common-Projekt zusammengefasst und später erstellt.

Erstellen Sie eine serverseitige Anwendung

Mit Ausnahme der Startklasse können Sie den Clientanwendungscode so wie er ist in das Serveranwendungsprojekt einbringen.

• Startklasse

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

}

• Erläuterung der Anmerkungen --①: Einstellung zum Starten als Serveranwendung in Apache GEODE. Stellen Sie den Verbindungs-Locator auf den 40404-Port von localhost ein. --②: Einstellung zum Starten des Locators an Port 40404 --③: Einstellung zum Starten des Dienstes, der die Client / Server-Anwendung überwacht

Zu diesem Zeitpunkt wurde die Serveranwendung implementiert.

Erstellen eines Datenmodells

• Modell vom Client in der Web-App anfordern (anders als Client in 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;
}

--Domänenmodell blieb in Apache GEODE erhalten

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();
	}
}

• Erläuterung der Anmerkungen --①: Legen Sie die Region fest, der dieses Modell zugeordnet ist.

• Da das Projekt, das das Datenmodell implementiert, vom Projekt der Client- und Serveranwendungen abhängt, werden die folgenden Inhalte in settings.gradle der Client- und Serveranwendungen beschrieben.

settings.gradle

//geodeCommon sollte als der von Ihnen erstellte Projektname gelesen werden
include ':geodeCommon'
project(':geodeCommon').projectDir = new File('../geodeCommon')

Zu diesem Zeitpunkt ist die Implementierung des Datenmodells abgeschlossen.

Versuche zu beginnen

Da die Clientanwendung beim Start eine Verbindung zum Locator herstellt, muss zuerst die Serveranwendung gestartet werden.

• Serveranwendung starten (eingebettetes Tomacat beginnt mit der Portnummer 9090)

--client application start (eingebetteter Tomcat startet mit der Portnummer 9000)

Wenn beide Anwendungen normal gestartet werden können, sollten Client, Locator und Server verbunden sein.

Versuchen Sie, den Benutzer bei der Clientanwendung zu registrieren

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/;

Versuchen Sie, in der Serveranwendung nach einem Benutzer zu suchen

curl -i http://localhost:9090/findAll

Es ist in Ordnung, wenn der in der Clientanwendung registrierte Benutzer in den Suchergebnissen gesucht werden kann

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

Suchen Sie für alle Fälle auch nach dem Namen

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}

Ich konnte bestätigen, dass die Daten auf dem Client und dem Server synchronisiert wurden. Ich habe es unter Bezugnahme auf das folgende offizielle Dokument implementiert. https://geode.apache.org/docs/

In Zukunft werde ich versuchen, Anwendungen mit dem Peer-Modell, der Anwendungskonfiguration unter AWS, der asynchronen Persistenz usw. zu erstellen.