• Home
• com.wl4g
• infra-common
• 3.1.70
• source code
• SingleJedisClient.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.wl4g.infra.common.jedis.single.SingleJedisClient Maven / Gradle / Ivy

/*
 * Copyright 2017 ~ 2025 the original author or authors. James Wong 
 *
 * 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 com.wl4g.infra.common.jedis.single;

import static com.wl4g.infra.common.lang.Assert2.notNullOf;
import static java.lang.String.format;
import static java.util.Collections.singletonMap;

import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Function;

import com.wl4g.infra.common.jedis.JedisClient;

import redis.clients.jedis.AccessControlLogEntry;
import redis.clients.jedis.AccessControlUser;
import redis.clients.jedis.BinaryJedisPubSub;
import redis.clients.jedis.BitOP;
import redis.clients.jedis.BitPosParams;
import redis.clients.jedis.ClusterReset;
import redis.clients.jedis.DebugParams;
import redis.clients.jedis.GeoCoordinate;
import redis.clients.jedis.GeoRadiusResponse;
import redis.clients.jedis.GeoUnit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPubSub;
import redis.clients.jedis.ListPosition;
import redis.clients.jedis.Module;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.StreamConsumersInfo;
import redis.clients.jedis.StreamEntry;
import redis.clients.jedis.StreamEntryID;
import redis.clients.jedis.StreamGroupInfo;
import redis.clients.jedis.StreamInfo;
import redis.clients.jedis.StreamPendingEntry;
import redis.clients.jedis.StreamPendingSummary;
import redis.clients.jedis.Tuple;
import redis.clients.jedis.ZParams;
import redis.clients.jedis.args.FlushMode;
import redis.clients.jedis.args.ListDirection;
import redis.clients.jedis.args.UnblockType;
import redis.clients.jedis.exceptions.JedisException;
import redis.clients.jedis.params.ClientKillParams;
import redis.clients.jedis.params.GeoAddParams;
import redis.clients.jedis.params.GeoRadiusParam;
import redis.clients.jedis.params.GeoRadiusStoreParam;
import redis.clients.jedis.params.GetExParams;
import redis.clients.jedis.params.LPosParams;
import redis.clients.jedis.params.MigrateParams;
import redis.clients.jedis.params.RestoreParams;
import redis.clients.jedis.params.SetParams;
import redis.clients.jedis.params.XAddParams;
import redis.clients.jedis.params.XClaimParams;
import redis.clients.jedis.params.XPendingParams;
import redis.clients.jedis.params.XReadGroupParams;
import redis.clients.jedis.params.XReadParams;
import redis.clients.jedis.params.XTrimParams;
import redis.clients.jedis.params.ZAddParams;
import redis.clients.jedis.params.ZIncrByParams;
import redis.clients.jedis.resps.KeyedListElement;
import redis.clients.jedis.resps.KeyedZSetElement;
import redis.clients.jedis.util.Slowlog;

/**
 * Single mode Jedis client implemention.
 * 
 * @author James Wong <[email protected]>
 * @version 2020年7月18日 v1.0.0
 * @see
 */
@SuppressWarnings("unchecked")
public class SingleJedisClient implements JedisClient {

    /** Jedis single pool */
    protected final JedisPool jedisPool;

    /** Safety mode, validating storage key. */
    protected final boolean safeMode;

    public SingleJedisClient(JedisPool jedisPool, boolean safeMode) {
        notNullOf(jedisPool, "jedisPool");
        this.jedisPool = jedisPool;
        this.safeMode = safeMode;
    }

    @Override
    public Map getClusterNodes() {
        return singletonMap("default", jedisPool);
    }

    @Override
    public void close() throws IOException {
        doExecuteWithRedis(jedis -> {
            jedis.close();
            return null;
        });
    }

    @Override
    public Boolean copy(byte[] srcKey, byte[] dstKey, int db, boolean replace) {
        return doExecuteWithRedis(jedis -> jedis.copy(srcKey, dstKey, db, replace));
    }

    @Override
    public Boolean copy(byte[] srcKey, byte[] dstKey, boolean replace) {
        return doExecuteWithRedis(jedis -> jedis.copy(srcKey, dstKey, replace));
    }

    @Override
    public Long del(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.del(keys));
    }

    @Override
    public Long unlink(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.unlink(keys));
    }

    @Override
    public Long exists(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.exists(keys));
    }

    @Override
    public byte[] lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to) {
        return doExecuteWithRedis(jedis -> jedis.lmove(srcKey, dstKey, from, to));
    }

    @Override
    public byte[] blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout) {
        return doExecuteWithRedis(jedis -> jedis.blmove(srcKey, dstKey, from, to, timeout));
    }

    @Override
    public List blpop(int timeout, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.blpop(timeout, keys));
    }

    @Override
    public List blpop(double timeout, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.blpop(timeout, keys));
    }

    @Override
    public List brpop(int timeout, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.brpop(timeout, keys));
    }

    @Override
    public List brpop(double timeout, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.brpop(timeout, keys));
    }

    @Override
    public List blpop(byte[]... args) {
        return doExecuteWithRedis(jedis -> jedis.blpop(args));
    }

    @Override
    public List brpop(byte[]... args) {
        return doExecuteWithRedis(jedis -> jedis.brpop(args));
    }

    @Override
    public List bzpopmax(double timeout, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.bzpopmax(timeout, keys));
    }

    @Override
    public List bzpopmin(double timeout, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.bzpopmin(timeout, keys));
    }

    @Override
    public Set keys(byte[] pattern) {
        return doExecuteWithRedis(jedis -> jedis.keys(pattern));
    }

    @Override
    public List mget(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.mget(keys));
    }

    @Override
    public String mset(byte[]... keysvalues) {
        return doExecuteWithRedis(jedis -> jedis.mset(keysvalues));
    }

    @Override
    public Long msetnx(byte[]... keysvalues) {
        return doExecuteWithRedis(jedis -> jedis.msetnx(keysvalues));
    }

    @Override
    public String rename(byte[] oldkey, byte[] newkey) {
        return doExecuteWithRedis(jedis -> jedis.rename(oldkey, newkey));
    }

    @Override
    public Long renamenx(byte[] oldkey, byte[] newkey) {
        return doExecuteWithRedis(jedis -> jedis.renamenx(oldkey, newkey));
    }

    @Override
    public byte[] rpoplpush(byte[] srckey, byte[] dstkey) {
        return doExecuteWithRedis(jedis -> jedis.rpoplpush(srckey, dstkey));
    }

    @Override
    public Set sdiff(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.sdiff(keys));
    }

    @Override
    public Long sdiffstore(byte[] dstkey, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.sdiffstore(dstkey, keys));
    }

    @Override
    public Set sinter(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.sinter(keys));
    }

    @Override
    public Long sinterstore(byte[] dstkey, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.sinterstore(dstkey, keys));
    }

    @Override
    public Long smove(byte[] srckey, byte[] dstkey, byte[] member) {
        return doExecuteWithRedis(jedis -> jedis.smove(srckey, dstkey, member));
    }

    @Override
    public Long sort(byte[] key, SortingParams sortingParameters, byte[] dstkey) {
        return doExecuteWithRedis(jedis -> jedis.sort(key, sortingParameters, dstkey));
    }

    @Override
    public Long sort(byte[] key, byte[] dstkey) {
        return doExecuteWithRedis(jedis -> jedis.sort(key, dstkey));
    }

    @Override
    public Set sunion(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.sunion(keys));
    }

    @Override
    public Long sunionstore(byte[] dstkey, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.sunionstore(dstkey, keys));
    }

    @Override
    public String watch(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.watch(keys));
    }

    @Override
    public Set zdiff(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.zdiff(keys));
    }

    @Override
    public Set zdiffWithScores(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.zdiffWithScores(keys));
    }

    @Override
    public Long zdiffStore(byte[] dstkey, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.zdiffStore(dstkey, keys));
    }

    @Override
    public Set zinter(ZParams params, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.zinter(params, keys));
    }

    @Override
    public Set zinterWithScores(ZParams params, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.zinterWithScores(params, keys));
    }

    @Override
    public Long zinterstore(byte[] dstkey, byte[]... sets) {
        return doExecuteWithRedis(jedis -> jedis.zinterstore(dstkey, sets));
    }

    @Override
    public Long zinterstore(byte[] dstkey, ZParams params, byte[]... sets) {
        return doExecuteWithRedis(jedis -> jedis.zinterstore(dstkey, params, sets));
    }

    @Override
    public Set zunion(ZParams params, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.zunion(params, keys));
    }

    @Override
    public Set zunionWithScores(ZParams params, byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.zunionWithScores(params, keys));
    }

    @Override
    public Long zunionstore(byte[] dstkey, byte[]... sets) {
        return doExecuteWithRedis(jedis -> jedis.zunionstore(dstkey, sets));
    }

    @Override
    public Long zunionstore(byte[] dstkey, ZParams params, byte[]... sets) {
        return doExecuteWithRedis(jedis -> jedis.zunionstore(dstkey, params, sets));
    }

    @Override
    public byte[] brpoplpush(byte[] source, byte[] destination, int timeout) {
        return doExecuteWithRedis(jedis -> jedis.brpoplpush(source, destination, timeout));
    }

    @Override
    public Long publish(byte[] channel, byte[] message) {
        return doExecuteWithRedis(jedis -> jedis.publish(channel, message));
    }

    @Override
    public void subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels) {
        doExecuteWithRedis(jedis -> {
            jedis.subscribe(jedisPubSub, channels);
            return null;
        });
    }

    @Override
    public void psubscribe(BinaryJedisPubSub jedisPubSub, byte[]... patterns) {
        doExecuteWithRedis(jedis -> {
            jedis.psubscribe(jedisPubSub, patterns);
            return null;
        });
    }

    @Override
    public byte[] randomBinaryKey() {
        return doExecuteWithRedis(jedis -> jedis.randomBinaryKey());
    }

    @Override
    public Long bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
        return doExecuteWithRedis(jedis -> jedis.bitop(op, destKey, srcKeys));
    }

    @Override
    public String pfmerge(byte[] destkey, byte[]... sourcekeys) {
        return doExecuteWithRedis(jedis -> jedis.pfmerge(destkey, sourcekeys));
    }

    @Override
    public Long pfcount(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.pfcount(keys));
    }

    @Override
    public Long touch(byte[]... keys) {
        return doExecuteWithRedis(jedis -> jedis.touch(keys));
    }

    @Override
    public List xread(int count, long block, Map streams) {
        return doExecuteWithRedis(jedis -> jedis.xread(count, block, streams));
    }

    @Override
    public List xread(XReadParams xReadParams, Entry... streams) {
        return doExecuteWithRedis(jedis -> jedis.xread(xReadParams, streams));
    }

    @Override
    public List xreadGroup(
            byte[] groupname,
            byte[] consumer,
            int count,
            long block,
            boolean noAck,
            Map streams) {
        return doExecuteWithRedis(jedis -> jedis.xreadGroup(groupname, consumer, count, block, noAck, streams));
    }

    @Override
    public List xreadGroup(
            byte[] groupname,
            byte[] consumer,
            XReadGroupParams xReadGroupParams,
            Entry... streams) {
        return doExecuteWithRedis(jedis -> jedis.xreadGroup(groupname, consumer, xReadGroupParams, streams));
    }

    @Override
    public Long georadiusStore(
            byte[] key,
            double longitude,
            double latitude,
            double radius,
            GeoUnit unit,
            GeoRadiusParam param,
            GeoRadiusStoreParam storeParam) {
        return doExecuteWithRedis(jedis -> jedis.georadiusStore(key, longitude, latitude, radius, unit, param, storeParam));
    }

    @Override
    public Long georadiusByMemberStore(
            byte[] key,
            byte[] member,
            double radius,
            GeoUnit unit,
            GeoRadiusParam param,
            GeoRadiusStoreParam storeParam) {
        return doExecuteWithRedis(jedis -> jedis.georadiusByMemberStore(key, member, radius, unit, param, storeParam));
    }

    @Override
    public Object eval(byte[] script, byte[] keyCount, byte[]... params) {
        return doExecuteWithRedis(jedis -> jedis.eval(script, keyCount, params));
    }

    @Override
    public Object eval(byte[] script, int keyCount, byte[]... params) {
        return doExecuteWithRedis(jedis -> jedis.eval(script, keyCount, params));
    }

    @Override
    public Object eval(byte[] script, List keys, List args) {
        return doExecuteWithRedis(jedis -> jedis.eval(script, keys, args));
    }

    @Override
    public Object eval(byte[] script) {
        return doExecuteWithRedis(jedis -> jedis.eval(script));
    }

    @Override
    public Object evalsha(byte[] sha1) {
        return doExecuteWithRedis(jedis -> jedis.evalsha(sha1));
    }

    @Override
    public Object evalsha(byte[] sha1, List keys, List args) {
        return doExecuteWithRedis(jedis -> jedis.evalsha(sha1, keys, args));
    }

    @Override
    public Object evalsha(byte[] sha1, int keyCount, byte[]... params) {
        return doExecuteWithRedis(jedis -> jedis.evalsha(sha1, keyCount, params));
    }

    @Override
    public List scriptExists(byte[]... sha1) {
        return doExecuteWithRedis(jedis -> jedis.scriptExists(sha1));
    }

    @Override
    public byte[] scriptLoad(byte[] script) {
        return doExecuteWithRedis(jedis -> jedis.scriptLoad(script));
    }

    @Override
    public String scriptFlush() {
        return doExecuteWithRedis(jedis -> jedis.scriptFlush());
    }

    @Override
    public String scriptFlush(FlushMode flushMode) {
        return doExecuteWithRedis(jedis -> jedis.scriptFlush(flushMode));
    }

    @Override
    public String scriptKill() {
        return doExecuteWithRedis(jedis -> jedis.scriptKill());
    }

    @Override
    public String set(byte[] key, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.set(key, value));
    }

    @Override
    public String set(byte[] key, byte[] value, SetParams params) {
        return doExecuteWithRedis(jedis -> jedis.set(key, value, params));
    }

    @Override
    public byte[] get(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.get(key));
    }

    @Override
    public byte[] getDel(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.getDel(key));
    }

    @Override
    public byte[] getEx(byte[] key, GetExParams params) {
        return doExecuteWithRedis(jedis -> jedis.getEx(key, params));
    }

    @Override
    public Boolean exists(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.exists(key));
    }

    @Override
    public Long persist(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.persist(key));
    }

    @Override
    public String type(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.type(key));
    }

    @Override
    public byte[] dump(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.dump(key));
    }

    @Override
    public String restore(byte[] key, long ttl, byte[] serializedValue) {
        return doExecuteWithRedis(jedis -> jedis.restore(key, ttl, serializedValue));
    }

    @Override
    public String restoreReplace(byte[] key, long ttl, byte[] serializedValue) {
        return doExecuteWithRedis(jedis -> jedis.restoreReplace(key, ttl, serializedValue));
    }

    @Override
    public String restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params) {
        return doExecuteWithRedis(jedis -> jedis.restore(key, ttl, serializedValue, params));
    }

    @Override
    public Long expire(byte[] key, long seconds) {
        return doExecuteWithRedis(jedis -> jedis.expire(key, seconds));
    }

    @Override
    public Long pexpire(byte[] key, long milliseconds) {
        return doExecuteWithRedis(jedis -> jedis.pexpire(key, milliseconds));
    }

    @Override
    public Long expireAt(byte[] key, long unixTime) {
        return doExecuteWithRedis(jedis -> jedis.expireAt(key, unixTime));
    }

    @Override
    public Long pexpireAt(byte[] key, long millisecondsTimestamp) {
        return doExecuteWithRedis(jedis -> jedis.pexpireAt(key, millisecondsTimestamp));
    }

    @Override
    public Long ttl(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.ttl(key));
    }

    @Override
    public Long pttl(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.pttl(key));
    }

    @Override
    public Long touch(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.touch(key));
    }

    @Override
    public Boolean setbit(byte[] key, long offset, boolean value) {
        return doExecuteWithRedis(jedis -> jedis.setbit(key, offset, value));
    }

    @Override
    public Boolean setbit(byte[] key, long offset, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.setbit(key, offset, value));
    }

    @Override
    public Boolean getbit(byte[] key, long offset) {
        return doExecuteWithRedis(jedis -> jedis.getbit(key, offset));
    }

    @Override
    public Long setrange(byte[] key, long offset, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.setrange(key, offset, value));
    }

    @Override
    public byte[] getrange(byte[] key, long startOffset, long endOffset) {
        return doExecuteWithRedis(jedis -> jedis.getrange(key, startOffset, endOffset));
    }

    @Override
    public byte[] getSet(byte[] key, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.getSet(key, value));
    }

    @Override
    public Long setnx(byte[] key, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.setnx(key, value));
    }

    @Override
    public String setex(byte[] key, long seconds, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.setex(key, seconds, value));
    }

    @Override
    public String psetex(byte[] key, long milliseconds, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.psetex(key, milliseconds, value));
    }

    @Override
    public Long decrBy(byte[] key, long decrement) {
        return doExecuteWithRedis(jedis -> jedis.decrBy(key, decrement));
    }

    @Override
    public Long decr(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.decr(key));
    }

    @Override
    public Long incrBy(byte[] key, long increment) {
        return doExecuteWithRedis(jedis -> jedis.incrBy(key, increment));
    }

    @Override
    public Double incrByFloat(byte[] key, double increment) {
        return doExecuteWithRedis(jedis -> jedis.incrByFloat(key, increment));
    }

    @Override
    public Long incr(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.incr(key));
    }

    @Override
    public Long append(byte[] key, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.append(key, value));
    }

    @Override
    public byte[] substr(byte[] key, int start, int end) {
        return doExecuteWithRedis(jedis -> jedis.substr(key, start, end));
    }

    @Override
    public Long hset(byte[] key, byte[] field, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.hset(key, field, value));
    }

    @Override
    public Long hset(byte[] key, Map hash) {
        return doExecuteWithRedis(jedis -> jedis.hset(key, hash));
    }

    @Override
    public byte[] hget(byte[] key, byte[] field) {
        return doExecuteWithRedis(jedis -> jedis.hget(key, field));
    }

    @Override
    public Long hsetnx(byte[] key, byte[] field, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.hsetnx(key, field, value));
    }

    @Override
    public String hmset(byte[] key, Map hash) {
        return doExecuteWithRedis(jedis -> jedis.hmset(key, hash));
    }

    @Override
    public List hmget(byte[] key, byte[]... fields) {
        return doExecuteWithRedis(jedis -> jedis.hmget(key, fields));
    }

    @Override
    public Long hincrBy(byte[] key, byte[] field, long value) {
        return doExecuteWithRedis(jedis -> jedis.hincrBy(key, field, value));
    }

    @Override
    public Double hincrByFloat(byte[] key, byte[] field, double value) {
        return doExecuteWithRedis(jedis -> jedis.hincrByFloat(key, field, value));
    }

    @Override
    public Boolean hexists(byte[] key, byte[] field) {
        return doExecuteWithRedis(jedis -> jedis.hexists(key, field));
    }

    @Override
    public Long hdel(byte[] key, byte[]... field) {
        return doExecuteWithRedis(jedis -> jedis.hdel(key, field));
    }

    @Override
    public Long hlen(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.hlen(key));
    }

    @Override
    public Set hkeys(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.hkeys(key));
    }

    @Override
    public List hvals(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.hvals(key));
    }

    @Override
    public Map hgetAll(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.hgetAll(key));
    }

    @Override
    public byte[] hrandfield(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.hrandfield(key));
    }

    @Override
    public List hrandfield(byte[] key, long count) {
        return doExecuteWithRedis(jedis -> jedis.hrandfield(key, count));
    }

    @Override
    public Map hrandfieldWithValues(byte[] key, long count) {
        return doExecuteWithRedis(jedis -> jedis.hrandfieldWithValues(key, count));
    }

    @Override
    public Long rpush(byte[] key, byte[]... args) {
        return doExecuteWithRedis(jedis -> jedis.rpush(key, args));
    }

    @Override
    public Long lpush(byte[] key, byte[]... args) {
        return doExecuteWithRedis(jedis -> jedis.lpush(key, args));
    }

    @Override
    public Long llen(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.llen(key));
    }

    @Override
    public List lrange(byte[] key, long start, long stop) {
        return doExecuteWithRedis(jedis -> jedis.lrange(key, start, stop));
    }

    @Override
    public String ltrim(byte[] key, long start, long stop) {
        return doExecuteWithRedis(jedis -> jedis.ltrim(key, start, stop));
    }

    @Override
    public byte[] lindex(byte[] key, long index) {
        return doExecuteWithRedis(jedis -> jedis.lindex(key, index));
    }

    @Override
    public String lset(byte[] key, long index, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.lset(key, index, value));
    }

    @Override
    public Long lrem(byte[] key, long count, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.lrem(key, count, value));
    }

    @Override
    public byte[] lpop(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.lpop(key));
    }

    @Override
    public List lpop(byte[] key, int count) {
        return doExecuteWithRedis(jedis -> jedis.lpop(key, count));
    }

    @Override
    public Long lpos(byte[] key, byte[] element) {
        return doExecuteWithRedis(jedis -> jedis.lpos(key, element));
    }

    @Override
    public Long lpos(byte[] key, byte[] element, LPosParams params) {
        return doExecuteWithRedis(jedis -> jedis.lpos(key, element, params));
    }

    @Override
    public List lpos(byte[] key, byte[] element, LPosParams params, long count) {
        return doExecuteWithRedis(jedis -> jedis.lpos(key, element, params, count));
    }

    @Override
    public byte[] rpop(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.rpop(key));
    }

    @Override
    public List rpop(byte[] key, int count) {
        return doExecuteWithRedis(jedis -> jedis.rpop(key, count));
    }

    @Override
    public Long sadd(byte[] key, byte[]... member) {
        return doExecuteWithRedis(jedis -> jedis.sadd(key, member));
    }

    @Override
    public Set smembers(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.smembers(key));
    }

    @Override
    public Long srem(byte[] key, byte[]... member) {
        return doExecuteWithRedis(jedis -> jedis.srem(key, member));
    }

    @Override
    public byte[] spop(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.spop(key));
    }

    @Override
    public Set spop(byte[] key, long count) {
        return doExecuteWithRedis(jedis -> jedis.spop(key, count));
    }

    @Override
    public Long scard(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.scard(key));
    }

    @Override
    public Boolean sismember(byte[] key, byte[] member) {
        return doExecuteWithRedis(jedis -> jedis.sismember(key, member));
    }

    @Override
    public List smismember(byte[] key, byte[]... members) {
        return doExecuteWithRedis(jedis -> jedis.smismember(key, members));
    }

    @Override
    public byte[] srandmember(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.srandmember(key));
    }

    @Override
    public List srandmember(byte[] key, int count) {
        return doExecuteWithRedis(jedis -> jedis.srandmember(key, count));
    }

    @Override
    public Long strlen(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.strlen(key));
    }

    @Override
    public Long zadd(byte[] key, double score, byte[] member) {
        return doExecuteWithRedis(jedis -> jedis.zadd(key, score, member));
    }

    @Override
    public Long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
        return doExecuteWithRedis(jedis -> jedis.zadd(key, score, member, params));
    }

    @Override
    public Long zadd(byte[] key, Map scoreMembers) {
        return doExecuteWithRedis(jedis -> jedis.zadd(key, scoreMembers));
    }

    @Override
    public Long zadd(byte[] key, Map scoreMembers, ZAddParams params) {
        return doExecuteWithRedis(jedis -> jedis.zadd(key, scoreMembers, params));
    }

    @Override
    public Double zaddIncr(byte[] key, double score, byte[] member, ZAddParams params) {
        return doExecuteWithRedis(jedis -> jedis.zaddIncr(key, score, member, params));
    }

    @Override
    public Set zrange(byte[] key, long start, long stop) {
        return doExecuteWithRedis(jedis -> jedis.zrange(key, start, stop));
    }

    @Override
    public Long zrem(byte[] key, byte[]... members) {
        return doExecuteWithRedis(jedis -> jedis.zrem(key, members));
    }

    @Override
    public Double zincrby(byte[] key, double increment, byte[] member) {
        return doExecuteWithRedis(jedis -> jedis.zincrby(key, increment, member));
    }

    @Override
    public Double zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params) {
        return doExecuteWithRedis(jedis -> jedis.zincrby(key, increment, member, params));
    }

    @Override
    public Long zrank(byte[] key, byte[] member) {
        return doExecuteWithRedis(jedis -> jedis.zrank(key, member));
    }

    @Override
    public Long zrevrank(byte[] key, byte[] member) {
        return doExecuteWithRedis(jedis -> jedis.zrevrank(key, member));
    }

    @Override
    public Set zrevrange(byte[] key, long start, long stop) {
        return doExecuteWithRedis(jedis -> jedis.zrevrange(key, start, stop));
    }

    @Override
    public Set zrangeWithScores(byte[] key, long start, long stop) {
        return doExecuteWithRedis(jedis -> jedis.zrangeWithScores(key, start, stop));
    }

    @Override
    public Set zrevrangeWithScores(byte[] key, long start, long stop) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeWithScores(key, start, stop));
    }

    @Override
    public byte[] zrandmember(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.zrandmember(key));
    }

    @Override
    public Set zrandmember(byte[] key, long count) {
        return doExecuteWithRedis(jedis -> jedis.zrandmember(key, count));
    }

    @Override
    public Set zrandmemberWithScores(byte[] key, long count) {
        return doExecuteWithRedis(jedis -> jedis.zrandmemberWithScores(key, count));
    }

    @Override
    public Long zcard(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.zcard(key));
    }

    @Override
    public Double zscore(byte[] key, byte[] member) {
        return doExecuteWithRedis(jedis -> jedis.zscore(key, member));
    }

    @Override
    public List zmscore(byte[] key, byte[]... members) {
        return doExecuteWithRedis(jedis -> jedis.zmscore(key, members));
    }

    @Override
    public Tuple zpopmax(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.zpopmax(key));
    }

    @Override
    public Set zpopmax(byte[] key, int count) {
        return doExecuteWithRedis(jedis -> jedis.zpopmax(key, count));
    }

    @Override
    public Tuple zpopmin(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.zpopmin(key));
    }

    @Override
    public Set zpopmin(byte[] key, int count) {
        return doExecuteWithRedis(jedis -> jedis.zpopmin(key, count));
    }

    @Override
    public List sort(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.sort(key));
    }

    @Override
    public List sort(byte[] key, SortingParams sortingParameters) {
        return doExecuteWithRedis(jedis -> jedis.sort(key, sortingParameters));
    }

    @Override
    public Long zcount(byte[] key, double min, double max) {
        return doExecuteWithRedis(jedis -> jedis.zcount(key, min, max));
    }

    @Override
    public Long zcount(byte[] key, byte[] min, byte[] max) {
        return doExecuteWithRedis(jedis -> jedis.zcount(key, min, max));
    }

    @Override
    public Set zrangeByScore(byte[] key, double min, double max) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByScore(key, min, max));
    }

    @Override
    public Set zrangeByScore(byte[] key, byte[] min, byte[] max) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByScore(key, min, max));
    }

    @Override
    public Set zrevrangeByScore(byte[] key, double max, double min) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByScore(key, max, min));
    }

    @Override
    public Set zrangeByScore(byte[] key, double min, double max, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByScore(key, min, max, offset, count));
    }

    @Override
    public Set zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByScore(key, max, min));
    }

    @Override
    public Set zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByScore(key, min, max, offset, count));
    }

    @Override
    public Set zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByScore(key, max, min, offset, count));
    }

    @Override
    public Set zrangeByScoreWithScores(byte[] key, double min, double max) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByScoreWithScores(key, min, max));
    }

    @Override
    public Set zrevrangeByScoreWithScores(byte[] key, double max, double min) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByScoreWithScores(key, max, min));
    }

    @Override
    public Set zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByScoreWithScores(key, min, max, offset, count));
    }

    @Override
    public Set zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByScore(key, max, min, offset, count));
    }

    @Override
    public Set zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByScoreWithScores(key, min, max));
    }

    @Override
    public Set zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByScoreWithScores(key, max, min));
    }

    @Override
    public Set zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByScoreWithScores(key, min, max, offset, count));
    }

    @Override
    public Set zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByScoreWithScores(key, max, min, offset, count));
    }

    @Override
    public Set zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByScoreWithScores(key, max, min, offset, count));
    }

    @Override
    public Long zremrangeByRank(byte[] key, long start, long stop) {
        return doExecuteWithRedis(jedis -> jedis.zremrangeByRank(key, start, stop));
    }

    @Override
    public Long zremrangeByScore(byte[] key, double min, double max) {
        return doExecuteWithRedis(jedis -> jedis.zremrangeByScore(key, min, max));
    }

    @Override
    public Long zremrangeByScore(byte[] key, byte[] min, byte[] max) {
        return doExecuteWithRedis(jedis -> jedis.zremrangeByScore(key, min, max));
    }

    @Override
    public Long zlexcount(byte[] key, byte[] min, byte[] max) {
        return doExecuteWithRedis(jedis -> jedis.zlexcount(key, min, max));
    }

    @Override
    public Set zrangeByLex(byte[] key, byte[] min, byte[] max) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByLex(key, min, max));
    }

    @Override
    public Set zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrangeByLex(key, min, max, offset, count));
    }

    @Override
    public Set zrevrangeByLex(byte[] key, byte[] max, byte[] min) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByLex(key, max, min));
    }

    @Override
    public Set zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count) {
        return doExecuteWithRedis(jedis -> jedis.zrevrangeByLex(key, max, min, offset, count));
    }

    @Override
    public Long zremrangeByLex(byte[] key, byte[] min, byte[] max) {
        return doExecuteWithRedis(jedis -> jedis.zremrangeByLex(key, min, max));
    }

    @Override
    public Long linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value) {
        return doExecuteWithRedis(jedis -> jedis.linsert(key, where, pivot, value));
    }

    @Override
    public Long lpushx(byte[] key, byte[]... arg) {
        return doExecuteWithRedis(jedis -> jedis.lpushx(key, arg));
    }

    @Override
    public Long rpushx(byte[] key, byte[]... arg) {
        return doExecuteWithRedis(jedis -> jedis.rpushx(key, arg));
    }

    @Override
    public Long del(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.del(key));
    }

    @Override
    public Long unlink(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.unlink(key));
    }

    @Override
    public byte[] echo(byte[] arg) {
        return doExecuteWithRedis(jedis -> jedis.echo(arg));
    }

    @Override
    public Long move(byte[] key, int dbIndex) {
        return doExecuteWithRedis(jedis -> jedis.move(key, dbIndex));
    }

    @Override
    public Long bitcount(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.bitcount(key));
    }

    @Override
    public Long bitcount(byte[] key, long start, long end) {
        return doExecuteWithRedis(jedis -> jedis.bitcount(key, start, end));
    }

    @Override
    public Long pfadd(byte[] key, byte[]... elements) {
        return doExecuteWithRedis(jedis -> jedis.pfadd(key, elements));
    }

    @Override
    public long pfcount(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.pfcount(key));
    }

    @Override
    public Long geoadd(byte[] key, double longitude, double latitude, byte[] member) {
        return doExecuteWithRedis(jedis -> jedis.geoadd(key, longitude, latitude, member));
    }

    @Override
    public Long geoadd(byte[] key, Map memberCoordinateMap) {
        return doExecuteWithRedis(jedis -> jedis.geoadd(key, memberCoordinateMap));
    }

    @Override
    public Long geoadd(byte[] key, GeoAddParams params, Map memberCoordinateMap) {
        return doExecuteWithRedis(jedis -> jedis.geoadd(key, params, memberCoordinateMap));
    }

    @Override
    public Double geodist(byte[] key, byte[] member1, byte[] member2) {
        return doExecuteWithRedis(jedis -> jedis.geodist(key, member1, member2));
    }

    @Override
    public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
        return doExecuteWithRedis(jedis -> jedis.geodist(key, member1, member2, unit));
    }

    @Override
    public List geohash(byte[] key, byte[]... members) {
        return doExecuteWithRedis(jedis -> jedis.geohash(key, members));
    }

    @Override
    public List geopos(byte[] key, byte[]... members) {
        return doExecuteWithRedis(jedis -> jedis.geopos(key, members));
    }

    @Override
    public List georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
        return doExecuteWithRedis(jedis -> jedis.georadius(key, longitude, latitude, radius, unit));
    }

    @Override
    public List georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
        return doExecuteWithRedis(jedis -> jedis.georadiusReadonly(key, longitude, latitude, radius, unit));
    }

    @Override
    public List georadius(
            byte[] key,
            double longitude,
            double latitude,
            double radius,
            GeoUnit unit,
            GeoRadiusParam param) {
        return doExecuteWithRedis(jedis -> jedis.georadius(key, longitude, latitude, radius, unit, param));
    }

    @Override
    public List georadiusReadonly(
            byte[] key,
            double longitude,
            double latitude,
            double radius,
            GeoUnit unit,
            GeoRadiusParam param) {
        return doExecuteWithRedis(jedis -> jedis.georadiusReadonly(key, longitude, latitude, radius, unit, param));
    }

    @Override
    public List georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit) {
        return doExecuteWithRedis(jedis -> jedis.georadiusByMember(key, member, radius, unit));
    }

    @Override
    public List georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit) {
        return doExecuteWithRedis(jedis -> jedis.georadiusByMemberReadonly(key, member, radius, unit));
    }

    @Override
    public List georadiusByMember(
            byte[] key,
            byte[] member,
            double radius,
            GeoUnit unit,
            GeoRadiusParam param) {
        return doExecuteWithRedis(jedis -> jedis.georadiusByMember(key, member, radius, unit, param));
    }

    @Override
    public List georadiusByMemberReadonly(
            byte[] key,
            byte[] member,
            double radius,
            GeoUnit unit,
            GeoRadiusParam param) {
        return doExecuteWithRedis(jedis -> jedis.georadiusByMemberReadonly(key, member, radius, unit, param));
    }

    @Override
    public ScanResult> hscan(byte[] key, byte[] cursor) {
        return doExecuteWithRedis(jedis -> jedis.hscan(key, cursor));
    }

    @Override
    public ScanResult> hscan(byte[] key, byte[] cursor, ScanParams params) {
        return doExecuteWithRedis(jedis -> jedis.hscan(key, cursor, params));
    }

    @Override
    public ScanResult sscan(byte[] key, byte[] cursor) {
        return doExecuteWithRedis(jedis -> jedis.sscan(key, cursor));
    }

    @Override
    public ScanResult sscan(byte[] key, byte[] cursor, ScanParams params) {
        return doExecuteWithRedis(jedis -> jedis.sscan(key, cursor, params));
    }

    @Override
    public ScanResult zscan(byte[] key, byte[] cursor) {
        return doExecuteWithRedis(jedis -> jedis.zscan(key, cursor));
    }

    @Override
    public ScanResult zscan(byte[] key, byte[] cursor, ScanParams params) {
        return doExecuteWithRedis(jedis -> jedis.zscan(key, cursor, params));
    }

    @Override
    public List bitfield(byte[] key, byte[]... arguments) {
        return doExecuteWithRedis(jedis -> jedis.bitfield(key, arguments));
    }

    @Override
    public List bitfieldReadonly(byte[] key, byte[]... arguments) {
        return doExecuteWithRedis(jedis -> jedis.bitfieldReadonly(key, arguments));
    }

    @Override
    public Long hstrlen(byte[] key, byte[] field) {
        return doExecuteWithRedis(jedis -> jedis.hstrlen(key, field));
    }

    @Override
    public byte[] xadd(byte[] key, byte[] id, Map hash, long maxLen, boolean approximateLength) {
        return doExecuteWithRedis(jedis -> jedis.xadd(key, id, hash, maxLen, approximateLength));
    }

    @Override
    public byte[] xadd(byte[] key, Map hash, XAddParams params) {
        return doExecuteWithRedis(jedis -> jedis.xadd(key, hash, params));
    }

    @Override
    public Long xlen(byte[] key) {
        return doExecuteWithRedis(jedis -> jedis.xlen(key));
    }

    @Override
    public List xrange(byte[] key, byte[] start, byte[] end) {
        return doExecuteWithRedis(jedis -> jedis.xrange(key, start, end));
    }

    @Override
    public List xrange(byte[] key, byte[] start, byte[] end, int count) {
        return doExecuteWithRedis(jedis -> jedis.xrange(key, start, end, count));
    }

    @Override
    public List xrevrange(byte[] key, byte[] end, byte[] start) {
        return doExecuteWithRedis(jedis -> jedis.xrevrange(key, end, start));
    }

    @Override
    public List xrevrange(byte[] key, byte[] end, byte[] start, int count) {
        return doExecuteWithRedis(jedis -> jedis.xrevrange(key, end, start, count));
    }

    @Override
    public Long xack(byte[] key, byte[] group, byte[]... ids) {
        return doExecuteWithRedis(jedis -> jedis.xack(key, group, ids));
    }

    @Override
    public String xgroupCreate(byte[] key, byte[] consumer, byte[] id, boolean makeStream) {
        return doExecuteWithRedis(jedis -> jedis.xgroupCreate(key, consumer, id, makeStream));
    }

    @Override
    public String xgroupSetID(byte[] key, byte[] consumer, byte[] id) {
        return doExecuteWithRedis(jedis -> jedis.xgroupSetID(key, consumer, id));
    }

    @Override
    public Long xgroupDestroy(byte[] key, byte[] consumer) {
        return doExecuteWithRedis(jedis -> jedis.xgroupDestroy(key, consumer));
    }

    @Override
    public Long xgroupDelConsumer(byte[] key, byte[] consumer, byte[] consumerName) {
        return doExecuteWithRedis(jedis -> jedis.xgroupDelConsumer(key, consumer, consumerName));
    }

    @Override
    public Long xdel(byte[] key, byte[]... ids) {
        return doExecuteWithRedis(jedis -> jedis.xdel(key, ids));
    }

    @Override
    public Long xtrim(byte[] key, long maxLen, boolean approximateLength) {
        return doExecuteWithRedis(jedis -> jedis.xtrim(key, maxLen, approximateLength));
    }

    @Override
    public Long xtrim(byte[] key, XTrimParams params) {
        return doExecuteWithRedis(jedis -> jedis.xtrim(key, params));
    }

    @Override
    public Object xpending(byte[] key, byte[] groupname) {
        return doExecuteWithRedis(jedis -> jedis.xpending(key, groupname));
    }

    @Override
    public List