import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
@Override
public void onRemoval(RemovalNotification<Object, Cache<Query, Value>> notification) {
    if (notification.getKey() == null) {
        return;
    }

    Cache<Query, Value> valueCache = notification.getValue();
    if (valueCache == null) {
        return;
    }

    for (Value value : valueCache.values()) {
        listener.onRemoval(value.shardId, value.bitset);
        // if null then this means the shard has already been removed and the stats are 0 anyway for the shard this key belongs to
    }
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
IndexFieldCache(Logger logger,final Cache<Key, Accountable> cache, Index index, String fieldName, Listener... listeners) {
    this.logger = logger;
    this.listeners = listeners;
    this.index = index;
    this.fieldName = fieldName;
    this.cache = cache;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
public BitsetFilterCache(IndexSettings indexSettings, Listener listener) {
    super(indexSettings);
    if (listener == null) {
        throw new IllegalArgumentException("listener must not be null");
    }
    this.loadRandomAccessFiltersEagerly = this.indexSettings.getValue(INDEX_LOAD_RANDOM_ACCESS_FILTERS_EAGERLY_SETTING);
    this.loadedFilters = CacheBuilder.<Object, Cache<Query, Value>>builder().removalListener(this).build();
    this.listener = listener;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
private BitSet getAndLoadIfNotPresent(final Query query, final LeafReaderContext context) throws IOException, ExecutionException {
    final Object coreCacheReader = context.reader().getCoreCacheKey();
    final ShardId shardId = ShardUtils.extractShardId(context.reader());
    if (shardId != null // can't require it because of the percolator
            && indexSettings.getIndex().equals(shardId.getIndex()) == false) {
        // insanity
        throw new IllegalStateException("Trying to load bit set for index " + shardId.getIndex()
                + " with cache of index " + indexSettings.getIndex());
    }
    Cache<Query, Value> filterToFbs = loadedFilters.computeIfAbsent(coreCacheReader, key -> {
        context.reader().addCoreClosedListener(BitsetFilterCache.this);
        return CacheBuilder.<Query, Value>builder().build();
    });

    return filterToFbs.computeIfAbsent(query, key -> {
        final IndexReaderContext topLevelContext = ReaderUtil.getTopLevelContext(context);
        final IndexSearcher searcher = new IndexSearcher(topLevelContext);
        searcher.setQueryCache(null);
        final Weight weight = searcher.createNormalizedWeight(query, false);
        Scorer s = weight.scorer(context);
        final BitSet bitSet;
        if (s == null) {
            bitSet = null;
        } else {
            bitSet = BitSet.of(s.iterator(), context.reader().maxDoc());
        }

        Value value = new Value(bitSet, shardId);
        listener.onCache(shardId, value.bitset);
        return value;
    }).bitset;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
private <E extends Object> E cacheLoad(CacheKey key, Cache<CacheKey, E> cache,
                                            CheckedFunction<String, E, IOException> loader) throws IOException {
    try {
        return cache.computeIfAbsent(key, (k) -> {
            E elt = loader.apply(k.getId());
            if (elt != null) {
                onAdd(k, elt);
            }
            return elt;
        });
    } catch (ExecutionException e) {
        throw new IOException(e.getMessage(), e.getCause());
    }
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
private void evict(String index, Cache<CacheKey, ?> cache) {
    Iterator<CacheKey> ite = cache.keys().iterator();
    while(ite.hasNext()) {
        if(ite.next().storeName.equals(index)) {
            ite.remove();
        }
    }
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
protected JoinerScript(Client client, ESLogger logger, Cache<Tuple<String, String>, Map<String, Object>> cache,
		String tenant, String index, String type, String id,
		String docindex, String doctype, String docid,
		String targetSource, String targetSourceIncludes, String targetSourceExcludes,
		String targetSourceLwc, String missing,
		String cacheField, String cachedField) {
    this.client = client;
    this.logger = logger;
    this.cache = cache;

    this.tenant = tenant;
    this.index = index;
    this.type = type;
    this.id = id;

    this.docid = docid;
    this.doctype = doctype;
    this.docindex = docindex;

    this.targetSource = targetSource;
    this.targetSourceIncludes = targetSourceIncludes;
    this.targetSourceExcludes = targetSourceExcludes;

    this.targetSourceLwc = targetSourceLwc;
    if (missing == null || missing.equals("_last")) {
    	this.missingStringSortValue = "\u00ff\u00ff\u00ff\u00ff";
    } else if (missing.equals("_first")) {
    	this.missingStringSortValue = "";
    } else {
    	this.missingStringSortValue = missing;
    }

    this.cacheField = cacheField;
    this.cachedField = cachedField;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
public Cache<Key, Accountable> getCache() {
    return cache;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
Cache<Object, Cache<Query, Value>> getLoadedFilters() {
    return loadedFilters;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
public Cache<CacheKey, Feature> featureCache() {
    return featureCache;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
public Cache<CacheKey, FeatureSet> featureSetCache() {
    return featureSetCache;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
public Cache<CacheKey, CompiledLtrModel> modelCache() {
    return modelCache;
}
 

import org.elasticsearch.common.cache.Cache; //导入依赖的package包/类
private <T> T innerGet(String id, Cache<Caches.CacheKey, T> cache) {
    return cache.get(key(id));
}