Unduh jetcache - pengunduhan kode sumber jetcache

jetcache

Kode sumber JAWA

v2.7.7

Unduh

Perkenalan

JetCache adalah abstraksi cache Java yang menyediakan penggunaan seragam untuk solusi caching yang berbeda. Ini memberikan anotasi yang lebih kuat daripada yang ada di Spring Cache. Anotasi di JetCache mendukung TTL asli, cache dua tingkat, dan penyegaran otomatis di lingkungan terdistribusi, Anda juga dapat memanipulasi instance Cache dengan kode Anda. Saat ini, ada empat implementasi: RedisCache , TairCache (bukan open source di github), CaffeineCache (di memori) dan LinkedHashMapCache sederhana (di memori). Fitur lengkap JetCache:

Memanipulasi cache melalui API Cache yang seragam.
Caching metode deklaratif menggunakan anotasi dengan TTL (Time To Live) dan dukungan caching dua tingkat
Buat & konfigurasikan instance Cache dengan manajer cache
Secara otomatis mengumpulkan statistik akses untuk instance Cache dan cache tingkat metode
Strategi pembuatan kunci dan serialisasi nilai dapat disesuaikan
Konverter kunci cache yang didukung: fastjson / fastjson2 / jackson ; Pengonversi nilai yang didukung: java / kryo / kryo5
Penyegaran otomatis cache terdistribusi dan kunci terdistribusi. (2.2+)
Akses asinkron menggunakan Cache API (2.2+, dengan klien selada redis)
Batalkan cache lokal (dalam semua proses JVM) setelah pembaruan (2.7+)
Dukungan Boot Musim Semi

persyaratan:

JDK1.8
Spring Framework4.0.8+ (opsional, dengan dukungan anotasi), jetcache 2.7 memerlukan 5.2.4+
Spring Boot1.1.9+ (opsional), jetcache 2.7 membutuhkan 2.2.5+

Kunjungi dokumen untuk detail lebih lanjut.

Memulai

Cache metode

Deklarasikan cache metode menggunakan anotasi @Cached .
expire = 3600 menunjukkan bahwa elemen akan kedaluwarsa dalam 3600 detik setelah disetel. JetCache secara otomatis menghasilkan kunci cache dengan semua parameter.

 public interface UserService {
    @ Cached ( expire = 3600 , cacheType = CacheType . REMOTE )
    User getUserById ( long userId );
}

Menggunakan atribut key untuk menentukan kunci cache menggunakan skrip SpEL.

 public interface UserService {
    @ Cached ( name = "userCache-" , key = "#userId" , expire = 3600 )
    User getUserById ( long userId );

    @ CacheUpdate ( name = "userCache-" , key = "#user.userId" , value = "#user" )
    void updateUser ( User user );

    @ CacheInvalidate ( name = "userCache-" , key = "#userId" )
    void deleteUser ( long userId );
}

Untuk menggunakan nama parameter seperti key="#userId" , target kompiler javac Anda harus 1,8 ke atas, dan -parameters harus disetel. Jika tidak, gunakan indeks untuk mengakses parameter seperti key="args[0]"

Penyegaran otomatis:

 public interface SummaryService {
    @ Cached ( expire = 3600 , cacheType = CacheType . REMOTE )
    @ CacheRefresh ( refresh = 1800 , stopRefreshAfterLastAccess = 3600 , timeUnit = TimeUnit . SECONDS )
    @ CachePenetrationProtect
    BigDecimal summaryOfToday ( long categoryId );
}

Anotasi CachePenetrationProtect menunjukkan bahwa cache akan dimuat secara sinkron di lingkungan multi-thread.

API cache

Buat instance Cache dengan CacheManager :

 @ Autowired
private CacheManager cacheManager ;
private Cache < String , UserDO > userCache ;

@ PostConstruct
public void init () {
    QuickConfig qc = QuickConfig . newBuilder ( "userCache" )
        . expire ( Duration . ofSeconds ( 100 ))
        . cacheType ( CacheType . BOTH ) // two level cache
        . localLimit ( 50 )
        . syncLocal ( true ) // invalidate local cache in all jvm process after update
        . build ();
    userCache = cacheManager . getOrCreateCache ( qc );
}

Kode di atas membuat instance Cache . cacheType = CacheType.BOTH mendefinisikan cache dua tingkat (cache dalam memori lokal dan sistem cache jarak jauh) dengan elemen lokal dibatasi hingga 50 (pengusiran berbasis LRU). Anda dapat menggunakannya seperti peta:

 UserDO user = userCache . get ( 12345L );
userCache . put ( 12345L , loadUserFromDataBase ( 12345L ));
userCache . remove ( 12345L );

userCache . computeIfAbsent ( 1234567L , ( key ) -> loadUserFromDataBase ( 1234567L ));

API tingkat lanjut

API Asinkron:

 CacheGetResult r = cache . GET ( userId );
CompletionStage < ResultData > future = r . future ();
future . thenRun (() -> {
    if ( r . isSuccess ()){
        System . out . println ( r . getValue ());
    }
});

Kunci terdistribusi:

 cache . tryLockAndRun ( "key" , 60 , TimeUnit . SECONDS , () -> heavyDatabaseOperation ());

Baca dan segarkan otomatis:

 @ Autowired
private CacheManager cacheManager ;
private Cache < String , Long > orderSumCache ;

@ PostConstruct
public void init () {
    QuickConfig qc = QuickConfig . newBuilder ( "userCache" )
        . expire ( Duration . ofSeconds ( 3600 ))
        . loader ( this :: loadOrderSumFromDatabase )
        . refreshPolicy ( RefreshPolicy . newPolicy ( 60 , TimeUnit . SECONDS ). stopRefreshAfterLastAccess ( 100 , TimeUnit . SECONDS ))
        . penetrationProtect ( true )
        . build ();
    orderSumCache = cacheManager . getOrCreateCache ( qc );
}

Konfigurasi dengan Spring Boot

pom:

< dependency >
    < groupId >com.alicp.jetcache</ groupId >
    < artifactId >jetcache-starter-redis</ artifactId >
    < version >${jetcache.latest.version}</ version >
</ dependency >

Kelas aplikasi:

 @ SpringBootApplication
@ EnableMethodCache ( basePackages = "com.company.mypackage" )
@ EnableCreateCacheAnnotation // deprecated in jetcache 2.7, can be removed if @CreateCache is not used
public class MySpringBootApp {
    public static void main ( String [] args ) {
        SpringApplication . run ( MySpringBootApp . class );
    }
}

konfigurasi aplikasi booting pegas.yml:

 jetcache :
  statIntervalMinutes : 15
  areaInCacheName : false
  local :
    default :
      type : linkedhashmap # other choose：caffeine
      keyConvertor : fastjson2 # other choose：fastjson/jackson
      limit : 100
  remote :
    default :
      type : redis
      keyConvertor : fastjson2 # other choose：fastjson/jackson
      broadcastChannel : projectA
      valueEncoder : java # other choose：kryo/kryo5
      valueDecoder : java # other choose：kryo/kryo5
      poolConfig :
        minIdle : 5
        maxIdle : 20
        maxTotal : 50
      host : ${redis.host}
      port : ${redis.port}