Spring - Pendahuluan

Pendahuluan awal mengenai Cache bisa dilihat di Java Cache

Penjelasan mengenai mekanisme dan object Cache bisa dilihat di Java Cache

Salah satu implementor dari Java Cache yang sepertinya paling banyak digunakan adalah EhCache

Versi terakhirnya saat artikel ini dibuat adalah versi 3.10.0.

EhCache adalah libray open-source yang di backup oleh Terracota, Inc, perusahaan yang banyak bergelut di bidang Distributed In-memory Data Management

Di versi 3.x.x, EhCache ini memperkenalkan :

  • Cache API yang menggunakan fitur Java Generic dan penyederhanaan interaksi dengan API Cache nya.
  • Fully compatible dengan Java Caching API (JSR-107).
  • Fitur yang lebih lengkap terkait dengan Offheap seperti Offheap storage, Offheap only caches
  • Memudahkan dari sisi integrasi dengan Spring dan Hibernate.
  • dll.

OffHeap adalah salah satu tipe memori yang menjadi pilihan bagi EhCache ketika berhadapan dengan tipe data yang perlu strategi Caching.

OffHeap adalah cache di memori tetapi bukan di Java Heap.

Efeknya, cache ini tidak akan diproses oleh JVM Garbage Collection (GC).

Dengan menggunakan OffHeap store, maka kita dapat membuat cache yang cukup besar, maksimal sebesar RAM yang kita punyai.

OffHeap ini menjadi salah satu dari tipe penyimpanan cache di EhCache ini, yaitu :

  • OnHeap memori. Tipe ini bisa kena Garbage Collectornya Java.
  • OffHeap memori. Tipe ini tidak kena Garbage Collectornya Java.
  • Disk store memori. Tipe ini lebih lambat karena disimpan di disk.

Spring Boot - EhCache

Bagaimana implementasi EhCache di Spring Boot ?

Untuk bisa menggunakan Spring Boot dengan EhCache di aplikasi kita, maka kita membutuhkan library :

  • spring-boot-starter-cache
  • cache-api , sebagai antarmuka JSR-107
  • ehcache , sebagai implementor dari JSR-107
  • spring-boot-starter-web, kalau butuh testing menggunakan REST controller.

Dependency dari SpringBoot menggunakan EhCache

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
    <version>2.7.5</version>
</dependency>
<dependency>
    <groupId>javax.cache</groupId>
    <artifactId>cache-api</artifactId>
    <version>1.1.1</version>
</dependency>
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.10.0</version>
</dependency>     
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.7.5</version>
</dependency>

Tentu saja ada Anotasi : EnableCaching harus kita tambahkan juga.

Misalnya :

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableCaching
@SpringBootApplication
public class SpringBootAppl {

	public static void main(String[] args) {
		  SpringApplication.run(SpringBootAppl.class, args);
	}
}

Secara otomatis, Spring Boot akan mencari implementor dari JSR-107, yang sudah kita definisikan di library pom.xml yaitu adalah EhCache.

Tetapi kita belum mendefinisikan :

  • Nama cache yang diperlukan.
  • konfigurasi kadaluarsa dari Cache nya.
  • konfigurasi lainnya.

Gimana dong ?

Ya sudah, bikin saja konfigurasinya.

Konfigurasi diatas bisa kita lakukan dengan membuat sebuah class Configuration sendiri.

Atau bisa juga dengan menambahkan file .xml khusus untuk konfigurasi otomatis EhCache ini.

Misalnya file ehcache.yml di folder config/ehcache.yml

// file : config/ehcache.xml

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.ehcache.org/v3"
    xmlns:jsr107="http://www.ehcache.org/v3/jsr107"
    xsi:schemaLocation="
            http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core-3.0.xsd
            http://www.ehcache.org/v3/jsr107 http://www.ehcache.org/schema/ehcache-107-ext-3.0.xsd">

    <cache alias="masterDataCache">
        <key-type>java.lang.String</key-type>
        <value-type>java.lang.String</value-type>
        <expiry>
            <ttl unit="days">2</ttl>
        </expiry>

        <resources>
            <heap unit="entries">100</heap>
            <offheap unit="MB">10</offheap>
        </resources>
    </cache>
</config>

Konfigurasi diatas artinya kita mau melakukan konfigurasi untuk sebuah Cache bernama masterDataCache.

Misalnya kegunaannya untuk Caching data-data master yang sering kita akses.

Entry atau datanya dalam bentuk map <String, String>

Eitss, tapi tunggu dulu.

Agar konfigurasi diatas bisa diakses, maka kita perlu mendefinisikan lokasinya, agar Spring Boot bisa dengan mudah melakukan inject dan instansiasi object terkait Cache.

Informasi letak file ehcache.yml tadi dapat ditambahkan di file konfigurasi umum : application.yml

\\ application.yml

spring:
  cache:
    jcache:
      config:  classpath:ehcache.xml

Bagaimana memakainya di code aplikasi kita ?

Ok kita coba memakai Cache masterDataCache ini di aplikasi kita.

Misalnya dalam sebuah komponen Data Master Repository, kita ingin melakukan Cache terhadap data yang kita query ke Database.

@Repository
public class DataMasterRepository {

    @Autowired
    private DatabaseRepository dbRepository;

    @Cacheable(value = "dataMasterCache", key = "#keyName", condition = "#keyName!=null")
    public String getDataMasterValue(String keyName) {
        String keyValue = dbRepository.getByKeyName(keyName);
        log.info("Value of {} is {}", keyName, keyValue);
        return keyValue;
    }
}

Dan misalnya kita menggunakan repository ini dalam sebuah REST Controller :

@RestController
@RequestMapping("/testCache")
public class CacheController {

    @Autowired
    private DataMasterRepository dataMasterRepository;

    @GetMapping(path = "/cache/{keyName}")
    public String getValue(@PathVariable String keyName) {
        String keyValue = dataMasterRepository.getMasterValue(keyName);
        log.info("Done call keyName : {}, keyValue : {}", keyName, keyValue);
        return value;
    }
}

dan kita bisa melakukan test memanggil cache nya sebagai berikut :


http://localhost:8080/testCache/cache/MAX_USER


Maka kita akan melihat hasilnya sbb : 

#pemanggilan pertama
Value of MAX_USER is 20
Done call keyName : MAX_USER, keyValue : 20

#pemanggilan kedua
Done call keyName : MAX_USER, keyValue : 20

#pemanggilan ketiga , dst
Done call keyName : MAX_USER, keyValue : 20

Kalau kita lihat , pada pemanggilan kedua, ketiga , dst, kita lihat tidak ada lagi pemanggilan ke database.

Hal ini karena key MAX_USER telah kita Caching selama 2 hari (lihat di konfigurasi ehCache.xml diatas).

Sehingga sampai 2 hari ke depan, ketika melakukan pemanggilan terhadap keyName MAX_USER ini, maka yang digunakan adalah data yang ada di Cache.


Bagaimana setelah 2 hari ?

Setelah 2 hari, maka ketika EhCache mengecek bahwa Cache nya telah kadaluarsa, maka akan diinisiasi Cache Event EXPIRED.

Efeknya akan dilakukan query lagi ke database, dan disimpan lagi ke Cache dengan menset waktu kadaluarsa yang baru.

Semoga membantu..