org.redisson.api.MapOptions Java Examples

public RedissonMapCache(EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor,
                        String name, RedissonClient redisson, MapOptions<K, V> options, WriteBehindService writeBehindService) {
    super(commandExecutor, name, redisson, options, writeBehindService);
    if (evictionScheduler != null) {
        evictionScheduler.schedule(getName(), getTimeoutSetName(), getIdleSetName(), getExpiredChannelName(), getLastAccessTimeSetName());
    }
    this.evictionScheduler = evictionScheduler;
}
 

public RedissonMapCache(Codec codec, EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor,
                        String name, RedissonClient redisson, MapOptions<K, V> options, WriteBehindService writeBehindService) {
    super(codec, commandExecutor, name, redisson, options, writeBehindService);
    if (evictionScheduler != null) {
        evictionScheduler.schedule(getName(), getTimeoutSetName(), getIdleSetName(), getExpiredChannelName(), getLastAccessTimeSetName());
    }
    this.evictionScheduler = evictionScheduler;
}
 

public MapWriteBehindTask(String name, CommandAsyncExecutor commandExecutor, MapOptions<?, ?> options) {
    super();
    this.commandExecutor = commandExecutor;
    this.options = (MapOptions<Object, Object>) options;
    String queueName = RedissonObject.suffixName(name, "write-behind-queue");
    this.writeBehindTasks = new RedissonQueue<>(commandExecutor, queueName, null);
}
 

public MapWriteBehindTask start(String name, MapOptions<?, ?> options) {
    MapWriteBehindTask task = tasks.get(name);
    if (task != null) {
        return task;
    }
    
    task = new MapWriteBehindTask(name, executor, options);
    MapWriteBehindTask prevTask = tasks.putIfAbsent(name, task);
    if (prevTask != null) {
        task = prevTask;
    }
    task.start();
    return task;
}
 

public RedissonMap(CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K, V> options, WriteBehindService writeBehindService) {
    super(commandExecutor, name);
    this.redisson = redisson;
    this.options = options;
    if (options != null && options.getWriteMode() == WriteMode.WRITE_BEHIND) {
        this.writeBehindService = writeBehindService;
        writeBehindTask = writeBehindService.start(name, options);
    } else {
        this.writeBehindService = null;
        writeBehindTask = null;
    }
}
 

public RedissonMap(Codec codec, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K, V> options, WriteBehindService writeBehindService) {
    super(codec, commandExecutor, name);
    this.redisson = redisson;
    this.options = options;
    if (options != null && options.getWriteMode() == WriteMode.WRITE_BEHIND) {
        this.writeBehindService = writeBehindService;
        writeBehindTask = writeBehindService.start(name, options);
    } else {
        this.writeBehindService = null;
        writeBehindTask = null;
    }
}
 

@Override
protected <K, V> RMap<K, V> getWriteBehindTestMap(String name, Map<K, V> map) {
    MapOptions<K, V> options = MapOptions.<K, V>defaults()
                                .writer(createMapWriter(map))
                                .writeMode(WriteMode.WRITE_BEHIND);
    return redisson.getMapCache("test", options);        
}
 

@Override
protected <K, V> RMap<K, V> getWriteBehindTestMap(String name, Map<K, V> map) {
    MapOptions<K, V> options = MapOptions.<K, V>defaults()
                                .writer(createMapWriter(map))
                                .writeMode(WriteMode.WRITE_BEHIND);
    return redisson.getMap("test", options);        
}
 

@Override
public <K, V> RMapCache<K, V> getMapCache(String name, Codec codec, MapOptions<K, V> options) {
  return new TracingRMapCache<>(redissonClient.getMapCache(name, codec, options),
      tracingRedissonHelper);
}
 

@Override
public <K, V> RMapCache<K, V> getMapCache(String name, MapOptions<K, V> options) {
  return new TracingRMapCache<>(redissonClient.getMapCache(name, options), tracingRedissonHelper);
}
 

@Override
public <K, V> RMap<K, V> getMap(String name,
    MapOptions<K, V> options) {
  return new TracingRMap<>(redissonClient.getMap(name, options), tracingRedissonHelper);
}
 

@Override
public <K, V> RMap<K, V> getMap(String name, Codec codec,
    MapOptions<K, V> options) {
  return new TracingRMap<>(redissonClient.getMap(name, codec, options), tracingRedissonHelper);
}
 

@Override
protected <K, V> RMap<K, V> getWriterTestMap(String name, Map<K, V> map) {
    MapOptions<K, V> options = MapOptions.<K, V>defaults().writer(createMapWriter(map));
    return redisson.getMapCache("test", options);        
}
 

@Override
protected <K, V> RMap<K, V> getLoaderTestMap(String name, Map<K, V> map) {
    MapOptions<K, V> options = MapOptions.<K, V>defaults().loader(createMapLoader(map));
    return redisson.getMapCache("test", options);        
}
 

@Override
protected <K, V> RMap<K, V> getLoaderTestMap(String name, Map<K, V> map) {
    MapOptions<K, V> options = MapOptions.<K, V>defaults().loader(createMapLoader(map));
    return redisson.getMap("test", options);        
}
 

@Override
protected <K, V> RMap<K, V> getWriterTestMap(String name, Map<K, V> map) {
    MapOptions<K, V> options = MapOptions.<K, V>defaults().writer(createMapWriter(map));
    return redisson.getMap("test", options);        
}