27-JetCache基于redis使用总结

• 前言

• 一.使用配置

• 1.1.SpringBoot中使用

• 1.2.未使用SpringBoot中进行应用：

• 二、代码使用

• 2.1创建缓存两级（内存+远程），缓存，控制在50个

• 2.2一些属性介绍:

• 结尾

前言

JetCache是阿里巴巴出品现在比较流行的一款基于Java缓存系统，通过注解实现缓存的封装,本文基于采用Redis配置的使用，RedisCache。当然jetcache还支持其他的。官网地址：https://github.com/alibaba/jetcache/wiki/Home_CN 其他参考：https://blog.csdn.net/sinat_32366329/article/details/80260944

一.使用配置

1.1.SpringBoot中使用

引入依赖：

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-starter-redis</artifactId>
    <version>2.4.4</version>
</dependency>

进行配置启动类注解或者配置类注解：@EnableMethodCache(basePackages = “包) @EnableCreateCacheAnnotation 上面两个分别激活的是Cached和CreateCache注解。配置文件:

jetcache:
  statIntervalMinutes: 15
  areaInCacheName: false
  local:
    default:
      type: linkedhashmap
      keyConvertor: fastjson
  remote:
    default:
      type: redis
      keyConvertor: fastjson
      valueEncoder: java
      valueDecoder: java
      poolConfig:
        minIdle: 5
        maxIdle: 20
        maxTotal: 50
      host: 127.0.0.1
      port: 6379

1.2.未使用SpringBoot中进行应用：

引入依赖：

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-anno</artifactId>
    <version>2.4.4</version>
</dependency>
<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-redis</artifactId>
    <version>2.4.4</version>
</dependency>

配置类：

package com.company.mypackage;

import java.util.HashMap;
import java.util.Map;

import com.alicp.jetcache.anno.CacheConsts;
import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;
import com.alicp.jetcache.anno.config.EnableMethodCache;
import com.alicp.jetcache.anno.support.GlobalCacheConfig;
import com.alicp.jetcache.anno.support.SpringConfigProvider;
import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
import com.alicp.jetcache.embedded.LinkedHashMapCacheBuilder;
import com.alicp.jetcache.redis.RedisCacheBuilder;
import com.alicp.jetcache.support.FastjsonKeyConvertor;
import com.alicp.jetcache.support.JavaValueDecoder;
import com.alicp.jetcache.support.JavaValueEncoder;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.util.Pool;

@Configuration
@EnableMethodCache(basePackages = "com.company.mypackage")
@EnableCreateCacheAnnotation
public class JetCacheConfig {

    @Bean
    public Pool<Jedis> pool(){
        GenericObjectPoolConfig pc = new GenericObjectPoolConfig();
        pc.setMinIdle(2);
        pc.setMaxIdle(10);
        pc.setMaxTotal(10);
        return new JedisPool(pc, "localhost", 6379);
    }

    @Bean
    public SpringConfigProvider springConfigProvider() {
        return new SpringConfigProvider();
    }

    @Bean
    public GlobalCacheConfig config(SpringConfigProvider configProvider, Pool<Jedis> pool){
        Map localBuilders = new HashMap();
        EmbeddedCacheBuilder localBuilder = LinkedHashMapCacheBuilder
                .createLinkedHashMapCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE);
        localBuilders.put(CacheConsts.DEFAULT_AREA, localBuilder);

        Map remoteBuilders = new HashMap();
        RedisCacheBuilder remoteCacheBuilder = RedisCacheBuilder.createRedisCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE)
                .valueEncoder(JavaValueEncoder.INSTANCE)
                .valueDecoder(JavaValueDecoder.INSTANCE)
                .jedisPool(pool);
        remoteBuilders.put(CacheConsts.DEFAULT_AREA, remoteCacheBuilder);

        GlobalCacheConfig globalCacheConfig = new GlobalCacheConfig();
        globalCacheConfig.setConfigProvider(configProvider);
        globalCacheConfig.setLocalCacheBuilders(localBuilders);
        globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);
        globalCacheConfig.setStatIntervalMinutes(15);
        globalCacheConfig.setAreaInCacheName(false);

        return globalCacheConfig;
    }
}

二、代码使用

2.1创建缓存两级（内存+远程），缓存，控制在50个

@CreateCache(name = "UserService.userCache", expire = 100, cacheType = CacheType.BOTH, localLimit = 50)
private Cache<String, Object> userCache;

两种加锁使用方式：第一种:tryLock

  // 使用try-with-resource方式，可以自动释放锁
  try(AutoReleaseLock lock = cache.tryLock("MyKey",100, TimeUnit.SECONDS)){
     if(lock != null){
        // do something
     }
  }

第一种:tryLockAndRun

  boolean hasRun = tryLockAndRun("MyKey",100, TimeUnit.SECONDS), () -> {
    // do something
  };
  if(hasRun)//进行判断是不是执行

基于方法的三种注解创建、更新、失效：

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

特别重要的总结：当两个key同时使用的时候：

@Cached(name ="findXXXX方法名",key="#vo.k1+'_'+#vo.k2",timeUnit= TimeUnit.MINUTES,expire=120 )

2.2一些属性介绍:

2.2.1 @CreateCache属性介绍：

2.2.2 @Cached属性介绍：

2.2.3 CacheInvalidate属性介绍：

2.2.4 CacheUpdate注解说明：

2.2.5 CacheRefresh注解说明：

2.2.6 属性配置的一些说明：

结尾

上面重点要说明的是两个key的情况下怎样使用缓存，还有就是进行加锁使用的方法介绍，其他的是一些配置说明可能有点多，用的时候当字典一样去查询就可以。jetcache的使用在一定的程度上可以让我们使用缓存更加的简单和方便，但是有些地方用不好的话可能会掉进坑里，所以请大家用一些注解属性的时候一定要了解清楚再使用，如果你喜欢我的分享，欢迎点赞，转发，赞赏。如有问题，可以关注公众号进行交流。