Redis的客户端Jedis及Jedis操作Redis命令详解

最新推荐文章于 2024-08-30 14:11:46 发布
最新推荐文章于 2024-08-30 14:11:46 发布
阅读量986 收藏 2
点赞数 1
分类专栏： Redis 文章标签： redis
Jedis获取Redis连接详解:[url]http://donald-draper.iteye.com/blog/2347121[/url]
Redis Protocol specification：[url]https://redis.io/topics/protocol[/url]
redis协议：[url]http://doc.redisfans.com/topic/protocol.html[/url]
上一篇中，我们探究了一下Jedis获取Redis连接过程，具体如下：
JedisPoolConfig的功能主要是配置连接最大空闲时间，存活数量，及等待时间；
JedisPoolConfig的父类Config为GenericObjectPool的静态内部类，与连接池有关的属性在Config中，而属性的设置在JedisPoolConfig中；JedisPool的初始化主要是GenericObjectPool初始化，主要是初始化连接池，连接数，空闲时间，等待时间，连接池，候选连接池，初始化候选连接初始化执行器，JedisFactory。JedisFactory工厂为JedisPool的内部类，JedisFactory的属性有host，port，timeout，password和database；JedisFactory的主要功能为管理（创建，关闭，验证）redis连接jedis。从连接池获取jedis连接资源，实际上看是从JedisPool的父类pool中获取，而pool又委托给JedisFactory，最后由JedisFactory创建redis连接jedis。

今天我们来看一下，jedis客户端如何操作redis服务器： 
public class Jedis extends BinaryJedis
    implements JedisCommands
{
    //这个在前面JedisFactory创建jedis客户端时，所用的构造方法
     public Jedis(String host, int port, int timeout)
    {
        super(host, port, timeout);
    }

}

来看其父类BinaryJedis
//BinaryJedis 
public class BinaryJedis
    implements BinaryJedisCommands
{
    protected Client client;//redis连接客户端
      public BinaryJedis(String host, int port, int timeout)
    {
        client = null;
        client = new Client(host, port);
        client.setTimeout(timeout);
    }
}


//再来看Client的构造 
public class Client extends BinaryClient
    implements Commands
{
  public Client(String host, int port)
    {
        super(host, port);
    }
}


再看BinaryClient 
public class BinaryClient extends Connection
{
    private boolean isInMulti;//是否是事务
    private String password;//密码 
    private long db;//数据库

   public BinaryClient(String host, int port)
    {
        super(host, port);
    }
}


再来看Connection 
public class Connection
{
    private String host;//ip
    private int port;//端口
    private Socket socket;//与redis连接socket
    private RedisOutputStream outputStream;//输出流
    private RedisInputStream inputStream;//输入流
    private int pipelinedCommands;//管道命令数
    private int timeout;//超时时间

       public Connection(String host, int port)
    {
        this.port = 6379;
        pipelinedCommands = 0;
        timeout = 2000;
        this.host = host;
        this.port = port;
    }
}

从JedisFactory创建redis连接jedis的构造方法，来看Jedis构造所做的事情为，初始化
BinaryJedis，即初始化Client的host和port，BinaryJedis有个Client，；Client初始化，其实
是初始化BinaryClient，即初始化Connection，Connection为实际与redis通信的连接，
BinaryClient有连三个属性分别为 isInMulti（是否是事务）password，db（数据库），
Connection有几个内部变量分别为host,port,socket,outputStream,inputStream,pipelinedCommands,timeout

下面再来看Jedis的另一种构造方式 
 public Jedis(JedisShardInfo shardInfo)
    {
        super(shardInfo);
    }

//JedisShardInfo 
public class JedisShardInfo extends ShardInfo
{
    private int timeout;
    private String host;
    private int port;
    private String password;
    private String name;
      public JedisShardInfo(String host, int port, int timeout)
    {
        this(host, port, timeout, 1);
    }
     public Jedis createResource()
    {
        return new Jedis(this);
    }
    //创建jedis客户端
    public volatile Object createResource()
    {
        return createResource();
    }
}

//ShardInfo 
public abstract class ShardInfo
{
    public ShardInfo()
    {
    }
    public ShardInfo(int weight)
    {
        this.weight = weight;
    }
    public int getWeight()
    {
        return weight;
    }
    protected abstract Object createResource();
    public abstract String getName();
    private int weight;
}

从JedisShardInfo可以看出，JedisShardInfo创建jedis客户端，实际上为Jedis，及JedisShardInfo依托于Jedis。

下面看一jedis的验证 
jedis.auth("redis");

//Jedis 
public String auth(String password)
    {
        //检查是否是事务
        checkIsInMulti();
	//验证密码
        client.auth(password);
	//返回redis恢复字符串
        return client.getStatusCodeReply();
    }


分3步来看：
1.检查是否是事务 
checkIsInMulti();

//Jedis 
 protected void checkIsInMulti()
    {
        if(client.isInMulti())
            throw new JedisDataException("Cannot use Jedis when in Multi. Please use JedisTransaction instead.");
        else
            return;
    }

//Client 
 public boolean isInMulti()
    {
        return isInMulti;
    }

2.验证密码 
client.auth(password);

//Client 
 public void auth(String password)
    {
        //设置密码
        setPassword(password);
	//发送命令
        sendCommand(Protocol.Command.AUTH, new String[] {
            password
        });
    }

//设置密码 
 public void setPassword(String password)
    {
        this.password = password;
    }

//发送命令 
 protected transient Connection sendCommand(Protocol.Command cmd, String args[])
    {
       //将发送内容，转换编码字节
        byte bargs[][] = new byte[args.length][];
        for(int i = 0; i < args.length; i++)
            bargs[i] = SafeEncoder.encode(args[i]);
        //发送字节流
        return sendCommand(cmd, bargs);
    }

编码字符
//SafeEncoder 
public static byte[] encode(String str)
    {
        if(str == null)
            throw new JedisDataException("value sent to redis cannot be null");
        return str.getBytes("UTF-8");
    }

发送字节流 
protected transient Connection sendCommand(Protocol.Command cmd, byte args[][])
    {
        //连接redis
        connect();
	//协议发送命令
        Protocol.sendCommand(outputStream, cmd, args);
        pipelinedCommands++;
        return this;
    }

创建连接redis Socket 
 connect();

//Connection 
public void connect()
    {
        if(!isConnected())
            try
            {
	        //如果没有redis建立连接则，则创建socket，并初始化RedisOutputStream，RedisInputStream
                socket = new Socket();
                socket.setReuseAddress(true);
                socket.setKeepAlive(true);
                socket.setTcpNoDelay(true);
                socket.setSoLinger(true, 0);
                socket.connect(new InetSocketAddress(host, port), timeout);
                socket.setSoTimeout(timeout);
                outputStream = new RedisOutputStream(socket.getOutputStream());
                inputStream = new RedisInputStream(socket.getInputStream());
            }
            catch(IOException ex)
            {
                throw new JedisConnectionException(ex);
            }
    }

协议发送命令 
Protocol.sendCommand(outputStream, cmd, args);

//Protocol
//发送验证命令和密码字节流 
public static transient void sendCommand(RedisOutputStream os, Command command, byte args[][])
    {
        sendCommand(os, command.raw, args);
    }

 private static transient void sendCommand(RedisOutputStream os, byte command[], byte args[][])
    {
        try
        {    
	   //发送内容长度
            os.write((byte)42);
            os.writeIntCrLf(args.length + 1);
	     //发送命令长度
            os.write((byte)36);
            os.writeIntCrLf(command.length);
	    //发送命令
            os.write(command);
	    //发送协议内容分割符
            os.writeCrLf();
            byte arr$[][] = args;
            int len$ = arr$.length;
            for(int i$ = 0; i$ < len$; i$++)
            {
	       //分字节发送内容
                byte arg[] = arr$[i$];
                os.write((byte)36);
                os.writeIntCrLf(arg.length);
                os.write(arg);
                os.writeCrLf();
            }

        }
        catch(IOException e)
        {
            throw new JedisConnectionException(e);
        }
    }

再来看字节发送输出流 
public final class RedisOutputStream extends FilterOutputStream
{
    protected final byte buf[];//输出流缓冲区
    protected int count;//缓冲区当前大小
     private static final int sizeTable[] = {
        9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, 2147483647
    };
    public RedisOutputStream(OutputStream out)
    {
        this(out, 8192);
    }
     public RedisOutputStream(OutputStream out, int size)
    {
        super(out);
        if(size <= 0)
        {
            throw new IllegalArgumentException("Buffer size <= 0");
        } else
        {
            buf = new byte[size];
            return;
        }
    }
    public void write(byte b)
        throws IOException
    {
        buf[count++] = b;
        if(count == buf.length)
	    //如果缓存已满，则刷新缓冲区
            flushBuffer();
    }
    //刷新缓冲区
    private void flushBuffer()
        throws IOException
    {
        if(count > 0)
        {
            out.write(buf, 0, count);
            count = 0;
        }
    }
    public void writeIntCrLf(int value)
        throws IOException
    {
        if(value < 0)
        {
            write(45);
            value = -value;
        }
        int size;
        for(size = 0; value > sizeTable[size]; size++);
	//如果缓冲区剩余大小不够用，则刷新缓存
        if(++size >= buf.length - count)
            flushBuffer();
        int charPos = count + size;
        while(value >= 65536) 
        {
            int q = value / 100;
            int r = value - ((q << 6) + (q << 5) + (q << 2));
            value = q;
            buf[--charPos] = DigitOnes[r];
            buf[--charPos] = DigitTens[r];
        }
        do
        {
            int q = value * 52429 >>> 19;
            int r = value - ((q << 3) + (q << 1));
            buf[--charPos] = digits[r];
            value = q;
        } while(value != 0);
        count += size;
        writeCrLf();
    }
    //协议内容分割符
    public void writeCrLf()
        throws IOException
    {
        if(2 >= buf.length - count)
            flushBuffer();
        buf[count++] = 13;
        buf[count++] = 10;
    }

3.返回redis回复内容 
return client.getStatusCodeReply();

//Connection 
protected String getStatusCodeReply()
    {
        //刷新输出流
        flush();
        pipelinedCommands--;
	//协议读取输入流
        byte resp[] = (byte[])(byte[])Protocol.read(inputStream);
        if(null == resp)
            return null;
        else
	    //解码输入流
            return SafeEncoder.encode(resp);
    }

刷新输出流 
protected void flush()
    {
        try
        {
            outputStream.flush();
        }
        catch(IOException e)
        {
            throw new JedisConnectionException(e);
        }
    }

//RedisOutputStream 
public void flush()
        throws IOException
    {
        flushBuffer();
        out.flush();
    }


协议读取输入流 
byte resp[] = (byte[])(byte[])Protocol.read(inputStream);

//Protocol
//协议读取输入流 
 public static Object read(RedisInputStream is)
    {
        return process(is);
    }
  private static Object process(RedisInputStream is)
    {
        byte b;
        b = is.readByte();
        if(b == 45)
        { 
	    //第一个字节为45则，redis返回错误
            processError(is);
            break MISSING_BLOCK_LABEL_103;
        }
        if(b == 42)
	    //第一个字节为42则，事务返回
            return processMultiBulkReply(is);
        if(b == 58)
	    //第一个字节为58则，返回为整数
            return processInteger(is);
        if(b == 36)
	    //第一个字节为36则，返回为字符串
            return processBulkReply(is);
        if(b == 43)
	    //第一个字节为43则，返回为状态码
            return processStatusCodeReply(is);
        try
        {
            throw new JedisConnectionException((new StringBuilder()).append("Unknown reply: ").append((char)b).toString());
        }
        catch(IOException e)
        {
            throw new JedisConnectionException(e);
        }
        return null;
    }

    //第一个字节为45则，redis返回错误
       private static void processError(RedisInputStream is)
    {
        String message = is.readLine();
        throw new JedisDataException(message);
    }
     //第一个字节为42则，事务返回
     private static List processMultiBulkReply(RedisInputStream is)
    {
        //事务返回数量
        int num = Integer.parseInt(is.readLine());
        if(num == -1)
            return null;
        List ret = new ArrayList(num);
        for(int i = 0; i < num; i++)
            try
            {
                ret.add(process(is));
            }
            catch(JedisDataException e)
            {
                ret.add(e);
            }

        return ret;
    }
    //第一个字节为58则，返回为整数
     private static Long processInteger(RedisInputStream is)
    {
        String num = is.readLine();
        return Long.valueOf(num);
    }
    //第一个字节为36则，返回为字符串
     private static byte[] processBulkReply(RedisInputStream is)
    {   
        //返回数量
        int len = Integer.parseInt(is.readLine());
        if(len == -1)
            return null;
        byte read[] = new byte[len];
        int offset = 0;
        try
        {
            while(offset < len) 
                offset += is.read(read, offset, len - offset);
            is.readByte();
            is.readByte();
        }
        catch(IOException e)
        {
            throw new JedisConnectionException(e);
        }
        return read;
    }
     //第一个字节为43则，返回为状态码
 private static byte[] processStatusCodeReply(RedisInputStream is)
    {
        return SafeEncoder.encode(is.readLine());
    }

解码输入流 
if(null == resp)
       return null;
else
//解码输入流
return SafeEncoder.encode(resp);

 public static String encode(byte data[])
    {
        return new String(data, "UTF-8");
        UnsupportedEncodingException e;
        e;
        throw new JedisException(e);
    }

至此密码验证完毕，我们来小节一下
密码验证过程中，先Client检查是不是事务，然后由Client，设置密码，发送密码验证命令；在这个过程中，Connection创建与redis通信的socket，并初始化Connection的RedisOutputStream，RedisInputStream，然后由Protocol发送密码验证命令Command.AUTH和密码字节流到Redis；最后由Protocol从RedisInputStream中，读取redis的命令执行的结果。

再来看看，jedis设置键的值 

//Jedis
jedis.set("name","donald");//向key-->name中放入了value-->donald  
 public String set(String key, String value)
    {
        //检查是事务
        checkIsInMulti();
	//设置键的值
        client.set(key, value);
	//获取redis执行键设值Command.SET命令后的回复内容，这个我们在前面已分析过
        return client.getStatusCodeReply();
    }

设置键的值 
client.set(key, value);


public void set(String key, String value)
    {
        //委托给BinaryClient
        set(SafeEncoder.encode(key), SafeEncoder.encode(value));
    }
//BinaryClient
public class BinaryClient extends Connection
{
 public void set(byte key[], byte value[])
    {

        //发送命令键设置命令
        sendCommand(Protocol.Command.SET, new byte[][] {
            key, value
        });
    }
}

//Connection 
protected transient Connection sendCommand(Protocol.Command cmd, byte args[][])
    {
        connect();
        Protocol.sendCommand(outputStream, cmd, args);
        pipelinedCommands++;
        return this;
    }

再来看 
jedis.get("name")

//Jedis 
  public String get(String key)
    {
        checkIsInMulti();
        client.sendCommand(Protocol.Command.GET, new String[] {
            key
        });
        return client.getBulkReply();
    }

//Connection 
protected transient Connection sendCommand(Protocol.Command cmd, String args[])
    {
        byte bargs[][] = new byte[args.length][];
        for(int i = 0; i < args.length; i++)
            bargs[i] = SafeEncoder.encode(args[i]);

        return sendCommand(cmd, bargs);
    }

总结：
[color=green]从JedisFactory创建redis连接jedis的构造方法，来看Jedis构造所做的事情为，初始化
BinaryJedis，即初始化Client的host和port，BinaryJedis有个Client，；Client初始化，其实
是初始化BinaryClient，即初始化Connection，Connection为实际与redis通信的连接，
BinaryClient有连三个属性分别为 isInMulti（是否是事务）password，db（数据库），
Connection有几个内部变量分别为host,port,socket,outputStream,inputStream
pipelinedCommands,timeout。Jedis执行命令的过程中，先Client检查是不是事务，然后由Client，执行命令及命令内容；在这个过程中，Connection创建与redis通信的socket，并初始化Connection的RedisOutputStream，RedisInputStream，然后由Protocol发送命令Command.*和内容字节串到Redis；最后由Protocol从RedisInputStream中，读取redis的命令执行的结果。从分析命令和内容字节串来看，redis发送命令的时候，先发送一个字节的长度，再发送内容字节串，最后以\r\n （CRLF）结束一次命令的发送。[/color]
redis协议：[url]http://doc.redisfans.com/topic/protocol.html[/url]

//Protocol 
public final class Protocol
{
//从Command可以看出，其实一个Enum，从里面的命令枚举变量，我们是不是很熟悉。
public static final class Command extends Enum
    {

        public static Command[] values()
        {
            return (Command[])$VALUES.clone();
        }

        public static Command valueOf(String name)
        {
            return (Command)Enum.valueOf(redis/clients/jedis/Protocol$Command, name);
        }

        public static final Command PING;
        public static final Command SET;
        public static final Command GET;
        public static final Command QUIT;
        public static final Command EXISTS;
        public static final Command DEL;
        public static final Command TYPE;
        public static final Command FLUSHDB;
        public static final Command KEYS;
        public static final Command RANDOMKEY;
        public static final Command RENAME;
        public static final Command RENAMENX;
        public static final Command RENAMEX;
        public static final Command DBSIZE;
        public static final Command EXPIRE;
        public static final Command EXPIREAT;
        public static final Command TTL;
        public static final Command SELECT;
        public static final Command MOVE;
        public static final Command FLUSHALL;
        public static final Command GETSET;
        public static final Command MGET;
        public static final Command SETNX;
        public static final Command SETEX;
        public static final Command MSET;
        public static final Command MSETNX;
        public static final Command DECRBY;
        public static final Command DECR;
        public static final Command INCRBY;
        public static final Command INCR;
        public static final Command APPEND;
        public static final Command SUBSTR;
        public static final Command HSET;
        public static final Command HGET;
        public static final Command HSETNX;
        public static final Command HMSET;
        public static final Command HMGET;
        public static final Command HINCRBY;
        public static final Command HEXISTS;
        public static final Command HDEL;
        public static final Command HLEN;
        public static final Command HKEYS;
        public static final Command HVALS;
        public static final Command HGETALL;
        public static final Command RPUSH;
        public static final Command LPUSH;
        public static final Command LLEN;
        public static final Command LRANGE;
        public static final Command LTRIM;
        public static final Command LINDEX;
        public static final Command LSET;
        public static final Command LREM;
        public static final Command LPOP;
        public static final Command RPOP;
        public static final Command RPOPLPUSH;
        public static final Command SADD;
        public static final Command SMEMBERS;
        public static final Command SREM;
        public static final Command SPOP;
        public static final Command SMOVE;
        public static final Command SCARD;
        public static final Command SISMEMBER;
        public static final Command SINTER;
        public static final Command SINTERSTORE;
        public static final Command SUNION;
        public static final Command SUNIONSTORE;
        public static final Command SDIFF;
        public static final Command SDIFFSTORE;
        public static final Command SRANDMEMBER;
        public static final Command ZADD;
        public static final Command ZRANGE;
        public static final Command ZREM;
        public static final Command ZINCRBY;
        public static final Command ZRANK;
        public static final Command ZREVRANK;
        public static final Command ZREVRANGE;
        public static final Command ZCARD;
        public static final Command ZSCORE;
        public static final Command MULTI;
        public static final Command DISCARD;
        public static final Command EXEC;
        public static final Command WATCH;
        public static final Command UNWATCH;
        public static final Command SORT;
        public static final Command BLPOP;
        public static final Command BRPOP;
        public static final Command AUTH;
        public static final Command SUBSCRIBE;
        public static final Command PUBLISH;
        public static final Command UNSUBSCRIBE;
        public static final Command PSUBSCRIBE;
        public static final Command PUNSUBSCRIBE;
        public static final Command ZCOUNT;
        public static final Command ZRANGEBYSCORE;
        public static final Command ZREVRANGEBYSCORE;
        public static final Command ZREMRANGEBYRANK;
        public static final Command ZREMRANGEBYSCORE;
        public static final Command ZUNIONSTORE;
        public static final Command ZINTERSTORE;
        public static final Command SAVE;
        public static final Command BGSAVE;
        public static final Command BGREWRITEAOF;
        public static final Command LASTSAVE;
        public static final Command SHUTDOWN;
        public static final Command INFO;
        public static final Command MONITOR;
        public static final Command SLAVEOF;
        public static final Command CONFIG;
        public static final Command STRLEN;
        public static final Command SYNC;
        public static final Command LPUSHX;
        public static final Command PERSIST;
        public static final Command RPUSHX;
        public static final Command ECHO;
        public static final Command LINSERT;
        public static final Command DEBUG;
        public static final Command BRPOPLPUSH;
        public static final Command SETBIT;
        public static final Command GETBIT;
        public static final Command SETRANGE;
        public static final Command GETRANGE;
        public static final Command EVAL;
        public static final Command EVALSHA;
        public static final Command SCRIPT;
        public static final Command SLOWLOG;
        public static final Command OBJECT;
	//命令字节串
        public final byte raw[] = SafeEncoder.encode(name());
        private static final Command $VALUES[];

        static 
        {
            PING = new Command("PING", 0);
            SET = new Command("SET", 1);
            GET = new Command("GET", 2);
            QUIT = new Command("QUIT", 3);
            EXISTS = new Command("EXISTS", 4);
            DEL = new Command("DEL", 5);
            TYPE = new Command("TYPE", 6);
            FLUSHDB = new Command("FLUSHDB", 7);
            KEYS = new Command("KEYS", 8);
            RANDOMKEY = new Command("RANDOMKEY", 9);
            RENAME = new Command("RENAME", 10);
            RENAMENX = new Command("RENAMENX", 11);
            RENAMEX = new Command("RENAMEX", 12);
            DBSIZE = new Command("DBSIZE", 13);
            EXPIRE = new Command("EXPIRE", 14);
            EXPIREAT = new Command("EXPIREAT", 15);
            TTL = new Command("TTL", 16);
            SELECT = new Command("SELECT", 17);
            MOVE = new Command("MOVE", 18);
            FLUSHALL = new Command("FLUSHALL", 19);
            GETSET = new Command("GETSET", 20);
            MGET = new Command("MGET", 21);
            SETNX = new Command("SETNX", 22);
            SETEX = new Command("SETEX", 23);
            MSET = new Command("MSET", 24);
            MSETNX = new Command("MSETNX", 25);
            DECRBY = new Command("DECRBY", 26);
            DECR = new Command("DECR", 27);
            INCRBY = new Command("INCRBY", 28);
            INCR = new Command("INCR", 29);
            APPEND = new Command("APPEND", 30);
            SUBSTR = new Command("SUBSTR", 31);
            HSET = new Command("HSET", 32);
            HGET = new Command("HGET", 33);
            HSETNX = new Command("HSETNX", 34);
            HMSET = new Command("HMSET", 35);
            HMGET = new Command("HMGET", 36);
            HINCRBY = new Command("HINCRBY", 37);
            HEXISTS = new Command("HEXISTS", 38);
            HDEL = new Command("HDEL", 39);
            HLEN = new Command("HLEN", 40);
            HKEYS = new Command("HKEYS", 41);
            HVALS = new Command("HVALS", 42);
            HGETALL = new Command("HGETALL", 43);
            RPUSH = new Command("RPUSH", 44);
            LPUSH = new Command("LPUSH", 45);
            LLEN = new Command("LLEN", 46);
            LRANGE = new Command("LRANGE", 47);
            LTRIM = new Command("LTRIM", 48);
            LINDEX = new Command("LINDEX", 49);
            LSET = new Command("LSET", 50);
            LREM = new Command("LREM", 51);
            LPOP = new Command("LPOP", 52);
            RPOP = new Command("RPOP", 53);
            RPOPLPUSH = new Command("RPOPLPUSH", 54);
            SADD = new Command("SADD", 55);
            SMEMBERS = new Command("SMEMBERS", 56);
            SREM = new Command("SREM", 57);
            SPOP = new Command("SPOP", 58);
            SMOVE = new Command("SMOVE", 59);
            SCARD = new Command("SCARD", 60);
            SISMEMBER = new Command("SISMEMBER", 61);
            SINTER = new Command("SINTER", 62);
            SINTERSTORE = new Command("SINTERSTORE", 63);
            SUNION = new Command("SUNION", 64);
            SUNIONSTORE = new Command("SUNIONSTORE", 65);
            SDIFF = new Command("SDIFF", 66);
            SDIFFSTORE = new Command("SDIFFSTORE", 67);
            SRANDMEMBER = new Command("SRANDMEMBER", 68);
            ZADD = new Command("ZADD", 69);
            ZRANGE = new Command("ZRANGE", 70);
            ZREM = new Command("ZREM", 71);
            ZINCRBY = new Command("ZINCRBY", 72);
            ZRANK = new Command("ZRANK", 73);
            ZREVRANK = new Command("ZREVRANK", 74);
            ZREVRANGE = new Command("ZREVRANGE", 75);
            ZCARD = new Command("ZCARD", 76);
            ZSCORE = new Command("ZSCORE", 77);
            MULTI = new Command("MULTI", 78);
            DISCARD = new Command("DISCARD", 79);
            EXEC = new Command("EXEC", 80);
            WATCH = new Command("WATCH", 81);
            UNWATCH = new Command("UNWATCH", 82);
            SORT = new Command("SORT", 83);
            BLPOP = new Command("BLPOP", 84);
            BRPOP = new Command("BRPOP", 85);
            AUTH = new Command("AUTH", 86);
            SUBSCRIBE = new Command("SUBSCRIBE", 87);
            PUBLISH = new Command("PUBLISH", 88);
            UNSUBSCRIBE = new Command("UNSUBSCRIBE", 89);
            PSUBSCRIBE = new Command("PSUBSCRIBE", 90);
            PUNSUBSCRIBE = new Command("PUNSUBSCRIBE", 91);
            ZCOUNT = new Command("ZCOUNT", 92);
            ZRANGEBYSCORE = new Command("ZRANGEBYSCORE", 93);
            ZREVRANGEBYSCORE = new Command("ZREVRANGEBYSCORE", 94);
            ZREMRANGEBYRANK = new Command("ZREMRANGEBYRANK", 95);
            ZREMRANGEBYSCORE = new Command("ZREMRANGEBYSCORE", 96);
            ZUNIONSTORE = new Command("ZUNIONSTORE", 97);
            ZINTERSTORE = new Command("ZINTERSTORE", 98);
            SAVE = new Command("SAVE", 99);
            BGSAVE = new Command("BGSAVE", 100);
            BGREWRITEAOF = new Command("BGREWRITEAOF", 101);
            LASTSAVE = new Command("LASTSAVE", 102);
            SHUTDOWN = new Command("SHUTDOWN", 103);
            INFO = new Command("INFO", 104);
            MONITOR = new Command("MONITOR", 105);
            SLAVEOF = new Command("SLAVEOF", 106);
            CONFIG = new Command("CONFIG", 107);
            STRLEN = new Command("STRLEN", 108);
            SYNC = new Command("SYNC", 109);
            LPUSHX = new Command("LPUSHX", 110);
            PERSIST = new Command("PERSIST", 111);
            RPUSHX = new Command("RPUSHX", 112);
            ECHO = new Command("ECHO", 113);
            LINSERT = new Command("LINSERT", 114);
            DEBUG = new Command("DEBUG", 115);
            BRPOPLPUSH = new Command("BRPOPLPUSH", 116);
            SETBIT = new Command("SETBIT", 117);
            GETBIT = new Command("GETBIT", 118);
            SETRANGE = new Command("SETRANGE", 119);
            GETRANGE = new Command("GETRANGE", 120);
            EVAL = new Command("EVAL", 121);
            EVALSHA = new Command("EVALSHA", 122);
            SCRIPT = new Command("SCRIPT", 123);
            SLOWLOG = new Command("SLOWLOG", 124);
            OBJECT = new Command("OBJECT", 125);
            $VALUES = (new Command[] {
                PING, SET, GET, QUIT, EXISTS, DEL, TYPE, FLUSHDB, KEYS, RANDOMKEY, 
                RENAME, RENAMENX, RENAMEX, DBSIZE, EXPIRE, EXPIREAT, TTL, SELECT, MOVE, FLUSHALL, 
                GETSET, MGET, SETNX, SETEX, MSET, MSETNX, DECRBY, DECR, INCRBY, INCR, 
                APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HEXISTS, HDEL, 
                HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, 
                LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, 
                SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, 
                ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, 
                EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, 
                PSUBSCRIBE, PUNSUBSCRIBE, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, 
                BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, 
                LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, 
                GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT
            });
        }

        private Command(String s, int i)
        {
            super(s, i);
        }
    }
}

//SafeEncoder 
package redis.clients.util;

import java.io.UnsupportedEncodingException;
import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.exceptions.JedisException;

public class SafeEncoder
{

    public SafeEncoder()
    {
    }

    public static transient byte[][] encodeMany(String strs[])
    {
        byte many[][] = new byte[strs.length][];
        for(int i = 0; i < strs.length; i++)
            many[i] = encode(strs[i]);

        return many;
    }

    public static byte[] encode(String str)
    {
        if(str == null)
            throw new JedisDataException("value sent to redis cannot be null");
        return str.getBytes("UTF-8");
        UnsupportedEncodingException e;
        e;
        throw new JedisException(e);
    }

    public static String encode(byte data[])
    {
        return new String(data, "UTF-8");
        UnsupportedEncodingException e;
        e;
        throw new JedisException(e);
    }
}

//FilterOutputStream 
package java.io;

/**
 * This class is the superclass of all classes that filter output
 * streams. These streams sit on top of an already existing output
 * stream (the <i>underlying</i> output stream) which it uses as its
 * basic sink of data, but possibly transforming the data along the
 * way or providing additional functionality.
 * <p>
 * The class <code>FilterOutputStream</code> itself simply overrides
 * all methods of <code>OutputStream</code> with versions that pass
 * all requests to the underlying output stream. Subclasses of
 * <code>FilterOutputStream</code> may further override some of these
 * methods as well as provide additional methods and fields.
 *
 * @author  Jonathan Payne
 * @since   JDK1.0
 */
public
class FilterOutputStream extends OutputStream
iteye_11587
关注
专栏目录
【自撰】Redis客户端Jedis
weixin_48235405的博客
12-22 828
1、什么是Jedis? jedis是针对Java提供的用来连接Redis服务器的客户端技术,就相当于连接数据库需要jdbc一样。 (连接mysql 需要使用jdbc、连接Redis需要使用Jedis ) 配置maven的pom.xmI中配置 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version&gt
Redis框架Jedis及Redisson对比解析
08-18
Jedis是Redis的Java实现的客户端，其API提供了比较全面的Redis命令的支持；Redisson实现了分布式和可扩展的Java数据结构，和Jedis相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。...
Redis Java客户端Jedis 2.9.0 jar包（含common-pool2）
11-17
Redis的官方推荐Java客户端——Jedis 此Jar包为Jedis 2.9.0版（2016年7月22日发布） 支持Redis 3.0 （亲测有效） 使用方法： import redis.clients.jedis.Jedis; Jedis jedis = new Jedis("localhost"); jedis.set("foo", "bar"); String value = jedis.get("foo"); jedis.close(); System.out.println(value);
JedisCommand接口说明
weixin_34221773的博客
06-02 517
本专栏与Redis相关的文章 Redis Sentinel机制与用法（一）Redis Sentinel机制与用法（二）Jedis的JedisSentinelPool源代码分析Jedis的Sharded源代码分析Redis 主从 Replication 的配置详解Redis SORT命令 JedisCommand接口说明 Sharded 和...
【Redis】已解决：redis.clients.jedis.exceptions.JedisDataException: NOAUTH Authentication required
最新发布
屿小夏.的知识博客
08-30 1127
在使用Redis进行缓存或数据存储时，开发者通常会用到Jedis客户端库与Redis服务器进行通信。为了正确解决该报错问题，我们需要在连接Redis服务器后，提供正确的密码进行身份认证。场景：一个Java应用程序尝试连接到启用了密码保护的Redis服务器，却没有提供或提供了错误的密码。该错误通常发生在Redis服务器开启了密码保护，而客户端未提供正确的认证信息的情况下。当我们运行该代码时，如果Redis服务器启用了密码保护而代码未进行认证，将会遇到。报错问题，确保Redis客户端与服务器的正常通信和操作。
Jedis直接使用Redis原生命令操作Redis，解决某些命令没有封装
iioSnail的博客
08-14 3422
背景：做项目中需要通过客户端ID关闭客户端连接（对应命令client kill id 12345），但是使用jedis封装的clientKill方法，尝试了很多次，都没有效果。所以就尝试使用反射方式，直接执行Redis命令来解决该问题。 使用Jedis的Connection类直接执行Redis命令 import redis.clients.jedis.*; import java.lang.ref...
【Spring常见错误】java.lang.NoClassDefFoundError: redis/clients/jedis/UnifiedJedis
专注Spring、SSM、数据结构与算法、蓝桥杯领域创作者
06-14 4092
​ 🙊🙊作者主页：🔗求不脱发的博客 📔📔精选专栏：🔗Spring 📋📋精彩摘要：SpringBoot项目整合jetcache时可能遇到版本冲突问题。本文将提供解决方式参考。 💞💞觉得文章还不错的话欢迎大家点赞👍➕收藏⭐️➕评论💬支持博主🤞 ​...
Redis中Jedis操作
爪哇人的博客
02-02 957
1 前言 之前我们使用的redis命令都是通过命令行的形式实现的，那么如何使用Java来操作redis呢？联想到之前可以通过jdbc来操作数据库，同理也可以通过jedis来操作redis。 2 相关操作 Jedis相关依赖： <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.3
jedis:java调用redis客户端jedis源码工程
03-23
Jedis是一个非常小而理智的 Java客户端。 Jedis被认为易于使用。 Jedis与Redis 2.8.x和3.0.x完全兼容。 社区 在IRC上与我们见面：freenode.net上的## jedis 加入邮件列表，为 那我可以和Jedis一起做什么？ 支持...
Redis客户端之Jedis
05-26
Jedis是Java开发的Redis官方推荐的客户端，它提供了丰富的API来执行Redis命令，涵盖了Redis的所有功能，包括字符串、哈希、列表、集合、有序集合等数据类型的操作，以及事务、发布订阅、脚本执行等高级特性。...
各种版本的redis+Jedis驱动包
08-24
Jedis支持各种Redis命令，包括数据类型操作、事务处理、发布/订阅、持久化等。在实际项目中，通过Jedis，开发者可以实现数据缓存、分布式锁、消息传递等功能。 为了使用Jedis，首先需要将其添加到项目依赖中，例如...
Redis之JedisCommand接口
wenslee263的博客
10-26 776
做了几年外包，公司的redis都是已经封装好的，平常直接引用，用不到原生方法，昨天面试竟然被问到了.... 这里就把源码看了一下并贴出来，这不是分享什么技术，单纯提醒一下各位同行，稍微了解一下，就怕下次面试也被问到了。（同时还被问到有没有用uml建模图，这个以前也用过，但是嘛都是一些传统行业或者老框架采用这个，我后面待得几个互联网项目都没再用过了，怪我资历不够深，我也比较好奇，uml建模图是必须...
redis.clients java_redis报错redis/clients/jedis/JedisPoolConfig'(curren
weixin_39637975的博客
03-02 660
redis + Jedis + Spring报错Type 'redis/clients/jedis/JedisPoolConfig'(current frame, stack[4]) is not aredis + Jedis + Spring集成之后运行报以下错误：log4j:WARNNo appenders could be found for logger(org.springframewo...
[Redis]java.lang.NoClassDefFoundError: redis/clients/jedis/JedisClientConfig
weixin_45254062的博客
12-21 2213
在使用 Spring Data Redis 操作 Redis 时，Spring 报出了 java.lang.NoClassDefFoundError: redis/clients/jedis/JedisClientConfig 异常: ```java @SpringBootTest public class SpringRedisDemoApplicationTests { @Autowire...
java对redis的基本操作
xingluxiaoseng的专栏
11-11 392
edisonfeng   博客园 首页 新随笔 联系 管理 订阅  随笔- 111  文章- 338  评论- 27      java对redis的基本操作   一、server端安装   　　1、下载   　　　　https://github.com/MSOpenTech/redis   　　　　可看到当前可下载版本：redis2.6   　
Redis随笔（五）Jedis、jedisCluster的使用
10-25 4082
参：https://www.cnblogs.com/c-xiaohai/p/8376364.html 1、Jedis客户端 https://redis.io/clients 2、Jedis源码包与使用介绍 https://github.com/xetorthio/jedis 3、项目中使用 通过maven引入Jedis的依赖包 &lt;dependency&gt; &l...
补充：jedis操作命令、redis命令大全
孤天浪雨
09-01 1949
这篇的整理是对《redis中各种数据类型对应的jedis操作命令、redis命令大全》的一个补充！ 方法 说明 详细链接 persist 用于移除给定 key 的过期时间，使得 key 永不过期。 pexpire 用于设定键有效期. http://www.yiibai.com/redis/keys_expire.html expireAt 用来以Unix时
Java中使用Jedis操作Redis
grj0521的博客
11-13 184
https://www.cnblogs.com/liuling/p/2014-4-19-04.html
redis客户端jedis 2.9.0中英双语API文档合集
Jedis库作为Redis的Java客户端，广泛用于Java应用中，能够执行如字符串、哈希、列表、集合、有序集合、位图、超日志和地理空间等数据类型的读写操作。在Jedis库的帮助下，开发者可以更加便捷地利用Redis的功能来优化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值