Panduan GemFire ​​dengan Data Musim Semi

1. Ikhtisar

GemFire ​​adalah infrastruktur manajemen data terdistribusi berkinerja tinggi yang berada di antara cluster aplikasi dan sumber data back-end.

Dengan GemFire, data dapat dikelola dalam memori, yang membuat akses lebih cepat. Spring Data menyediakan konfigurasi yang mudah dan akses ke GemFire ​​dari aplikasi Spring.

Di artikel ini, kita akan melihat bagaimana kita dapat menggunakan GemFire ​​untuk memenuhi persyaratan cache aplikasi kita.

2. Ketergantungan Maven

Untuk menggunakan dukungan Spring Data GemFire, pertama-tama kita perlu menambahkan dependensi berikut di pom.xml:

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

Versi terbaru dari ketergantungan ini dapat ditemukan di sini.

3. Fitur Dasar GemFire

3.1. Cache

Cache di GemFire ​​menyediakan layanan manajemen data penting serta mengelola konektivitas ke peer lain.

Konfigurasi cache ( cache.xml ) menjelaskan bagaimana data akan didistribusikan di antara node yang berbeda:

     ...     ... 

3.2. Wilayah

Region data adalah pengelompokan logis dalam cache untuk satu kumpulan data.

Sederhananya, suatu region memungkinkan kita menyimpan data di beberapa VM dalam sistem tanpa mempertimbangkan node mana data tersebut disimpan dalam cluster.

Wilayah diklasifikasikan menjadi tiga kategori besar:

  • Wilayah yang direplikasi menyimpan kumpulan data lengkap di setiap node. Ini memberikan kinerja baca yang tinggi. Operasi tulis lebih lambat karena pembaruan data perlu disebarkan ke setiap node:
  • Wilayah yang dipartisi mendistribusikan data sehingga setiap node hanya menyimpan sebagian dari konten wilayah. Salinan data disimpan di salah satu node lainnya. Ini memberikan kinerja tulis yang baik.
  • Wilayah lokal berada di node anggota yang menentukan. Tidak ada konektivitas dengan node lain di dalam cluster.

3.3. Buat kueri Cache

GemFire ​​menyediakan bahasa kueri yang disebut OQL (Object Query Language) yang memungkinkan kita untuk merujuk ke objek yang disimpan di wilayah data GemFire. Ini sangat mirip dengan SQL dalam sintaks. Mari kita lihat bagaimana kueri yang sangat dasar terlihat seperti:

PILIH DISTINCT * FROM exampleRegion

QueryService GemFire menyediakan metode untuk membuat objek kueri.

3.4. Serialisasi Data

Untuk mengelola data serialization-deserialization, GemFire ​​memberikan pilihan selain serialization Java yang memberikan performa lebih tinggi, memberikan fleksibilitas yang lebih besar untuk penyimpanan data dan transfer data, juga support untuk berbagai bahasa.

Dengan pemikiran tersebut, GemFire ​​telah menentukan format data Portable Data eXchange (PDX). PDX adalah format data lintas bahasa yang menyediakan serialisasi dan deserialisasi lebih cepat, dengan menyimpan data di bidang bernama yang dapat diakses secara langsung tanpa perlu sepenuhnya deserialisasi objek.

3.5. Eksekusi Fungsi

Di GemFire, suatu fungsi dapat berada di server dan dapat dipanggil dari aplikasi klien atau server lain tanpa perlu mengirim kode fungsi itu sendiri.

Pemanggil dapat mengarahkan fungsi yang bergantung pada data untuk beroperasi pada kumpulan data tertentu atau dapat memimpin fungsi data independen untuk bekerja pada server, anggota, atau grup anggota tertentu.

3.6. Kueri Berkelanjutan

Dengan kueri berkelanjutan, klien berlangganan kejadian sisi server dengan menggunakan pemfilteran kueri tipe SQL. Server mengirimkan semua peristiwa yang mengubah hasil kueri. Pengiriman acara kueri berkelanjutan menggunakan kerangka langganan klien / server.

Sintaks untuk kueri kontinu mirip dengan kueri dasar yang ditulis di OQL. Misalnya, kueri yang menyediakan data stok terbaru dari wilayah Saham dapat ditulis sebagai:

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

Untuk mendapatkan pembaruan status dari kueri ini, implementasi CQListener perlu dilampirkan dengan StockRegion:

   ...  ...  ...   

4. Dukungan Spring Data GemFire

4.1. Konfigurasi Java

Untuk menyederhanakan konfigurasi, Spring Data GemFire ​​menyediakan berbagai anotasi untuk mengonfigurasi komponen inti 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; } }

Untuk mengatur cache dan wilayah GemFire, pertama-tama kita harus mengatur beberapa properti tertentu. Di sini mcast-port disetel ke nol, yang menunjukkan bahwa simpul GemFire ​​ini dinonaktifkan untuk penemuan dan distribusi multicast. Properti ini kemudian diteruskan ke CacheFactoryBean untuk membuat instance GemFireCache .

Menggunakan GemFireCache bean, sebuah instance dari LocalRegionFatcoryBean dibuat yang merepresentasikan wilayah dalam Cache untuk instance Employee .

4.2. Pemetaan Entitas

The library provides support to map objects to be stored in GemFire grid. The mapping metadata is defined by using annotations at the domain classes:

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

In the example above, we used the following annotations:

  • @Region, to specify the region instance of the Employee class
  • @Id, to annotate the property that shall be utilized as a cache key
  • @PersistenceConstructor, which helps to mark the one constructor that will be used to create entities, in case multiple constructors available

4.3. GemFire Repositories

Next, let's have a look at a central component in Spring Data – the repository:

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

4.4. Oql Query Support

The repositories allow the definition of query methods to efficiently run the OQL queries against the region the managed entity is mapped to:

@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. Function Execution Support

We also have annotation support available – to simplify working with GemFire function execution.

There are two concerns to address when we make use of functions, the implementation, and the execution.

Let's see how a POJO can be exposed as a GemFire function using Spring Data annotations:

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

We need to activate the annotation processing explicitly for @GemfireFunction to work:

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

For function execution, a process invoking a remote function need to provide calling arguments, a function id, the execution target (onServer, onRegion, onMember, etc.):

@OnRegion(region="employee") public interface FunctionExecution { @FunctionId("greeting") public void execute(String message); // ... }

Untuk mengaktifkan pemrosesan anotasi eksekusi fungsi, kita perlu menambahkan untuk mengaktifkannya menggunakan kemampuan pemindaian komponen Spring:

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

5. Kesimpulan

Pada artikel ini, kami telah menjelajahi fitur-fitur penting GemFire ​​dan memeriksa bagaimana API yang disediakan Spring Data memudahkan untuk bekerja dengannya.

Kode lengkap untuk artikel ini tersedia di GitHub.