├── .gitignore
├── README.md
├── pom.xml
└── src
    ├── demo
        └── java
        │   ├── Demo.java
        │   └── Test.java
    └── main
        └── java
            └── com
                └── udpwork
                    └── ssdb
                        ├── Link.java
                        ├── MemoryStream.java
                        ├── Response.java
                        └── SSDB.java


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.o
 2 | *.a
 3 | *.class
 4 | .DS_Store
 5 | *.pyc
 6 | *.swp
 7 | *_cpy_*
 8 | .project
 9 | .classpath
10 | target
11 | 
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | javassdb
2 | ========
3 | 
4 | SSDB Java client
5 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2 |   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3 |   <modelVersion>4.0.0</modelVersion>
 4 | 
 5 |   <groupId>com.updwork</groupId>
 6 |   <artifactId>ssdb</artifactId>
 7 |   <version>0.0.1-SNAPSHOT</version>
 8 |   <packaging>jar</packaging>
 9 | 
10 |   <name>ssdb</name>
11 |   <url>http://maven.apache.org</url>
12 | 
13 |   <properties>
14 |     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15 |   </properties>
16 | 
17 | </project>
18 | 


--------------------------------------------------------------------------------
/src/demo/java/Demo.java:
--------------------------------------------------------------------------------
 1 | import com.udpwork.ssdb.*;
 2 | 
 3 | /**
 4 |  * SSDB Java client SDK demo.
 5 |  */
 6 | public class Demo {
 7 | 	public static void main(String[] args) throws Exception {
 8 | 		SSDB ssdb = null;
 9 | 		Response resp;
10 | 		byte[] b;
11 | 		ssdb = new SSDB("127.0.0.1", 8888);
12 | 		System.out.println("---- connected -----");
13 | 
14 | 		// 注意: 如果某个命令没有对应的函数, 你就使用 request() 方法来执行
15 | 		resp = ssdb.request("qpush", "q", "a");
16 | 		for(int i=1; i<resp.raw.size(); i+=2){
17 | 			String s = new String(resp.raw.get(i));
18 | 			System.out.println(s);
19 | 		}
20 | 
21 | 		
22 | 		/* kv */
23 | 		System.out.println("---- kv -----");
24 | 		
25 | 		ssdb.set("a", "123");
26 | 		b = ssdb.get("a");
27 | 		System.out.println(new String(b));
28 | 		ssdb.del("a");
29 | 		b = ssdb.get("a");
30 | 		System.out.println(b);
31 | 		ssdb.incr("a", 10);
32 | 		
33 | 		resp = ssdb.scan("", "", 10);
34 | 		resp.print();
35 | 		resp = ssdb.rscan("", "", 10);
36 | 		resp.print();
37 | 		System.out.println("");
38 | 
39 | 		/* hashmap */
40 | 		System.out.println("---- hashmap -----");
41 | 
42 | 		ssdb.hset("n", "a", "123");
43 | 		b = ssdb.hget("n", "a");
44 | 		System.out.println(new String(b));
45 | 		ssdb.hdel("n", "a");
46 | 		b = ssdb.hget("n", "a");
47 | 		System.out.println(b);
48 | 		ssdb.hincr("n", "a", 10);
49 | 
50 | 		resp = ssdb.hscan("n", "", "", 10);
51 | 		resp.print();
52 | 		System.out.println("");
53 | 
54 | 		/* zset */
55 | 		System.out.println("---- zset -----");
56 | 
57 | 		Long d;
58 | 		ssdb.zset("n", "a", 123);
59 | 		d = ssdb.zget("n", "a");
60 | 		System.out.println(d);
61 | 		ssdb.zdel("n", "a");
62 | 		d = ssdb.zget("n", "a");
63 | 		System.out.println(d);
64 | 		ssdb.zincr("n", "a", 10);
65 | 
66 | 		resp = ssdb.zscan("n", "", null, null, 10);
67 | 		resp.print();
68 | 		System.out.println("");
69 | 		
70 | 		/* multi */
71 | 		ssdb.multi_set("a", "1", "b", "2");
72 | 		resp = ssdb.multi_get("a", "b");
73 | 		resp.print();
74 | 		System.out.println("");
75 | 	
76 | 		//
77 | 		ssdb.close();
78 | 	}
79 | }
80 | 


--------------------------------------------------------------------------------
/src/demo/java/Test.java:
--------------------------------------------------------------------------------
 1 | import com.udpwork.ssdb.*;
 2 | 
 3 | /**
 4 |  * SSDB Java client SDK demo.
 5 |  */
 6 | public class Test {
 7 | 	public static void main(String[] args) throws Exception {
 8 | 		String s = "3\r\nget\n1\r\nk\r\n\r\n";
 9 | 		s += s;
10 | 		s += s;
11 | 		byte[] bytes = s.getBytes();
12 | 		Link link = new Link();
13 | 		link.testRead(bytes);
14 | 		for(int i=0; i<bytes.length; i++){
15 | 			byte[] bs = {bytes[i]};
16 | 			link.testRead(bs);
17 | 		}
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/src/main/java/com/udpwork/ssdb/Link.java:
--------------------------------------------------------------------------------
  1 | package com.udpwork.ssdb;
  2 | 
  3 | import java.io.InputStream;
  4 | import java.io.OutputStream;
  5 | import java.net.Socket;
  6 | import java.util.ArrayList;
  7 | import java.util.Arrays;
  8 | import java.util.List;
  9 | 
 10 | public class Link {
 11 | 	private Socket sock;
 12 | 	private MemoryStream input = new MemoryStream();
 13 | 	
 14 | 	public Link(){
 15 | 		
 16 | 	}
 17 | 
 18 | 	public Link(String host, int port) throws Exception{
 19 | 		this(host, port, 0);
 20 | 	}
 21 | 
 22 | 	public Link(String host, int port, int timeout_ms) throws Exception{
 23 | 		sock = new Socket(host, port);
 24 | 		if(timeout_ms > 0){
 25 | 			sock.setSoTimeout(timeout_ms);
 26 | 		}
 27 | 		sock.setTcpNoDelay(true);
 28 | 	}
 29 | 	
 30 | 	public void close(){
 31 | 		try{
 32 | 			sock.close();
 33 | 		}catch(Exception e){
 34 | 			//
 35 | 		}
 36 | 	}
 37 | 
 38 | 	public Response request(String cmd, byte[]...params) throws Exception{
 39 | 		ArrayList<byte[]> list = new ArrayList<byte[]>();
 40 | 		for(byte[] s : params){
 41 | 			list.add(s);
 42 | 		}
 43 | 		return this.request(cmd, list);
 44 | 	}
 45 | 	
 46 | 	public Response request(String cmd, String...params) throws Exception{
 47 | 		ArrayList<byte[]> list = new ArrayList<byte[]>();
 48 | 		for(String s : params){
 49 | 			list.add(s.getBytes());
 50 | 		}
 51 | 		return this.request(cmd, list);
 52 | 	}
 53 | 
 54 | 	public Response request(String cmd, List<byte[]> params) throws Exception{
 55 | 		MemoryStream buf = new MemoryStream(4096);
 56 | 		Integer len = cmd.length();
 57 | 		buf.write(len.toString());
 58 | 		buf.write('\n');
 59 | 		buf.write(cmd);
 60 | 		buf.write('\n');
 61 | 		for(byte[] bs : params){
 62 | 			len = bs.length;
 63 | 			buf.write(len.toString());
 64 | 			buf.write('\n');
 65 | 			buf.write(bs);
 66 | 			buf.write('\n');
 67 | 		}
 68 | 		buf.write('\n');
 69 | 		send(buf);
 70 | 		
 71 | 		List<byte[]> list = recv();
 72 | 		return new Response(list);
 73 | 	}
 74 | 	
 75 | 	private void send(MemoryStream buf) throws Exception{
 76 | 		OutputStream os = sock.getOutputStream();
 77 | 		os.write(buf.toArray());
 78 | 		os.flush();
 79 | 	}
 80 | 	
 81 | 	private List<byte[]> recv() throws Exception{
 82 | 		input.nice();
 83 | 		InputStream is = sock.getInputStream();
 84 | 		while(true){
 85 | 			List<byte[]> ret = parse();
 86 | 			if(ret != null){
 87 | 				return ret;
 88 | 			}
 89 | 			byte[] bs = new byte[8192];
 90 | 			int len = is.read(bs);
 91 | 			//System.out.println("<< " + (new MemoryStream(bs, 0, len)).printable());
 92 | 			input.write(bs, 0, len);
 93 | 		}
 94 | 	}
 95 | 	
 96 | 	public void testRead(byte[] data) throws Exception{
 97 | 		input.write(data, 0, data.length);
 98 | 		System.out.println("<< " +input.repr());
 99 | 		
100 | 		List<byte[]> ret = parse();
101 | 		if(ret != null){
102 | 			System.out.println("---------------------");
103 | 			for (byte[] bs : ret) {
104 | 				System.out.println(String.format("%-15s", MemoryStream.repr(bs)));
105 | 			}
106 | 		}
107 | 	}
108 | 	
109 | 	private List<byte[]> parse() throws Exception{
110 | 		ArrayList<byte[]> list = new ArrayList<byte[]>();
111 | 		
112 | 		int idx = 0;
113 | 		// ignore leading empty lines
114 | 		while(idx < input.size && (input.chatAt(idx) == '\r' || input.chatAt(idx) == '\n')){
115 | 			idx ++;
116 | 		}
117 | 		
118 | 		while(idx < input.size){
119 | 			int data_idx = input.memchr('\n', idx);
120 | 			if(data_idx == -1){
121 | 				break;
122 | 			}
123 | 			data_idx += 1;
124 | 			
125 | 			int head_len = data_idx - idx;
126 | 			if(head_len == 1 || (head_len == 2 && input.chatAt(idx) == '\r')){
127 | 				input.decr(data_idx);
128 | 				return list;
129 | 			}
130 | 			String str = new String(input.copyOfRange(idx, data_idx));
131 | 			str = str.trim();
132 | 			int size;
133 | 			try{
134 | 				size = Integer.parseInt(str, 10);
135 | 			}catch(Exception e){
136 | 				throw new Exception("Parse body_len error");
137 | 			}
138 | 			
139 | 			idx = data_idx + size;
140 | 
141 | 			int left = input.size - idx;
142 | 			if(left >= 1 && input.chatAt(idx) == '\n'){
143 | 				idx += 1;
144 | 			}else if(left >= 2 && input.chatAt(idx) == '\r' && input.chatAt(idx+1) == '\n'){
145 | 				idx += 2;
146 | 			}else if(left >= 2){
147 | 				throw new Exception("bad format");
148 | 			}else{
149 | 				break;
150 | 			}
151 | 			// System.out.println("size: " + size + " idx: " + idx + " left: " + (input.size - idx));
152 | 			
153 | 			byte[] data = input.copyOfRange(data_idx, data_idx + size);
154 | 			//System.out.println("size: " + size + " data: " + data.length);
155 | 			list.add(data);
156 | 		}
157 | 		return null;		
158 | 	}
159 | 
160 | }
161 | 


--------------------------------------------------------------------------------
/src/main/java/com/udpwork/ssdb/MemoryStream.java:
--------------------------------------------------------------------------------
  1 | package com.udpwork.ssdb;
  2 | 
  3 | import java.util.Arrays;
  4 | 
  5 | public class MemoryStream {
  6 | 	private int capacity;
  7 | 	private int data = 0;
  8 | 	private int slot = 0;
  9 | 	public int size = 0;
 10 | 	public byte[] buf;
 11 | 	
 12 | 	public MemoryStream(){
 13 | 		this(4096);
 14 | 	}
 15 | 	
 16 | 	public MemoryStream(int capacity){
 17 | 		this.capacity = capacity;
 18 | 		buf = new byte[capacity];
 19 | 	}
 20 | 	
 21 | 	public MemoryStream(byte[] copy){
 22 | 		this(copy, 0, copy.length);
 23 | 	}
 24 | 	
 25 | 	public MemoryStream(byte[] copy, int off, int len){
 26 | 		this.capacity = len;
 27 | 		this.size = len;
 28 | 		buf = Arrays.copyOfRange(copy, off, off + len);
 29 | 	}
 30 | 	
 31 | 	public byte[] toArray(){
 32 | 		byte[] ret = Arrays.copyOfRange(buf, data, data + size);
 33 | 		return ret;
 34 | 	}
 35 | 
 36 | 	public static String repr(byte[] bs){
 37 | 		StringBuffer sb = new StringBuffer();
 38 | 		for(int i=0; i<bs.length; i++){
 39 | 			char b = (char)bs[i];
 40 | 			//byte b = buf[i];
 41 | 			if(b == '\r'){
 42 | 				sb.append("\\r");
 43 | 			}else if(b == '\n'){
 44 | 				sb.append("\\n");
 45 | 			}else if(b == '\t'){
 46 | 				sb.append("\\t");
 47 | 			}else if(b == '_'){
 48 | 				sb.append(b);
 49 | 			}else if(Character.isLetter(b) || Character.isDigit(b)){
 50 | 				sb.append(b);
 51 | 			}else{
 52 | 				sb.append(String.format("\\%02X", (int)b));
 53 | 			}
 54 | 		}
 55 | 		return sb.toString();
 56 | 	}
 57 | 
 58 | 	public String repr(){
 59 | 		return repr(toArray());
 60 | 	}
 61 | 	
 62 | 	public int space(){
 63 | 		return capacity - slot;
 64 | 	}
 65 | 	
 66 | 	// try realloc
 67 | 	private void realloc(int require){
 68 | 		while(require > space()){
 69 | 			capacity *= 2;
 70 | 			buf = Arrays.copyOf(buf, capacity);
 71 | 		}
 72 | 	}
 73 | 	
 74 | 	public void nice(){
 75 | 		if(data > capacity/2){
 76 | 			System.arraycopy(buf, data, buf, 0, size);
 77 | 			data = 0;
 78 | 			slot = size;
 79 | 		}
 80 | 	}
 81 | 	
 82 | 	public void decr(int num){
 83 | 		size -= num;
 84 | 		data += num;
 85 | 	}
 86 | 	
 87 | 	public void write(int b){
 88 | 		this.write((byte)b);
 89 | 	}
 90 | 	
 91 | 	public void write(byte b){
 92 | 		realloc(1);
 93 | 		buf[size] = b;
 94 | 		size += 1;
 95 | 		slot += 1;
 96 | 	}
 97 | 	
 98 | 	public void write(String s){
 99 | 		this.write(s.getBytes());
100 | 	}
101 | 	
102 | 	public void write(byte[] bs){
103 | 		this.write(bs, 0, bs.length);
104 | 	}
105 | 	
106 | 	public void write(byte[] bs, int start, int len){
107 | 		realloc(len);
108 | 		System.arraycopy(bs, start, buf, slot, len);
109 | 		size += len;
110 | 		slot += len;
111 | 	}
112 | 	
113 | 	public int memchr(int b, int offset){
114 | 		return this.memchr((byte)b, offset);
115 | 	}
116 | 	
117 | 	// return offset to data
118 | 	public int memchr(byte b, int offset){
119 | 		for(int i=data+offset; i<data+size; i++){
120 | 			if(b == buf[i]){
121 | 				return i - data;
122 | 			}
123 | 		}
124 | 		return -1;
125 | 	}
126 | 	
127 | 	public byte chatAt(int offset){
128 | 		return buf[data + offset];
129 | 	}
130 | 	
131 | 	// end - exclusive
132 | 	public byte[] copyOfRange(int start, int end){
133 | 		byte[] ret = Arrays.copyOfRange(buf, data + start, data + end);
134 | 		return ret;
135 | 	}
136 | }
137 | 


--------------------------------------------------------------------------------
/src/main/java/com/udpwork/ssdb/Response.java:
--------------------------------------------------------------------------------
 1 | package com.udpwork.ssdb;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.LinkedHashMap;
 5 | import java.util.List;
 6 | import java.util.Map;
 7 | 
 8 | public class Response{
 9 | 	public String status;
10 | 	public List<byte[]> raw;
11 | 	/**
12 | 	 * Indicates items' order
13 | 	 */
14 | 	public List<byte[]> keys = new ArrayList<byte[]>();
15 | 	/**
16 | 	 * key-value results
17 | 	 */
18 | 	public Map<byte[], byte[]> items = new LinkedHashMap<byte[], byte[]>();
19 | 	
20 | 	public Response(List<byte[]> raw){
21 | 		this.raw = raw;
22 | 		if(raw.size() > 0){
23 | 			status = new String(raw.get(0));
24 | 		}
25 | 	}
26 | 	
27 | 	public Object exception() throws Exception{
28 | 		if(raw.size() >= 2){
29 | 			throw new Exception(new String(raw.get(1)));
30 | 		}else{
31 | 			throw new Exception("");
32 | 		}
33 | 	}
34 | 
35 | 	public boolean ok(){
36 | 		return status.equals("ok");
37 | 	}
38 | 	
39 | 	public boolean not_found(){
40 | 		return status.equals("not_found");
41 | 	}
42 | 	
43 | 	public void buildMap(){
44 | 		for(int i=1; i+1<raw.size(); i+=2){
45 | 			byte[] k = raw.get(i);
46 | 			byte[] v = raw.get(i+1);
47 | 			keys.add(k);
48 | 			items.put(k, v);
49 | 		}
50 | 	}
51 | 
52 | 	public void print(){
53 | 		System.out.println(String.format("%-15s %s", "key", "value"));
54 | 		System.out.println("---------------------");
55 | 		for (byte[] bs : keys) {
56 | 			System.out.print(String.format("%-15s", MemoryStream.repr(bs)));
57 | 			System.out.print(": ");
58 | 			System.out.print(MemoryStream.repr(items.get(bs)));
59 | 			System.out.println();
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/src/main/java/com/udpwork/ssdb/SSDB.java:
--------------------------------------------------------------------------------
  1 | package com.udpwork.ssdb;
  2 | 
  3 | import java.util.List;
  4 | 
  5 | 
  6 | /**
  7 |  * SSDB Java client SDK.
  8 |  * Example:
  9 |  * <pre>
 10 |  * SSDB ssdb = new SSDB("127.0.0.1", 8888);
 11 |  * ssdb.set("a", "123");
 12 |  * byte[] val = ssdb.get("a");
 13 |  * ssdb.close();
 14 |  * </pre>
 15 |  */
 16 | public class SSDB{
 17 | 	public Link link;
 18 | 
 19 | 	public SSDB(String host, int port) throws Exception{
 20 | 		this(host, port, 0);
 21 | 	}
 22 | 
 23 | 	public SSDB(String host, int port, int timeout_ms) throws Exception{
 24 | 		link = new Link(host, port, timeout_ms);
 25 | 	}
 26 | 	
 27 | 	public void close(){
 28 | 		link.close();
 29 | 	}
 30 | 
 31 | 	public Response request(String cmd, byte[]...params) throws Exception{
 32 | 		return link.request(cmd, params);
 33 | 	}
 34 | 
 35 | 	public Response request(String cmd, String...params) throws Exception{
 36 | 		return link.request(cmd, params);
 37 | 	}
 38 | 	
 39 | 	public Response request(String cmd, List<byte[]> params) throws Exception{
 40 | 		return link.request(cmd, params);
 41 | 	}
 42 | 
 43 | 	/* auth */
 44 | 
 45 | 	public void auth(String password) throws Exception{
 46 | 		Response resp = link.request("auth", password);
 47 | 		if(resp.ok()){
 48 | 			return;
 49 | 		}
 50 | 		resp.exception();
 51 | 	}
 52 | 
 53 | 	/* kv */
 54 | 
 55 | 	public void set(byte[] key, byte[] val) throws Exception{
 56 | 		Response resp = link.request("set", key, val);
 57 | 		if(resp.ok()){
 58 | 			return;
 59 | 		}
 60 | 		resp.exception();
 61 | 	}
 62 | 	
 63 | 	public void set(String key, byte[] val) throws Exception{
 64 | 		set(key.getBytes(), val);
 65 | 	}
 66 | 	
 67 | 	public void set(String key, String val) throws Exception{
 68 | 		set(key, val.getBytes());
 69 | 	}
 70 | 
 71 | 	public void del(byte[] key) throws Exception{
 72 | 		Response resp = link.request("del", key);
 73 | 		if(resp.ok()){
 74 | 			return;
 75 | 		}
 76 | 		resp.exception();
 77 | 	}
 78 | 	
 79 | 	public void del(String key) throws Exception{
 80 | 		del(key.getBytes());
 81 | 	}
 82 | 
 83 | 	/***
 84 | 	 * 
 85 | 	 * @param key
 86 | 	 * @return null if not found
 87 | 	 * @throws Exception
 88 | 	 */
 89 | 	public byte[] get(byte[] key) throws Exception{
 90 | 		Response resp = link.request("get", key);
 91 | 		if(resp.not_found()){
 92 | 			return null;
 93 | 		}
 94 | 		if(resp.raw.size() != 2){
 95 | 			throw new Exception("Invalid response");
 96 | 		}
 97 | 		if(resp.ok()){
 98 | 			return resp.raw.get(1);
 99 | 		}
100 | 		resp.exception();
101 | 		return null;
102 | 	}
103 | 	
104 | 	/***
105 | 	 * 
106 | 	 * @param key
107 | 	 * @return null if not found
108 | 	 * @throws Exception
109 | 	 */
110 | 	public byte[] get(String key) throws Exception{
111 | 		return get(key.getBytes());
112 | 	}
113 | 
114 | 	private Response _scan(String cmd, String key_start, String key_end, int limit) throws Exception{
115 | 		if(key_start == null){
116 | 			key_start = "";
117 | 		}
118 | 		if(key_end == null){
119 | 			key_end = "";
120 | 		}
121 | 		Response resp = link.request(cmd, key_start, key_end, (new Integer(limit)).toString());
122 | 		if(!resp.ok()){
123 | 			resp.exception();
124 | 		}
125 | 		resp.buildMap();
126 | 		return resp;
127 | 	}
128 | 	
129 | 	public Response scan(String key_start, String key_end, int limit) throws Exception{
130 | 		return _scan("scan", key_start, key_end, limit);
131 | 	}
132 | 	
133 | 	public Response rscan(String key_start, String key_end, int limit) throws Exception{
134 | 		return _scan("rscan", key_start, key_end, limit);
135 | 	}
136 | 	
137 | 	public long incr(String key, long by) throws Exception{
138 | 		Response resp = link.request("incr", key, (new Long(by)).toString());
139 | 		if(!resp.ok()){
140 | 			resp.exception();
141 | 		}
142 | 		if(resp.raw.size() != 2){
143 | 			throw new Exception("Invalid response");
144 | 		}
145 | 		long ret = 0;
146 | 		ret = Long.parseLong(new String(resp.raw.get(1)));
147 | 		return ret;
148 | 	}
149 | 	
150 | 	/* hashmap */
151 | 
152 | 	public void hset(String name, byte[] key, byte[] val) throws Exception{
153 | 		Response resp = link.request("hset", name.getBytes(), key, val);
154 | 		if(resp.ok()){
155 | 			return;
156 | 		}
157 | 		resp.exception();
158 | 	}
159 | 	
160 | 	public void hset(String name, String key, byte[] val) throws Exception{
161 | 		this.hset(name, key.getBytes(), val);
162 | 	}
163 | 	
164 | 	public void hset(String name, String key, String val) throws Exception{
165 | 		this.hset(name, key, val.getBytes());
166 | 	}
167 | 	
168 | 	public void hdel(String name, byte[] key) throws Exception{
169 | 		Response resp = link.request("hdel", name.getBytes(), key);
170 | 		if(resp.ok()){
171 | 			return;
172 | 		}
173 | 		resp.exception();
174 | 	}
175 | 	
176 | 	public void hdel(String name, String key) throws Exception{
177 | 		this.hdel(name, key.getBytes());
178 | 	}
179 | 
180 | 	/**
181 | 	 * 
182 | 	 * @param name
183 | 	 * @param key
184 | 	 * @return null if not found
185 | 	 * @throws Exception
186 | 	 */
187 | 	public byte[] hget(String name, byte[] key) throws Exception{
188 | 		Response resp = link.request("hget", name.getBytes(), key);
189 | 		if(resp.not_found()){
190 | 			return null;
191 | 		}
192 | 		if(resp.raw.size() != 2){
193 | 			throw new Exception("Invalid response");
194 | 		}
195 | 		if(resp.ok()){
196 | 			return resp.raw.get(1);
197 | 		}
198 | 		resp.exception();
199 | 		return null;
200 | 	}
201 | 	
202 | 	/**
203 | 	 * 
204 | 	 * @param name
205 | 	 * @param key
206 | 	 * @return null if not found
207 | 	 * @throws Exception
208 | 	 */
209 | 	public byte[] hget(String name, String key) throws Exception{
210 | 		return hget(name, key.getBytes());
211 | 	}
212 | 
213 | 	private Response _hscan(String cmd, String name, String key_start, String key_end, int limit) throws Exception{
214 | 		if(key_start == null){
215 | 			key_start = "";
216 | 		}
217 | 		if(key_end == null){
218 | 			key_end = "";
219 | 		}
220 | 		Response resp = link.request(cmd, name, key_start, key_end, (new Integer(limit)).toString());
221 | 		if(!resp.ok()){
222 | 			resp.exception();
223 | 		}
224 | 		for(int i=1; i<resp.raw.size(); i+=2){
225 | 			byte[] k = resp.raw.get(i);
226 | 			byte[] v = resp.raw.get(i+1);
227 | 			resp.keys.add(k);
228 | 			resp.items.put(k, v);
229 | 		}
230 | 		return resp;
231 | 	}
232 | 	
233 | 	public Response hscan(String name, String key_start, String key_end, int limit) throws Exception{
234 | 		return this._hscan("hscan", name, key_start, key_end, limit);
235 | 	}
236 | 	
237 | 	public Response hrscan(String name, String key_start, String key_end, int limit) throws Exception{
238 | 		return this._hscan("hrscan", name, key_start, key_end, limit);
239 | 	}
240 | 	
241 | 	public long hincr(String name, String key, long by) throws Exception{
242 | 		Response resp = link.request("hincr", name, key, (new Long(by)).toString());
243 | 		if(!resp.ok()){
244 | 			resp.exception();
245 | 		}
246 | 		if(resp.raw.size() != 2){
247 | 			throw new Exception("Invalid response");
248 | 		}
249 | 		long ret = 0;
250 | 		ret = Long.parseLong(new String(resp.raw.get(1)));
251 | 		return ret;
252 | 	}
253 | 	
254 | 	/* zset */
255 | 
256 | 	public void zset(String name, byte[] key, long score) throws Exception{
257 | 		Response resp = link.request("zset", name.getBytes(), key, (new Long(score)).toString().getBytes());
258 | 		if(resp.ok()){
259 | 			return;
260 | 		}
261 | 		resp.exception();
262 | 	}
263 | 	
264 | 	public void zset(String name, String key, long score) throws Exception{
265 | 		zset(name, key.getBytes(), score);
266 | 	}
267 | 	
268 | 	public void zdel(String name, byte[] key) throws Exception{
269 | 		Response resp = link.request("zdel", name.getBytes(), key);
270 | 		if(resp.ok()){
271 | 			return;
272 | 		}
273 | 		resp.exception();
274 | 	}
275 | 	
276 | 	public void zdel(String name, String key) throws Exception{
277 | 		this.zdel(name, key.getBytes());
278 | 	}
279 | 	
280 | 	/**
281 | 	 * 
282 | 	 * @param name
283 | 	 * @param key
284 | 	 * @return null if not found.
285 | 	 * @throws Exception
286 | 	 */
287 | 	public Long zget(String name, byte[] key) throws Exception{
288 | 		Response resp = link.request("zget", name.getBytes(), key);
289 | 		if(resp.not_found()){
290 | 			return null;
291 | 		}
292 | 		if(resp.raw.size() != 2){
293 | 			throw new Exception("Invalid response");
294 | 		}
295 | 		if(resp.ok()){
296 | 			return Long.parseLong(new String(resp.raw.get(1)));
297 | 		}
298 | 		resp.exception();
299 | 		return new Long(0);
300 | 	}
301 | 
302 | 	/**
303 | 	 * 
304 | 	 * @param name
305 | 	 * @param key
306 | 	 * @return null if not found.
307 | 	 * @throws Exception
308 | 	 */
309 | 	public Long zget(String name, String key) throws Exception{
310 | 		return zget(name, key.getBytes());
311 | 	}
312 | 
313 | 	private Response _zscan(String cmd, String name, String key, Long score_start, Long score_end, int limit) throws Exception{
314 | 		if(key == null){
315 | 			key = "";
316 | 		}
317 | 		String ss ="";
318 | 		if(score_start != null){
319 | 			ss = score_start.toString();
320 | 		}
321 | 		String se ="";
322 | 		if(score_end != null){
323 | 			se = score_end.toString();
324 | 		}
325 | 		Response resp = link.request(cmd, name, key, ss, se, (new Integer(limit)).toString());
326 | 		if(!resp.ok()){
327 | 			resp.exception();
328 | 		}
329 | 		for(int i=1; i<resp.raw.size(); i+=2){
330 | 			byte[] k = resp.raw.get(i);
331 | 			byte[] v = resp.raw.get(i+1);
332 | 			resp.keys.add(k);
333 | 			resp.items.put(k, v);
334 | 		}
335 | 		return resp;
336 | 	}
337 | 	
338 | 	public Response zscan(String name, String key, Long score_start, Long score_end, int limit) throws Exception{
339 | 		return this._zscan("zscan", name, key, score_start, score_end, limit);
340 | 	}
341 | 	
342 | 	public Response zrscan(String name, String key, Long score_start, Long score_end, int limit) throws Exception{
343 | 		return this._zscan("zrscan", name, key, score_start, score_end, limit);
344 | 	}
345 | 	
346 | 	public long zincr(String name, String key, long by) throws Exception{
347 | 		Response resp = link.request("zincr", name, key, (new Long(by)).toString());
348 | 		if(!resp.ok()){
349 | 			resp.exception();
350 | 		}
351 | 		if(resp.raw.size() != 2){
352 | 			throw new Exception("Invalid response");
353 | 		}
354 | 		long ret = 0;
355 | 		ret = Long.parseLong(new String(resp.raw.get(1)));
356 | 		return ret;
357 | 	}
358 | 
359 | 	/****************/
360 | 	
361 | 	public Response multi_get(String...keys) throws Exception{
362 | 		Response resp = link.request("multi_get", keys);
363 | 		if(!resp.ok()){
364 | 			resp.exception();
365 | 		}
366 | 		resp.buildMap();
367 | 		return resp;
368 | 	}
369 | 	
370 | 	public Response multi_get(byte[]...keys) throws Exception{
371 | 		Response resp = link.request("multi_get", keys);
372 | 		if(!resp.ok()){
373 | 			resp.exception();
374 | 		}
375 | 		resp.buildMap();
376 | 		return resp;
377 | 	}
378 | 	
379 | 	public void multi_set(String...kvs) throws Exception{
380 | 		if(kvs.length % 2 != 0){
381 | 			throw new Exception("Invalid arguments count");
382 | 		}
383 | 		Response resp = link.request("multi_set", kvs);
384 | 		if(!resp.ok()){
385 | 			resp.exception();
386 | 		}
387 | 	}
388 | 	
389 | 	public void multi_set(byte[]...kvs) throws Exception{
390 | 		if(kvs.length % 2 != 0){
391 | 			throw new Exception("Invalid arguments count");
392 | 		}
393 | 		Response resp = link.request("multi_set", kvs);
394 | 		if(!resp.ok()){
395 | 			resp.exception();
396 | 		}
397 | 	}
398 | 	
399 | 	public Response multi_del(String...keys) throws Exception{
400 | 		Response resp = link.request("multi_del", keys);
401 | 		if(!resp.ok()){
402 | 			resp.exception();
403 | 		}
404 | 		resp.buildMap();
405 | 		return resp;
406 | 	}
407 | 	
408 | 	public Response multi_del(byte[]...keys) throws Exception{
409 | 		Response resp = link.request("multi_del", keys);
410 | 		if(!resp.ok()){
411 | 			resp.exception();
412 | 		}
413 | 		resp.buildMap();
414 | 		return resp;
415 | 	}
416 | }
417 | 


--------------------------------------------------------------------------------