• Home
• org.redisson
• redisson-all
• 3.38.1
• source code
• RedissonMapCache.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.

org.redisson.RedissonMapCache Maven / Gradle / Ivy

/**
 * Copyright (c) 2013-2024 Nikita Koksharov
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.redisson;

import io.netty.buffer.ByteBuf;
import org.redisson.api.*;
import org.redisson.api.listener.MessageListener;
import org.redisson.api.map.event.*;
import org.redisson.client.RedisClient;
import org.redisson.client.codec.Codec;
import org.redisson.client.codec.IntegerCodec;
import org.redisson.client.codec.LongCodec;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.client.protocol.convertor.NumberConvertor;
import org.redisson.client.protocol.decoder.*;
import org.redisson.codec.BaseEventCodec;
import org.redisson.codec.MapCacheEventCodec;
import org.redisson.command.CommandAsyncExecutor;
import org.redisson.connection.decoder.MapGetAllDecoder;
import org.redisson.eviction.EvictionScheduler;
import org.redisson.misc.CompletableFutureWrapper;

import java.math.BigDecimal;
import java.time.Duration;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

/**
 * 
Map-based cache with ability to set TTL for each entry via
 * {@link #put(Object, Object, long, TimeUnit)} or {@link #putIfAbsent(Object, Object, long, TimeUnit)} methods.
 * And therefore has an complex lua-scripts inside.
 *
 * 
Current redis implementation doesnt have map entry eviction functionality.
 * Thus entries are checked for TTL expiration during any key/value/entry read operation.
 * If key/value/entry expired then it doesn't returns and clean task runs asynchronous.
 * Clean task deletes removes 100 expired entries at once.
 * In addition there is {@link EvictionScheduler}. This scheduler
 * deletes expired entries in time interval between 5 seconds to 2 hours.
 *
 * 
If eviction is not required then it's better to use {@link RedissonMap} object.
 *
 * @author Nikita Koksharov
 *
 * @param  key
 * @param  value
 */
public class RedissonMapCache extends RedissonMap implements RMapCache {

    private final EvictionScheduler evictionScheduler;
    protected String publishCommand;
    private String timeoutSetName;
    private String idleSetName;
    private String lastAccessTimeSetName;
    private String optionsName;
    
    public RedissonMapCache(EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor,
                            String name, RedissonClient redisson, MapCacheOptions options, WriteBehindService writeBehindService) {
        super(commandExecutor, name, redisson, options, writeBehindService);
        this.timeoutSetName = getTimeoutSetName(getRawName());
        this.idleSetName = getIdleSetName(getRawName());
        this.lastAccessTimeSetName = getLastAccessTimeSetName(getRawName());
        this.optionsName = getOptionsName(getRawName());
        if (evictionScheduler != null) {
            evictionScheduler.schedule(getRawName(), timeoutSetName, idleSetName,
                    getExpiredChannelName(), lastAccessTimeSetName, options,
                    commandExecutor.getConnectionManager().getSubscribeService().getPublishCommand());
        }
        this.evictionScheduler = evictionScheduler;
        this.publishCommand = commandExecutor.getConnectionManager().getSubscribeService().getPublishCommand();
    }

    public RedissonMapCache(Codec codec, EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor,
                            String name, RedissonClient redisson, MapCacheOptions options, WriteBehindService writeBehindService) {
        super(codec, commandExecutor, name, redisson, options, writeBehindService);
        this.timeoutSetName = getTimeoutSetName(getRawName());
        this.idleSetName = getIdleSetName(getRawName());
        this.lastAccessTimeSetName = getLastAccessTimeSetName(getRawName());
        this.optionsName = getOptionsName(getRawName());
        if (evictionScheduler != null) {
            evictionScheduler.schedule(getRawName(), timeoutSetName, idleSetName,
                    getExpiredChannelName(), lastAccessTimeSetName, options,
                    commandExecutor.getConnectionManager().getSubscribeService().getPublishCommand());
        }
        this.evictionScheduler = evictionScheduler;
        this.publishCommand = commandExecutor.getConnectionManager().getSubscribeService().getPublishCommand();
    }

    @Override
    public boolean trySetMaxSize(int maxSize) {
        return get(trySetMaxSizeAsync(maxSize));
    }

    public boolean trySetMaxSize(int maxSize, EvictionMode mode) {
        return get(trySetMaxSizeAsync(maxSize, mode));
    }

    @Override
    public RFuture trySetMaxSizeAsync(int maxSize) {
        return trySetMaxSizeAsync(maxSize, EvictionMode.LRU);
    }

    public RFuture trySetMaxSizeAsync(int maxSize, EvictionMode mode) {
        if (maxSize < 0) {
            throw new IllegalArgumentException("maxSize should be greater than zero");
        }

        return commandExecutor.evalWriteNoRetryAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                "redis.call('hsetnx', KEYS[1], 'max-size', ARGV[1]);"
              + "return redis.call('hsetnx', KEYS[1], 'mode', ARGV[2]);",
                Collections.singletonList(optionsName), maxSize, mode);
    }

    @Override
    public V computeIfAbsent(K key, Duration ttl, Function mappingFunction) {
        checkNotBatch();

        checkKey(key);
        Objects.requireNonNull(mappingFunction);

        V value = get(key);
        if (value != null) {
            return value;
        }
        RLock lock = getLock(key);
        lock.lock();
        try {
            value = get(key);
            if (value == null) {
                V newValue = mappingFunction.apply(key);
                if (newValue != null) {
                    fastPut(key, newValue, ttl.toMillis(), TimeUnit.MILLISECONDS);
                    return newValue;
                }
                return null;
            }
            return value;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void setMaxSize(int maxSize) {
        get(setMaxSizeAsync(maxSize));
    }

    public void setMaxSize(int maxSize, EvictionMode mode) {
        get(setMaxSizeAsync(maxSize, mode));
    }

    @Override
    public RFuture setMaxSizeAsync(int maxSize) {
        return setMaxSizeAsync(maxSize, EvictionMode.LRU);
    }

    public RFuture setMaxSizeAsync(int maxSize, EvictionMode mode) {
        if (maxSize < 0) {
            throw new IllegalArgumentException("maxSize should be greater than zero");
        }

        List