Download jetcache - download do código-fonte jetcache

jetcache

Código fonte JAVA

v2.7.7

Baixar

Introdução

JetCache é uma abstração de cache Java que fornece uso uniforme para diferentes soluções de cache. Ele fornece anotações mais poderosas do que as do Spring Cache. As anotações no JetCache suportam TTL nativo, cache de dois níveis e atualização automática em ambientes distribuídos. Você também pode manipular a instância Cache pelo seu código. Atualmente, existem quatro implementações: RedisCache , TairCache (não é de código aberto no github), CaffeineCache (na memória) e um LinkedHashMapCache simples (na memória). Recursos completos do JetCache:

Manipule o cache por meio da API de cache uniforme.
Cache de método declarativo usando anotações com TTL (Time To Live) e suporte de cache de dois níveis
Crie e configure instância Cache com gerenciador de cache
Colete automaticamente estatísticas de acesso para instância Cache e cache em nível de método
A estratégia de geração de chaves e serialização de valor pode ser customizada
Conversor de chave de cache suportado: fastjson / fastjson2 / jackson ; Conversor de valor suportado: java / kryo / kryo5
Atualização automática de cache distribuído e bloqueio distribuído. (2,2+)
Acesso assíncrono usando API Cache (2.2+, com cliente redis alface)
Invalidar caches locais (em todos os processos JVM) após atualizações (2.7+)
Suporte para inicialização Spring

requisitos:

JDK1.8
Spring Framework4.0.8+ (opcional, com suporte a anotações), jetcache 2.7 precisa de 5.2.4+
Spring Boot1.1.9+ (opcional), jetcache 2.7 precisa de 2.2.5+

Visite os documentos para mais detalhes.

Começando

Cache de método

Declare o cache do método usando a anotação @Cached .
expire = 3600 indica que os elementos expirarão em 3600 segundos após serem configurados. JetCache gera automaticamente a chave de cache com todos os parâmetros.

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

Usando o atributo key para especificar a chave de cache usando o script 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 );
}

Para usar o nome do parâmetro como key="#userId" , o destino do compilador javac deve ser 1.8 e superior e os -parameters devem ser definidos. Caso contrário, use index para acessar parâmetros como key="args[0]"

Atualização automática:

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

A anotação CachePenetrationProtect indica que o cache será carregado de forma síncrona em ambiente multithread.

API de cache

Crie uma instância Cache com 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 );
}

O código acima cria uma instância Cache . cacheType = CacheType.BOTH define um cache de dois níveis (um cache local na memória e um sistema de cache remoto) com elementos locais limitados a 50 (despejo baseado em LRU). Você pode usá-lo como um mapa:

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

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

API avançada

API assíncrona:

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

Bloqueio distribuído:

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

Leia e atualize automaticamente:

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

Configuração com Spring Boot

pom:

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

Classe de aplicativo:

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

Configuração do spring boot application.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}