Redis Protocol即为client与server交互时，所使用的数据格式；符合格式的数据能够被server端解析并返回结果，client端如果按照格式要求既可以解析“结果”并将结构化数据反馈给调用者。有些时候，我们可以通过改造协议的方式构建redis-client套层或者server端的Proxy。
Redis-Client与Server之间进行的任何通讯，均是通过普通的TCP链接进行，因为TCP通讯是面向字节流的，因此它和其他任何基于字节流的信息交互的平台一样，需要“protocol”（协议）；任何protocol本身需要至少具备2种能力：1)字节码成帧策略 2)字符序列格式约束。
“字节码成帧”被广泛的应用在基于字节流的网络交互中，以TCP通讯为例，在Socket通讯中所发送的数据（特别是长链接，持续交付packet的场景下），对于socket的一端都需要知道每个packet的“终止符”位置，以及packet中每个数据field的偏移量；只有这样，对于socket的数据的接收端才能将“无边界流数据”有效的转化成结构化/可读的字符序列。如下展示一个packet帧的结构，其中"[""]"只是为了标记参数：
[magic-header][packet-bytes-length][field-name-bytes-length][field-name-bytes][field-data-bytes-length][field-data-bytes]
实际数据大概为：
[“magic-header”][10][4]["name".getBytes()][6]["012345".getBytes()]
不同的设计者可能考虑成帧的方式不同，但是都需要描述当前packet字节的长度/filed顺序/每个filed的字节长度等。上述例子则表达：此packet需要以“magic-header”开头（主要用来防止字节流被意外破坏或者乱序，同时用来表示一个新帧的开始），此后的总字节长度为10,其中“name”这个filed名称占4个字节，“name”这个filed对应的数据占6个字节；最终我们还原成name=012345这么一个信息。
“字符序列格式约束”即将字符串按照一定的规则进行解析，并获得有效数据；其中“规则”就是格式约束，对于符合规则的字符串才能被接受和实施，否则将会被丢弃。比如xml，json等等，只有符合格式约束的字符串才能被相应的引擎所解析。
Redis协议非常简单且容易理解，request和reply数据都遵循同一个协议；对于client端的每个request，最终会被描述为一个command，command所包含的信息只会包括：指令名称 + 参数列表。那么对于server端的response，最终会被描述为一个result，那么result可能包括此次操作的状态(status)码、错误信息、结果内容等。协议就是为双端交互中的数据格式提供约束。
1. Request部分：对于指令操作[command-name][arg...]最终将会转换成如下格式在网络中传输并交付给server端：
*[参数数量] \r\n
$[参数字节个数]\r\n
[参数字节序列]
...
##以“SET key value”指令为例：
*3 #表示有3个参数
$3 #表示“参数”有三个字节("SET"字符串为3个字节)
SET
$4
name
$5
01234
##流的方式
*3\r\n$3\r\nSET\r\n$4\r\nname\r\n$5\r\n01234\r\n
2.Reply部分：server端需要返回结果的类型，redis中，reply的首个字符用来表示结果的类型，最终以“\r\n”结束.
- “+”：“状态”类型reply，对于无需实际数据返回的相应，只是用来表示此次操作成功与否，例如SET KEY-VALUE指令。比如“+OK”表示操作成功，如果不成功将会返回“-ERROR”。
- “-”：“异常”信息类型reply，对于操作失败时，将会返回此类型的信息告知client端。
lrange testtt w x
-ERR value is not an integer or out of range
在“-”之后为“错误类型”，此后为一个空格或者“\r\n”，然后为异常信息内容，内容可能有多行。
- “:”：表示返回结果为integer类型，此结果只包括一个数字，也可以用来表示true/false的结果类型，比如INCR/DECR/EXISTS/SISMEMBER等指令；需要注意的是，integer结果也是按照“字符串”方式传输的，你不能按照“4个字节=integer”的思路去使用它。比如integer = 23456，那么“23456”实际上是5个字节
exists fck-me
:0
exists fck-you
:1
- “$”：表示返回的结果为普通数据结果，格式为：[$][字节个数][\r\n][字节序列][\r\n]，如果结果中存在$-1则表示当前请求的数据为“null”。
get fck-you
$3
123
- “*”：表示返回的结果为复合数据结果，结果中包括多个子数据集合。
lrange testlist 0 -1
*2
$1
b
$1
a
Redis支持“行内指令”，我们可以通过telnet的方式，执行指令和查看协议：
qing@qing-tp:~$ telnet 127.0.0.1 6379
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
SET test 1
+OK
incr test
:2
exist test
-ERR unknown command 'exist'
3.协议与实践：在下文的代码中，我们将通过代码展示如何直接通过Socket-IO的方式直接与redis-server交互，可以比较直观的明白protocol数据格式；其实，可以认为它是一个java redis-client,不过我本人采取了和Jedis不同的请求处理手段，本人采取了“请求队列 + 同步”的方式进行，其实如下代码可以在极少的修改下，改变为“异步”的方式。在此需要提醒：protocol中的字节流需要UTF-8编码之后。
TestMain.java
public class TestMain {
public static void main(String[] args){
Client client = new Client("127.0.0.1", 6379);
client.set("testset", "012xyz中国_？");
System.out.println(client.get("testset"));
List<String> list = client.lrange("testlist", 0, -1);
for(String item : list){
System.out.println("--:" + item);
}
System.out.println("incr:" + client.incr("testincr"));
}
}
Client.java
（完整代码，参见附件）
public class Client {
private BlockingQueue<Request> requests = new LinkedBlockingQueue<Request>();
private Charset charset = Charset.forName("utf-8");
private Handler handler;
Client(String host,int port){
handler = new Handler(host, port);
handler.setDaemon(true);
handler.start();
}
public void set(String key,String value){
Request request = new Request(Command.SET, key,value);
try{
synchronized (request) {
requests.put(request);
request.wait();
}
Reply reply = request.reply;
if(reply == null || reply.code == -1 || !reply.success){
throw new RuntimeException("operation fail..");
}
}catch(InterruptedException e){
return;
}
}
public String get(String key){
Request request = new Request(Command.GET, key);
try{
synchronized (request) {
requests.put(request);
request.wait();
}
Reply reply = request.reply;
if(reply == null || reply.code == -1 || !reply.success){
throw new RuntimeException("operation fail..");
}
return reply.result;
}catch(InterruptedException e){
return null;
}
}
public List<String> lrange(String key,int from,int to){
Request request = new Request(Command.LRANGE, key,String.valueOf(from),String.valueOf(to));
try{
synchronized (request) {
requests.put(request);
request.wait();
}
Reply reply = request.reply;
if(reply == null || reply.code == -1 || !reply.success){
throw new RuntimeException("operation fail..");
}
return reply.lresult;
}catch(InterruptedException e){
return null;
}
}
public Integer incr(String key){
Request request = new Request(Command.INCR,key);
try{
synchronized (request) {
requests.put(request);
request.wait();
}
Reply reply = request.reply;
if(reply == null || reply.code == -1 || !reply.success){
throw new RuntimeException("operation fail..");
}
return Integer.valueOf(reply.result);
}catch(InterruptedException e){
return null;
}
}
public void close(){
handler.close();
}
class Handler extends Thread{
Socket socket = null;
boolean closed = false;
BufferedReader is = null;
OutputStream os = null;
String host;
int port;
Handler(String host,int port){
try{
this.host = host;
this.port = port;
connect();
}catch(Exception e){
e.printStackTrace();
}
}
private void connect() throws IOException{
socket = new Socket();
SocketAddress addr = new InetSocketAddress(host,port);
socket.setKeepAlive(true);
//socket.setSoTimeout(10000);
socket.setSoLinger(true,0);
//socket.setReceiveBufferSize(1024);
socket.setTcpNoDelay(true);
socket.connect(addr,10000); //blocking
is = new BufferedReader(new InputStreamReader(socket.getInputStream(),charset));
os = socket.getOutputStream();
}
public void close(){
closed = true;
this.interrupt();
}
private void write(Request request) throws IOException{
os.write('*');
String[] args = request.args;
os.write(String.valueOf(args.length + 1).getBytes(charset));
os.write('\r');
os.write('\n');
//*2
os.write('$');
byte[] cb = request.command.name().getBytes(charset);
os.write(String.valueOf(cb.length).getBytes(charset));
os.write('\r');
os.write('\n');
//$3
os.write(cb);
os.write('\r');
os.write('\n');
//GET
for(String arg : args){
byte[] ab = arg.getBytes(charset);
os.write('$');
os.write(String.valueOf(ab.length).getBytes(charset));
os.write('\r');
os.write('\n');
os.write(ab);
os.write('\r');
os.write('\n');
}
}
@Override
public void run(){
try{
while(!closed){
Request request = requests.take();
try{
write(request);
char status = (char)is.read();
Reply reply = new Reply();
if(status != '-'){
reply.success = true;
}
if(status == '+' || status == '-'){
reply.message = read();
}else if(status == '$'){
reply.result = readString();
}else if(status == '*'){
reply.lresult = readMulti();
}else if(status == ':'){
reply.result = read();
}else{
request.reply = new Reply(-1);
throw new RuntimeException("packet error..");
}
synchronized (request) {
request.reply = reply;
request.notifyAll();
}
}catch(Exception e){
try{
socket.close();
this.connect();
}catch(Exception ex){
//
}
synchronized (request) {
request.notifyAll();
}
}
}
}catch(InterruptedException e){
try{
closed = true;
socket.close();
for(Request request : requests){
request.blocker.interrupt();
}
requests.clear();
}catch(Exception ex){
//
}
}
}
//read line
private String read() throws IOException{
StringBuilder sb = new StringBuilder();
//\r\n必须互为成对
//不能直接使用is.readline()
boolean lfcr = false;
while(true){
char _char = (char)is.read();
if(_char == -1){
close();
break;
}
//如果上一个字符为\r
if(lfcr == true){
if(_char == '\n'){
break;
}
sb.append('\r');
lfcr = false;
}
if(_char == '\r'){
lfcr = true;
continue;
}
sb.append(_char);
}
return sb.toString();
}
private List<String> readMulti() throws IOException{
Integer size = Integer.valueOf(read());
List<String> lresult = new ArrayList<String>();
//eg: *3
if(size > 0) {
for(int i=0;i<size;i++){
while(true){
char _char = (char)is.read();//$3
if(_char == '$'){
lresult.add(readString());
break;
}
}
}
}
return lresult;
}
//such as:
//$3
//012
private String readString() throws IOException{
Integer size = Integer.valueOf(read());
//-1 is null
if(size > 0){
return read();
}
return null;
}
}
}
