Java Codec类代码示例

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
protected <V, R> void async(boolean readOnlyMode, int slot, MultiDecoder<Object> messageDecoder,
        Codec codec, RedisCommand<V> command, Object[] params, Promise<R> mainPromise, int attempt) {
    if (executed) {
        throw new IllegalStateException("Batch already executed!");
    }
    Entry entry = commands.get(slot);
    if (entry == null) {
        entry = new Entry();
        Entry oldEntry = commands.putIfAbsent(slot, entry);
        if (oldEntry != null) {
            entry = oldEntry;
        }
    }

    if (!readOnlyMode) {
        entry.setReadOnlyMode(false);
    }
    entry.getCommands().add(new CommandEntry(new CommandData<V, R>(mainPromise, messageDecoder, codec, command, params), index.incrementAndGet()));
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
public CommandData(Promise<R> promise, MultiDecoder<Object> messageDecoder, Codec codec, RedisCommand<T> command, Object[] params) {
    this.promise = promise;
    this.command = command;
    this.params = params;
    this.codec = codec;
    this.messageDecoder = messageDecoder;
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
private <T, R> Future<R> evalAsync(boolean readOnlyMode, String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object ... params) {
    Promise<R> mainPromise = connectionManager.newPromise();
    List<Object> args = new ArrayList<Object>(2 + keys.size() + params.length);
    args.add(script);
    args.add(keys.size());
    args.addAll(keys);
    args.addAll(Arrays.asList(params));
    int slot = connectionManager.calcSlot(key);
    async(readOnlyMode, slot, null, codec, evalCommandType, args.toArray(), mainPromise, 0);
    return mainPromise;
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
private void loadComparator() {
    commandExecutor.read(getName(), new SyncOperation<Void>() {
        @Override
        public Void execute(Codec codec, RedisConnection conn) {
            loadComparator(conn);
            return null;
        }
    });
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public boolean contains(final Object o) {
    return commandExecutor.read(getName(), new SyncOperation<Boolean>() {
        @Override
        public Boolean execute(Codec codec, RedisConnection conn) {
            return binarySearch((V)o, codec, conn).getIndex() >= 0;
        }
    });
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
private void remove(final int index) {
    commandExecutor.write(getName(), new SyncOperation<V>() {
        @Override
        public V execute(Codec codec, RedisConnection conn) {
            if (index == 0) {
                return conn.sync(codec, RedisCommands.LPOP, getName());
            }
            while (true) {
                conn.sync(RedisCommands.WATCH, getName());
                List<Object> tail = conn.sync(codec, RedisCommands.LRANGE, getName(), index + 1, size());
                conn.sync(RedisCommands.MULTI);
                conn.sync(codec, RedisCommands.LTRIM, getName(), 0, index - 1);
                if (tail.isEmpty()) {
                    if (((List<Object>)conn.sync(codec, RedisCommands.EXEC)).size() == 1) {
                        return null;
                    }
                } else {
                    tail.add(0, getName());
                    conn.sync(codec, RedisCommands.RPUSH, tail.toArray());
                    if (((List<Object>)conn.sync(codec, RedisCommands.EXEC)).size() == 2) {
                        return null;
                    }
                }
            }
        }
    });
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public boolean add(final V value) {
    return commandExecutor.write(getName(), new SyncOperation<Boolean>() {
        @Override
        public Boolean execute(Codec codec, RedisConnection conn) {
            return add(value, codec, conn);
        }
    });
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public <V> RGeo<V> getGeo(String name, Codec codec) {
    return r.getGeo(name, codec);
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public <V> RSetCache<V> getSetCache(String name, Codec codec) {
    return r.getSetCache(name, codec);
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public <K, V> RMapCache<K, V> getMapCache(String name, Codec codec) {
    return r.getMapCache(name, codec);
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public <V> RBucket<V> getBucket(String name, Codec codec) {
    return r.getBucket(name, codec);
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public RBuckets getBuckets(Codec codec) {
    return r.getBuckets(codec);
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public <V> RHyperLogLog<V> getHyperLogLog(String name, Codec codec) {
    return r.getHyperLogLog(name, codec);
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public <V> RList<V> getList(String name, Codec codec) {
    return r.getList(name, codec);
}
 

import org.redisson.client.codec.Codec; //导入依赖的package包/类
@Override
public <K, V> RListMultimap<K, V> getListMultimap(String name, Codec codec) {
    return r.getListMultimap(name, codec);
}