• Home
• com.github.lontime
• extredisson-library
• 1.4.0
• source code
• Redisson2LevelMapCache.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.github.lontime.extredisson.cache.Redisson2LevelMapCache Maven / Gradle / Ivy

package com.github.lontime.extredisson.cache;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

import com.github.lontime.base.logging.GLogger;
import io.netty.buffer.ByteBuf;
import com.github.lontime.shaded.org.redisson.RedissonMapCache;
import com.github.lontime.shaded.org.redisson.WriteBehindService;
import com.github.lontime.shaded.org.redisson.api.LocalCachedMapOptions;
import com.github.lontime.shaded.org.redisson.api.RFuture;
import com.github.lontime.shaded.org.redisson.api.RedissonClient;
import com.github.lontime.shaded.org.redisson.cache.CacheKey;
import com.github.lontime.shaded.org.redisson.cache.CacheValue;
import com.github.lontime.shaded.org.redisson.cache.LocalCacheListener;
import com.github.lontime.shaded.org.redisson.cache.LocalCachedMapClear;
import com.github.lontime.shaded.org.redisson.cache.LocalCachedMapInvalidate;
import com.github.lontime.shaded.org.redisson.cache.LocalCachedMapUpdate;
import com.github.lontime.shaded.org.redisson.cache.LocalCachedMessageCodec;
import com.github.lontime.shaded.org.redisson.client.codec.Codec;
import com.github.lontime.shaded.org.redisson.client.codec.LongCodec;
import com.github.lontime.shaded.org.redisson.client.codec.StringCodec;
import com.github.lontime.shaded.org.redisson.client.protocol.RedisCommand;
import com.github.lontime.shaded.org.redisson.client.protocol.RedisCommands;
import com.github.lontime.shaded.org.redisson.client.protocol.convertor.NumberConvertor;
import com.github.lontime.shaded.org.redisson.command.CommandAsyncExecutor;
import com.github.lontime.shaded.org.redisson.eviction.EvictionScheduler;
import com.github.lontime.shaded.org.redisson.misc.CompletableFutureWrapper;

/**
 * Redisson2LevelMapCache.
 * 先通知 在执行具体的操作.有可能引起 错误通知，不过可以保证redis数据正确
 *
 * @author lontime
 * @since 1.0
 * @param  K
 * @param  V
 */
@SuppressWarnings("all")
public class Redisson2LevelMapCache extends RedissonMapCache implements R2LevelMapCache {
    public static final String HOLDER_VALUE = "x";

    private long cacheUpdateLogTime = TimeUnit.MINUTES.toMillis(10);
    private byte[] instanceId;
    private ConcurrentMap cache;
    private int invalidateEntryOnChange;
    private LocalCachedMapOptions.SyncStrategy syncStrategy;
    private LocalCachedMapOptions.StoreMode storeMode;
    private boolean storeCacheMiss;

    private LocalCacheListener listener;
    private ExtLocalCacheView localCacheView;

    public Redisson2LevelMapCache(CommandAsyncExecutor commandExecutor, String name, LocalCachedMapOptions options,
                                  EvictionScheduler evictionScheduler, RedissonClient redisson, WriteBehindService writeBehindService) {
        super(evictionScheduler, commandExecutor, name, redisson, options, writeBehindService);
        init(options, redisson, evictionScheduler);
    }

    public Redisson2LevelMapCache(Codec codec, CommandAsyncExecutor connectionManager, String name, LocalCachedMapOptions options,
                                  EvictionScheduler evictionScheduler, RedissonClient redisson, WriteBehindService writeBehindService) {
        super(codec, evictionScheduler, connectionManager, name, redisson, options, writeBehindService);
        init(options, redisson, evictionScheduler);
    }

    private void init(LocalCachedMapOptions options, RedissonClient redisson, EvictionScheduler evictionScheduler) {
        syncStrategy = options.getSyncStrategy();
        storeMode = options.getStoreMode();
        storeCacheMiss = options.isStoreCacheMiss();

        localCacheView = new ExtLocalCacheView<>(options, this);
        cache = localCacheView.getCache();
        listener = new LocalCacheListener(getLocalRawName(), commandExecutor, this, codec, options, cacheUpdateLogTime) {

            @Override
            protected void updateCache(ByteBuf keyBuf, ByteBuf valueBuf) throws IOException {
                CacheKey cacheKey = localCacheView.toCacheKey(keyBuf);
                Object key = codec.getMapKeyDecoder().decode(keyBuf, null);
                Object value = codec.getMapValueDecoder().decode(valueBuf, null);
                cachePut(cacheKey, key, value);
            }

        };
        listener.add(cache);
        instanceId = listener.getInstanceId();

        if (options.getSyncStrategy() != LocalCachedMapOptions.SyncStrategy.NONE) {
            invalidateEntryOnChange = 1;
        }
        if (options.getReconnectionStrategy() == LocalCachedMapOptions.ReconnectionStrategy.LOAD) {
            invalidateEntryOnChange = 2;
            evictionScheduler.schedule(listener.getUpdatesLogName(), cacheUpdateLogTime + TimeUnit.MINUTES.toMillis(1));
        }
    }

    public ExtLocalCacheView getLocalCacheView() {
        return localCacheView;
    }

    private void broadcastLocalCacheStore(V value, ByteBuf mapKey, CacheKey cacheKey) {
        if (storeMode != LocalCachedMapOptions.StoreMode.LOCALCACHE) {
            return;
        }

        if (invalidateEntryOnChange != 0) {
            Object msg;
            if (syncStrategy == LocalCachedMapOptions.SyncStrategy.UPDATE) {
                ByteBuf mapValue = encodeMapValue(value);
                msg = new LocalCachedMapUpdate(instanceId, mapKey, mapValue);
            } else {
                msg = new LocalCachedMapInvalidate(instanceId, cacheKey.getKeyHash());
            }
            listener.getInvalidationTopic().publishAsync(msg);
        }
        mapKey.release();
    }

    private CacheValue cachePut(CacheKey cacheKey, Object key, Object value) {
        if (listener.isDisabled(cacheKey)) {
            return null;
        }

        return cache.put(cacheKey, new CacheValue(key, value));
    }

    private CacheValue cachePutIfAbsent(CacheKey cacheKey, Object key, Object value) {
        if (listener.isDisabled(cacheKey)) {
            return null;
        }

        return cache.putIfAbsent(cacheKey, new CacheValue(key, value));
    }

    private CacheValue cachePutIfExists(CacheKey cacheKey, Object key, Object value) {
        if (listener.isDisabled(cacheKey)) {
            return null;
        }

        while (true) {
            CacheValue v = cache.get(cacheKey);
            if (v != null) {
                if (cache.replace(cacheKey, v, new CacheValue(key, value))) {
                    return v;
                }
            } else {
                return null;
            }
        }
    }

    private CacheValue cacheReplace(CacheKey cacheKey, Object key, Object value) {
        if (listener.isDisabled(cacheKey)) {
            return null;
        }

        return cache.replace(cacheKey, new CacheValue(key, value));
    }

    private boolean cacheReplace(CacheKey cacheKey, Object key, Object oldValue, Object newValue) {
        if (listener.isDisabled(cacheKey)) {
            return false;
        }

        return cache.replace(cacheKey, new CacheValue(key, oldValue), new CacheValue(key, newValue));
    }

    private boolean cacheRemove(CacheKey cacheKey, Object key, Object value) {
        if (listener.isDisabled(cacheKey)) {
            return false;
        }

        return cache.remove(cacheKey, new CacheValue(key, value));
    }

    @Override
    public RFuture sizeAsync() {
        if (storeMode == LocalCachedMapOptions.StoreMode.LOCALCACHE) {
            return new CompletableFutureWrapper<>(cache.size());
        }
        return super.sizeAsync();
    }

    @Override
    public RFuture containsKeyAsync(Object key) {
        checkKey(key);

        CacheKey cacheKey = localCacheView.toCacheKey(key);
        CacheValue cacheValue = cache.get(cacheKey);
        if (cacheValue == null) {
            if (storeMode == LocalCachedMapOptions.StoreMode.LOCALCACHE) {
                if (hasNoLoader()) {
                    return new CompletableFutureWrapper<>(false);
                }

                CompletableFuture future = loadValue((K) key, false);
                CompletableFuture f = future.thenApply(value -> {
                    if (storeCacheMiss || value != null) {
                        cachePut(cacheKey, key, value);
                    }
                    return value != null;
                });
                return new CompletableFutureWrapper<>(f);
            }

            CompletableFuture promise = new CompletableFuture<>();
            promise.thenAccept(value -> {
                if (storeCacheMiss || value != null) {
                    cachePut(cacheKey, key, value);
                }
            });
            return containsKeyAsync(key, promise);
        }

        return new CompletableFutureWrapper<>(cacheValue.getValue() != null);
    }

    @Override
    public RFuture containsValueAsync(Object value) {
        checkValue(value);

        CacheValue cacheValue = new CacheValue(null, value);
        if (!cache.containsValue(cacheValue)) {
            if (storeMode == LocalCachedMapOptions.StoreMode.LOCALCACHE) {
                return new CompletableFutureWrapper<>(false);
            }

            return super.containsValueAsync(value);
        }
        return new CompletableFutureWrapper<>(true);
    }

    @Override
    public RFuture getAsync(Object key) {
        checkKey(key);

        CacheKey cacheKey = localCacheView.toCacheKey(key);
        CacheValue cacheValue = cache.get(cacheKey);
        if (cacheValue != null && (storeCacheMiss || cacheValue.getValue() != null)) {
            GLogger.defaults().debugv("{0} found in local cache", key);
            return new CompletableFutureWrapper<>((V) cacheValue.getValue());
        }

        if (storeMode == LocalCachedMapOptions.StoreMode.LOCALCACHE) {
            if (hasNoLoader()) {
                return new CompletableFutureWrapper((Void) null);
            }

            CompletableFuture future = loadValue((K) key, false);
            CompletableFuture f = future.thenApply(value -> {
                if (storeCacheMiss || value != null) {
                    cachePut(cacheKey, key, value);
                }
                return value;
            });
            return new CompletableFutureWrapper<>(f);
        }

        RFuture future = super.getAsync((K) key);
        CompletionStage result = future.thenApply(value -> {
            if (storeCacheMiss || value != null) {
                cachePut(cacheKey, key, value);
            }
            return value;
        });
        return new CompletableFutureWrapper<>(result);
    }

    protected static byte[] generateLogEntryId(byte[] keyHash) {
        byte[] result = new byte[keyHash.length + 1 + 8];
        result[16] = ':';
        byte[] id = new byte[8];
        ThreadLocalRandom.current().nextBytes(id);

        System.arraycopy(keyHash, 0, result, 0, keyHash.length);
        System.arraycopy(id, 0, result, 17, id.length);
        return result;
    }

    @Override
    protected RFuture putOperationAsync(K key, V value, long ttlTimeout, long maxIdleTimeout,
                                           long maxIdleDelta, long ttlTimeoutDelta) {
        //先通知 再放内存
        return new CompletableFutureWrapper<>((CompletableFuture) putOperationAsync0(key, value)
                .thenCompose(s -> super.putOperationAsync(key, value, ttlTimeout,
                        maxIdleTimeout, maxIdleDelta, ttlTimeoutDelta)));
    }

    @Override
    protected RFuture putOperationAsync(K key, V value) {
        //先通知 再放内存
        return new CompletableFutureWrapper<>((CompletableFuture) putOperationAsync0(key, value)
                .thenCompose(s -> super.putOperationAsync(key, value)));
    }

    private RFuture putOperationAsync0(K key, V value) {
        ByteBuf mapKey = encodeMapKey(key);
        CacheKey cacheKey = localCacheView.toCacheKey(mapKey);
        CacheValue prevValue = cachePut(cacheKey, key, value);
        broadcastLocalCacheStore(value, mapKey, cacheKey);

        if (storeMode == LocalCachedMapOptions.StoreMode.LOCALCACHE) {
            V val = null;
            if (prevValue != null) {
                val = (V) prevValue.getValue();
            }
            return new CompletableFutureWrapper<>(val);
        }

        ByteBuf mapValue = encodeMapValue(HOLDER_VALUE);
        ByteBuf mapValueMessage = encodeMapValue(value);
        byte[] entryId = generateLogEntryId(cacheKey.getKeyHash());
        ByteBuf msg = createSyncMessage(mapKey, mapValueMessage, cacheKey);
        return commandExecutor.evalWriteAsync(getRawName(), codec, RedisCommands.EVAL_MAP_VALUE,
                //"local v = redis.call('hget', KEYS[1], ARGV[1]); "
                //+ "redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); "
                "if ARGV[4] == '1' then "
                        + "redis.call('publish', KEYS[2], ARGV[3]); "
                        + "end;"
                        + "if ARGV[4] == '2' then "
                        + "redis.call('zadd', KEYS[3], ARGV[5], ARGV[6]);"
                        + "redis.call('publish', KEYS[2], ARGV[3]); "
                        + "end;"
                        + "return 1; "
                //+ "return v; ",
                , Arrays.asList(getLocalRawName(), listener.getInvalidationTopicName(), listener.getUpdatesLogName()),
                mapKey, mapValue, msg, invalidateEntryOnChange, System.currentTimeMillis(), entryId);
    }

    protected ByteBuf createSyncMessage(ByteBuf mapKey, ByteBuf mapValue, CacheKey cacheKey) {
        if (syncStrategy == LocalCachedMapOptions.SyncStrategy.UPDATE) {
            return encode(new LocalCachedMapUpdate(instanceId, mapKey, mapValue));
        }
        return encode(new LocalCachedMapInvalidate(instanceId, cacheKey.getKeyHash()));
    }

    @Override
    protected RFuture fastPutOperationAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit) {
        //先通知 再放内存
        return new CompletableFutureWrapper<>((CompletableFuture) fastPutOperationAsync0(key, value)
                .thenCompose(s -> super.fastPutOperationAsync(key, value, ttl,
                        ttlUnit, maxIdleTime, maxIdleUnit)));
    }

    @Override
    protected RFuture fastPutOperationAsync(K key, V value) {
        //先通知 再放内存
        return new CompletableFutureWrapper<>((CompletableFuture) fastPutOperationAsync0(key, value)
                .thenCompose(s -> super.fastPutOperationAsync(key, value)));
    }

    private RFuture fastPutOperationAsync0(K key, V value) {
        ByteBuf encodedKey = encodeMapKey(key);
        CacheKey cacheKey = localCacheView.toCacheKey(encodedKey);

        CacheValue prevValue = cachePut(cacheKey, key, value);
        broadcastLocalCacheStore(value, encodedKey, cacheKey);
        if (storeMode == LocalCachedMapOptions.StoreMode.LOCALCACHE) {
            return new CompletableFutureWrapper<>(prevValue == null);
        }

        ByteBuf encodedValue = encodeMapValue(HOLDER_VALUE);
        ByteBuf encodedValueMessage = encodeMapValue(value);
        byte[] entryId = generateLogEntryId(cacheKey.getKeyHash());
        ByteBuf msg = createSyncMessage(encodedKey, encodedValueMessage, cacheKey);

        return commandExecutor.evalWriteAsync(getRawName(),
                codec, RedisCommands.EVAL_BOOLEAN,
                "if ARGV[4] == '1' then "
                        + "redis.call('publish', KEYS[2], ARGV[3]); "
                        + "end;"
                        + "if ARGV[4] == '2' then "
                        + "redis.call('zadd', KEYS[3], ARGV[5], ARGV[6]);"
                        + "redis.call('publish', KEYS[2], ARGV[3]); "
                        + "end;"
                        //+ "if redis.call('hset', KEYS[1], ARGV[1], ARGV[2]) == 0 then "
                        //+ "return 0; "
                        //+ "end; "
                        + "return 1; "
                , Arrays.