JetCache源码解析——配置加载

JetCache自动化配置加载

JetCache的配置加载主要是在jetcache-autoconfigure模块中完成的，无论是使用内存缓存LinkedHashMap和caffeine，亦或是通过lettuce、redisson和spring-data-redis来操作Redis服务缓存数据，其自动加载配置的操作基本上都是相似的。

例如LinkedHashMapAutoConfiguration完成LinkedHashMap类型的缓存初始化操作，源码如下：

/**
 * LinkedHashMap自动配置类
 */
@Component
@Conditional(LinkedHashMapAutoConfiguration.LinkedHashMapCondition.class)
public class LinkedHashMapAutoConfiguration extends EmbeddedCacheAutoInit {
    public LinkedHashMapAutoConfiguration() {
        super("linkedhashmap");
    }

    @Override
    /**
     * 初始化缓存
     * @param ct            配置树
     * @param cacheAreaWithPrefix    缓存区域名称（包括前缀）
     * @return              初始化后的缓存
     */
    protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
        LinkedHashMapCacheBuilder builder = LinkedHashMapCacheBuilder.createLinkedHashMapCacheBuilder();
        parseGeneralConfig(builder, ct);
        return builder;
    }

    /**
     * LinkedHashMap条件类
     */
    public static class LinkedHashMapCondition extends JetCacheCondition {
        public LinkedHashMapCondition() {
            super("linkedhashmap");
        }
    }
}

其中LinkedHashMapCondition是一个自定义的条件类，如果spring boot项目的application.yml文件中jetcache.local.${areaName} .type或jetcache.remote.${areaName}.type为linkedhashmap时，就会构建LinkedHashMapAutoConfiguration对应的bean，JetCacheCondition类的源码如下：

public abstract class JetCacheCondition extends SpringBootCondition {

    /**
     * 缓存类型数组
     */
    private String[] cacheTypes;

    /**
     * 构造方法
     * @param cacheTypes 缓存类型数组
     */
    protected JetCacheCondition(String... cacheTypes) {
        Objects.requireNonNull(cacheTypes, "cacheTypes can't be null");
        Assert.isTrue(cacheTypes.length > 0, "cacheTypes length is 0");
        this.cacheTypes = cacheTypes;
    }

    /**
     * 判断条件是否匹配
     * @param conditionContext 条件上下文
     * @param annotatedTypeMetadata 注解类型元数据
     * @return 匹配结果
     */
    @Override
    public ConditionOutcome getMatchOutcome(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        ConfigTree ct = new ConfigTree((ConfigurableEnvironment) conditionContext.getEnvironment(), "jetcache.");
        if (match(ct, "local.") || match(ct, "remote.")) {
            return ConditionOutcome.match();
        } else {
            return ConditionOutcome.noMatch("no match for " + cacheTypes[0]);
        }
    }

    /**
     * 判断是否匹配指定前缀
     * @param ct 配置树
     * @param prefix 前缀
     * @return 是否匹配
     */
    private boolean match(ConfigTree ct, String prefix) {
        Map<String, Object> m = ct.subTree(prefix).getProperties();
        Set<String> cacheAreaNames = m.keySet().stream().map((s) -> s.substring(0, s.indexOf('.'))).collect(Collectors.toSet());
        final List<String> cacheTypesList = Arrays.asList(cacheTypes);
        return cacheAreaNames.stream().anyMatch((s) -> cacheTypesList.contains(m.get(s + ".type")));
    }
}

同理，如果想要使用redisson或lettuce中间件来进行远程缓存的处理，则对应的自动化配置类的源码如下：

@Configuration
@Conditional(RedissonAutoConfiguration.RedissonCondition.class)
public class RedissonAutoConfiguration {
    private static final String CACHE_TYPE = "redisson";

    public static class RedissonCondition extends JetCacheCondition {
        public RedissonCondition() {
            super(CACHE_TYPE);
        }
    }

    @Bean
    public RedissonAutoInit redissonAutoInit() {
        return new RedissonAutoInit();
    }
}

在上面的RedissonAutoConfiguration.RedissonCondition条件类中对应的cacheTypes为redisson，即当spring boot项目的application.yml文件中jetcache.local.${areaName} .type或jetcache.remote.${areaName}.type为redisson时，就会构建RedissonAutoConfiguration对应的bean。

同理，加载lettuce对应的自动化加载的源码如下：

@Configuration
@Conditional(RedisLettuceAutoConfiguration.RedisLettuceCondition.class)
public class RedisLettuceAutoConfiguration {
    public static final String AUTO_INIT_BEAN_NAME = "redisLettuceAutoInit";

    public static class RedisLettuceCondition extends JetCacheCondition {
        public RedisLettuceCondition() {
            super("redis.lettuce");
        }
    }

    @Bean(name = {AUTO_INIT_BEAN_NAME})
    public RedisLettuceAutoInit redisLettuceAutoInit() {
        return new RedisLettuceAutoInit();
    }
}

JetCache自动初始化

JetCache的自动化的类图如下：

内存缓存自动初始化

LinkedHashMapAutoConfiguration类是基于LinkedHashMap来创建的内存缓存自动配置类，该类继承自EmbeddedCacheAutoInit抽象类，该类重写了initCache方法，用于内存缓存的初始化操作，该方法会创建用于创建LinkedHashMap类型的内存缓存的创建者，并调用parseGeneralConfig方法解析JetCache的配置。源码如下：

    /**
     * 重写方法，用于初始化缓存
     * @param ct 缓存的配置树
     * @param cacheAreaWithPrefix 缓存区服（包括前缀）
     * @return 返回构建好的缓存
     */
    @Override
    protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
        LinkedHashMapCacheBuilder builder = LinkedHashMapCacheBuilder.createLinkedHashMapCacheBuilder();
        parseGeneralConfig(builder, ct);
        return builder;
    }

创建LinkerHashMap类型的缓存构建者的源码如下：

public class LinkedHashMapCacheBuilder<T extends EmbeddedCacheBuilder<T>> extends EmbeddedCacheBuilder<T> {
    /**
     * LinkedHashMapCacheBuilder的内部类
     */
    public static class LinkedHashMapCacheBuilderImpl extends LinkedHashMapCacheBuilder<LinkedHashMapCacheBuilderImpl> {
        
    }

    /**
     * 创建一个LinkedHashMapCacheBuilderImpl实例
     * 
     * @return 返回LinkedHashMapCacheBuilderImpl实例
     */
    public static LinkedHashMapCacheBuilderImpl createLinkedHashMapCacheBuilder() {
        return new LinkedHashMapCacheBuilderImpl();
    }

    /**
     * 私有构造方法
     */
    protected LinkedHashMapCacheBuilder() {
        buildFunc((c) -> new LinkedHashMapCache((EmbeddedCacheConfig) c));
    }
}

在上面构建的LinkedHashMapCacheBuilder实例时，LinkedHashMapCacheBuilder的构造函数会初始化相应的缓存类LinkedHashMapCache。这里紧急简单介绍一下，后面会详细就缓存构建者进行描述。

CaffeineAutoConfiguration类是基于Caffeine来创建的内存缓存自动配置类，该类继承自EmbeddedCacheAutoInit抽象类，该类重写了initCache方法，该方法会创建用于创建Caffeine类型的内存缓存的创建者，并调用parseGeneralConfig方法解析JetCache的配置。源码如下：

@Override
    protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
        CaffeineCacheBuilder builder = CaffeineCacheBuilder.createCaffeineCacheBuilder();
        parseGeneralConfig(builder, ct);
        return builder;
    }

同样，关于构建CaffeineCacheBuilder相应的代码逻辑也放在后面再进行介绍。

内存缓存LinkedHashMap和caffeine的自动初始化类都是继承自EmbeddedCacheAutoInit抽象类，主要是解析配置的内存缓存的最大缓存数量。EmbeddedCacheAutoInit类的源码如下：

public abstract class EmbeddedCacheAutoInit extends AbstractCacheAutoInit {

    public EmbeddedCacheAutoInit(String... cacheTypes) {
        super(cacheTypes);
    }

    @Override
    protected void parseGeneralConfig(CacheBuilder builder, ConfigTree ct) {
        super.parseGeneralConfig(builder, ct);
        EmbeddedCacheBuilder ecb = (EmbeddedCacheBuilder) builder;

        ecb.limit(Integer.parseInt(ct.getProperty("limit", String.valueOf(CacheConsts.DEFAULT_LOCAL_LIMIT))));
    }
}

解析配置文件的逻辑放到下面的JetCache配置解析章节进行讲述，这里不做过多描述。

Redis缓存自动初始化

在RedissonAutoConfiguration类中，redissonAutoInit()函数会创建RedissonAutoInit对应的bean，类RedissonAutoInit继承自ExternalCacheAutoInit类，通过重写initCache方法，该方法会创建用于创建Redisson类型的内存缓存的创建者RedissonCacheBuilder，并调用parseGeneralConfig方法解析JetCache的配置。下面会详细介绍不同类型的Redis缓存的初始化逻辑。

RedissonAutoInit

待完善…………

RedisLettuceAutoInit

待完善…………

JetCache缓存构建者

待完善…………

JetCache配置加载

待完善…………