Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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 org.apache.thrift.protocol; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.util.Stack; import org.apache.thrift.TByteArrayOutputStream; import org.apache.thrift.TException; import org.apache.thrift.transport.TTransport; /** * JSON protocol implementation for thrift. * This is a full-featured protocol supporting write and read. * Please see the C++ class header for a detailed description of the * protocol's wire format. */ public class TJSONProtocol extends TProtocol { /** * Factory for JSON protocol objects */ public static class Factory implements TProtocolFactory { public TProtocol getProtocol(TTransport trans) { return new TJSONProtocol(trans); } } private static final byte[] COMMA = new byte[] { ',' }; private static final byte[] COLON = new byte[] { ':' }; private static final byte[] LBRACE = new byte[] { '{' }; private static final byte[] RBRACE = new byte[] { '}' }; private static final byte[] LBRACKET = new byte[] { '[' }; private static final byte[] RBRACKET = new byte[] { ']' }; private static final byte[] QUOTE = new byte[] { '"' }; private static final byte[] BACKSLASH = new byte[] { '\\' }; private static final byte[] ZERO = new byte[] { '0' }; private static final byte[] ESCSEQ = new byte[] { '\\', 'u', '0', '0' }; private static final long VERSION = 1; private static final byte[] JSON_CHAR_TABLE = { /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ 0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1 1, 1, '"', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2 }; private static final String ESCAPE_CHARS = "\"\\/bfnrt"; private static final byte[] ESCAPE_CHAR_VALS = { '"', '\\', '/', '\b', '\f', '\n', '\r', '\t', }; private static final int DEF_STRING_SIZE = 16; private static final byte[] NAME_BOOL = new byte[] { 't', 'f' }; private static final byte[] NAME_BYTE = new byte[] { 'i', '8' }; private static final byte[] NAME_I16 = new byte[] { 'i', '1', '6' }; private static final byte[] NAME_I32 = new byte[] { 'i', '3', '2' }; private static final byte[] NAME_I64 = new byte[] { 'i', '6', '4' }; private static final byte[] NAME_DOUBLE = new byte[] { 'd', 'b', 'l' }; private static final byte[] NAME_STRUCT = new byte[] { 'r', 'e', 'c' }; private static final byte[] NAME_STRING = new byte[] { 's', 't', 'r' }; private static final byte[] NAME_MAP = new byte[] { 'm', 'a', 'p' }; private static final byte[] NAME_LIST = new byte[] { 'l', 's', 't' }; private static final byte[] NAME_SET = new byte[] { 's', 'e', 't' }; private static final TStruct ANONYMOUS_STRUCT = new TStruct(); private static final byte[] getTypeNameForTypeID(byte typeID) throws TException { switch (typeID) { case TType.BOOL: return NAME_BOOL; case TType.BYTE: return NAME_BYTE; case TType.I16: return NAME_I16; case TType.I32: return NAME_I32; case TType.I64: return NAME_I64; case TType.DOUBLE: return NAME_DOUBLE; case TType.STRING: return NAME_STRING; case TType.STRUCT: return NAME_STRUCT; case TType.MAP: return NAME_MAP; case TType.SET: return NAME_SET; case TType.LIST: return NAME_LIST; default: throw new TProtocolException(TProtocolException.NOT_IMPLEMENTED, "Unrecognized type"); } } private static final byte getTypeIDForTypeName(byte[] name) throws TException { byte result = TType.STOP; if (name.length > 1) { switch (name[0]) { case 'd': result = TType.DOUBLE; break; case 'i': switch (name[1]) { case '8': result = TType.BYTE; break; case '1': result = TType.I16; break; case '3': result = TType.I32; break; case '6': result = TType.I64; break; } break; case 'l': result = TType.LIST; break; case 'm': result = TType.MAP; break; case 'r': result = TType.STRUCT; break; case 's': if (name[1] == 't') { result = TType.STRING; } else if (name[1] == 'e') { result = TType.SET; } break; case 't': result = TType.BOOL; break; } } if (result == TType.STOP) { throw new TProtocolException(TProtocolException.NOT_IMPLEMENTED, "Unrecognized type"); } return result; } // Base class for tracking JSON contexts that may require inserting/reading // additional JSON syntax characters // This base context does nothing. protected class JSONBaseContext { /** * @throws TException */ protected void write() throws TException { } /** * @throws TException */ protected void read() throws TException { } protected boolean escapeNum() { return false; } } // Context for JSON lists. Will insert/read commas before each item except // for the first one protected class JSONListContext extends JSONBaseContext { private boolean first_ = true; protected void write() throws TException { if (first_) { first_ = false; } else { trans_.write(COMMA); } } protected void read() throws TException { if (first_) { first_ = false; } else { readJSONSyntaxChar(COMMA); } } } // Context for JSON records. Will insert/read colons before the value portion // of each record pair, and commas before each key except the first. In // addition, will indicate that numbers in the key position need to be // escaped in quotes (since JSON keys must be strings). protected class JSONPairContext extends JSONBaseContext { private boolean first_ = true; private boolean colon_ = true; protected void write() throws TException { if (first_) { first_ = false; colon_ = true; } else { trans_.write(colon_ ? COLON : COMMA); colon_ = !colon_; } } protected void read() throws TException { if (first_) { first_ = false; colon_ = true; } else { readJSONSyntaxChar(colon_ ? COLON : COMMA); colon_ = !colon_; } } protected boolean escapeNum() { return colon_; } } // Holds up to one byte from the transport protected class LookaheadReader { private boolean hasData_; private byte[] data_ = new byte[1]; // Return and consume the next byte to be read, either taking it from the // data buffer if present or getting it from the transport otherwise. protected byte read() throws TException { if (hasData_) { hasData_ = false; } else { trans_.readAll(data_, 0, 1); } return data_[0]; } // Return the next byte to be read without consuming, filling the data // buffer if it has not been filled already. protected byte peek() throws TException { if (!hasData_) { trans_.readAll(data_, 0, 1); } hasData_ = true; return data_[0]; } } // Stack of nested contexts of type JSONBaseContext that we may be in private Stack contextStack_ = new Stack(); // Current context that we are in private JSONBaseContext context_ = new JSONBaseContext(); // Reader that manages a 1-byte buffer private LookaheadReader reader_ = new LookaheadReader(); // Push a new JSON context onto the stack. private void pushContext(JSONBaseContext c) { contextStack_.push(context_); context_ = c; } // Pop the last JSON context off the stack private void popContext() { context_ = (JSONBaseContext) contextStack_.pop(); } /** * Constructor */ public TJSONProtocol(TTransport trans) { super(trans); } public void reset() { contextStack_.clear(); context_ = new JSONBaseContext(); reader_ = new LookaheadReader(); } // Temporary buffer used by several methods private byte[] tmpbuf_ = new byte[4]; // Read a byte that must match b[0]; otherwise an exception is thrown. // Marked protected to avoid synthetic accessor in JSONListContext.read // and JSONPairContext.read protected void readJSONSyntaxChar(byte[] b) throws TException { byte ch = reader_.read(); if (ch != b[0]) { throw new TProtocolException(TProtocolException.INVALID_DATA, "Unexpected character:" + (char) ch); } } // Convert a byte containing a hex char ('0'-'9' or 'a'-'f') into its // corresponding hex value private static final byte hexVal(byte ch) throws TException { if ((ch >= '0') && (ch <= '9')) { return (byte) ((char) ch - '0'); } else if ((ch >= 'a') && (ch <= 'f')) { return (byte) ((char) ch - 'a' + 10); } else { throw new TProtocolException(TProtocolException.INVALID_DATA, "Expected hex character"); } } // Convert a byte containing a hex value to its corresponding hex character private static final byte hexChar(byte val) { val &= 0x0F; if (val < 10) { return (byte) ((char) val + '0'); } else { return (byte) ((char) (val - 10) + 'a'); } } private static boolean isHighSurrogate(char c) { return c >= '\uD800' && c <= '\uDBFF'; } private static boolean isLowSurrogate(char c) { return c >= '\uDC00' && c <= '\uDFFF'; } private static byte[] toUTF8(int codepoint) { final int[] FIRST_BYTE_MASK = { 0, 0xc0, 0xe0, 0xf0 }; int length = 0; if (codepoint <= 0x7f) length = 1; else if (codepoint <= 0x7ff) length = 2; else if (codepoint <= 0xffff) length = 3; else if (codepoint <= 0x1fffff) length = 4; else throw new RuntimeException("Code point over U+1FFFFF is not supported"); byte[] bytes = new byte[length]; switch (length) { case 4: bytes[3] = (byte) ((codepoint & 0x3f) | 0x80); codepoint >>= 6; case 3: bytes[2] = (byte) ((codepoint & 0x3f) | 0x80); codepoint >>= 6; case 2: bytes[1] = (byte) ((codepoint & 0x3f) | 0x80); codepoint >>= 6; case 1: bytes[0] = (byte) (codepoint | FIRST_BYTE_MASK[length - 1]); } return bytes; } private static byte[] toUTF8(int high, int low) { int codepoint = (1 << 16) + ((high & 0x3ff) << 10); codepoint += low & 0x3ff; return toUTF8(codepoint); } // Write the bytes in array buf as a JSON characters, escaping as needed private void writeJSONString(byte[] b) throws TException { context_.write(); trans_.write(QUOTE); int len = b.length; for (int i = 0; i < len; i++) { if ((b[i] & 0x00FF) >= 0x30) { if (b[i] == BACKSLASH[0]) { trans_.write(BACKSLASH); trans_.write(BACKSLASH); } else { trans_.write(b, i, 1); } } else { tmpbuf_[0] = JSON_CHAR_TABLE[b[i]]; if (tmpbuf_[0] == 1) { trans_.write(b, i, 1); } else if (tmpbuf_[0] > 1) { trans_.write(BACKSLASH); trans_.write(tmpbuf_, 0, 1); } else { trans_.write(ESCSEQ); tmpbuf_[0] = hexChar((byte) (b[i] >> 4)); tmpbuf_[1] = hexChar(b[i]); trans_.write(tmpbuf_, 0, 2); } } } trans_.write(QUOTE); } // Write out number as a JSON value. If the context dictates so, it will be // wrapped in quotes to output as a JSON string. private void writeJSONInteger(long num) throws TException { context_.write(); String str = Long.toString(num); boolean escapeNum = context_.escapeNum(); if (escapeNum) { trans_.write(QUOTE); } try { byte[] buf = str.getBytes("UTF-8"); trans_.write(buf); } catch (UnsupportedEncodingException uex) { throw new TException("JVM DOES NOT SUPPORT UTF-8"); } if (escapeNum) { trans_.write(QUOTE); } } // Write out a double as a JSON value. If it is NaN or infinity or if the // context dictates escaping, write out as JSON string. private void writeJSONDouble(double num) throws TException { context_.write(); String str = Double.toString(num); boolean special = false; switch (str.charAt(0)) { case 'N': // NaN case 'I': // Infinity special = true; break; case '-': if (str.charAt(1) == 'I') { // -Infinity special = true; } break; } boolean escapeNum = special || context_.escapeNum(); if (escapeNum) { trans_.write(QUOTE); } try { byte[] b = str.getBytes("UTF-8"); trans_.write(b, 0, b.length); } catch (UnsupportedEncodingException uex) { throw new TException("JVM DOES NOT SUPPORT UTF-8"); } if (escapeNum) { trans_.write(QUOTE); } } // Write out contents of byte array b as a JSON string with base-64 encoded // data private void writeJSONBase64(byte[] b, int offset, int length) throws TException { context_.write(); trans_.write(QUOTE); int len = length; int off = offset; while (len >= 3) { // Encode 3 bytes at a time TBase64Utils.encode(b, off, 3, tmpbuf_, 0); trans_.write(tmpbuf_, 0, 4); off += 3; len -= 3; } if (len > 0) { // Encode remainder TBase64Utils.encode(b, off, len, tmpbuf_, 0); trans_.write(tmpbuf_, 0, len + 1); } trans_.write(QUOTE); } private void writeJSONObjectStart() throws TException { context_.write(); trans_.write(LBRACE); pushContext(new JSONPairContext()); } private void writeJSONObjectEnd() throws TException { popContext(); trans_.write(RBRACE); } private void writeJSONArrayStart() throws TException { context_.write(); trans_.write(LBRACKET); pushContext(new JSONListContext()); } private void writeJSONArrayEnd() throws TException { popContext(); trans_.write(RBRACKET); } public void writeMessageBegin(TMessage message) throws TException { writeJSONArrayStart(); writeJSONInteger(VERSION); try { byte[] b = message.name.getBytes("UTF-8"); writeJSONString(b); } catch (UnsupportedEncodingException uex) { throw new TException("JVM DOES NOT SUPPORT UTF-8"); } writeJSONInteger(message.type); writeJSONInteger(message.seqid); } public void writeMessageEnd() throws TException { writeJSONArrayEnd(); } public void writeStructBegin(TStruct struct) throws TException { writeJSONObjectStart(); } public void writeStructEnd() throws TException { writeJSONObjectEnd(); } public void writeFieldBegin(TField field) throws TException { writeJSONInteger(field.id); writeJSONObjectStart(); writeJSONString(getTypeNameForTypeID(field.type)); } public void writeFieldEnd() throws TException { writeJSONObjectEnd(); } public void writeFieldStop() { } public void writeMapBegin(TMap map) throws TException { writeJSONArrayStart(); writeJSONString(getTypeNameForTypeID(map.keyType)); writeJSONString(getTypeNameForTypeID(map.valueType)); writeJSONInteger(map.size); writeJSONObjectStart(); } public void writeMapEnd() throws TException { writeJSONObjectEnd(); writeJSONArrayEnd(); } public void writeListBegin(TList list) throws TException { writeJSONArrayStart(); writeJSONString(getTypeNameForTypeID(list.elemType)); writeJSONInteger(list.size); } public void writeListEnd() throws TException { writeJSONArrayEnd(); } public void writeSetBegin(TSet set) throws TException { writeJSONArrayStart(); writeJSONString(getTypeNameForTypeID(set.elemType)); writeJSONInteger(set.size); } public void writeSetEnd() throws TException { writeJSONArrayEnd(); } public void writeBool(boolean b) throws TException { writeJSONInteger(b ? (long) 1 : (long) 0); } public void writeByte(byte b) throws TException { writeJSONInteger(b); } public void writeI16(short i16) throws TException { writeJSONInteger(i16); } public void writeI32(int i32) throws TException { writeJSONInteger(i32); } public void writeI64(long i64) throws TException { writeJSONInteger(i64); } public void writeDouble(double dub) throws TException { writeJSONDouble(dub); } public void writeString(String str) throws TException { try { byte[] b = str.getBytes("UTF-8"); writeJSONString(b); } catch (UnsupportedEncodingException uex) { throw new TException("JVM DOES NOT SUPPORT UTF-8"); } } public void writeBinary(byte[] bin) throws TException { writeJSONBase64(bin, 0, bin.length); } /** * Reading methods. */ // Read in a JSON string, unescaping as appropriate.. Skip reading from the // context if skipContext is true. private TByteArrayOutputStream readJSONString(boolean skipContext) throws TException { TByteArrayOutputStream arr = new TByteArrayOutputStream(DEF_STRING_SIZE); int highSurrogate = 0; if (!skipContext) { context_.read(); } readJSONSyntaxChar(QUOTE); while (true) { byte ch = reader_.read(); if (ch == QUOTE[0]) { break; } if (ch == ESCSEQ[0]) { ch = reader_.read(); if (ch == ESCSEQ[1]) { trans_.readAll(tmpbuf_, 0, 4); short cu = (short) (((short) hexVal(tmpbuf_[0]) << 12) + ((short) hexVal(tmpbuf_[1]) << 8) + ((short) hexVal(tmpbuf_[2]) << 4) + (short) hexVal(tmpbuf_[3])); try { if (isHighSurrogate((char) cu)) { if (highSurrogate != 0) { throw new TProtocolException(TProtocolException.INVALID_DATA, "Expected low surrogate char"); } highSurrogate = cu; } else if (isLowSurrogate((char) cu)) { if (highSurrogate == 0) { throw new TProtocolException(TProtocolException.INVALID_DATA, "Expected high surrogate char"); } arr.write(toUTF8(highSurrogate, cu)); highSurrogate = 0; } else { arr.write(toUTF8(cu)); } continue; } catch (UnsupportedEncodingException ex) { throw new TProtocolException(TProtocolException.NOT_IMPLEMENTED, "JVM does not support UTF-8"); } catch (IOException ex) { throw new TProtocolException(TProtocolException.INVALID_DATA, "Invalid unicode sequence"); } } else { int off = ESCAPE_CHARS.indexOf(ch); if (off == -1) { throw new TProtocolException(TProtocolException.INVALID_DATA, "Expected control char"); } ch = ESCAPE_CHAR_VALS[off]; } } arr.write(ch); } if (highSurrogate != 0) { throw new TProtocolException(TProtocolException.INVALID_DATA, "Expected low surrogate char"); } return arr; } // Return true if the given byte could be a valid part of a JSON number. private boolean isJSONNumeric(byte b) { switch (b) { case '+': case '-': case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'E': case 'e': return true; } return false; } // Read in a sequence of characters that are all valid in JSON numbers. Does // not do a complete regex check to validate that this is actually a number. private String readJSONNumericChars() throws TException { StringBuffer strbuf = new StringBuffer(); while (true) { byte ch = reader_.peek(); if (!isJSONNumeric(ch)) { break; } strbuf.append((char) reader_.read()); } return strbuf.toString(); } // Read in a JSON number. If the context dictates, read in enclosing quotes. private long readJSONInteger() throws TException { context_.read(); if (context_.escapeNum()) { readJSONSyntaxChar(QUOTE); } String str = readJSONNumericChars(); if (context_.escapeNum()) { readJSONSyntaxChar(QUOTE); } try { return Long.valueOf(str).longValue(); } catch (NumberFormatException ex) { throw new TProtocolException(TProtocolException.INVALID_DATA, "Bad data encounted in numeric data"); } } // Read in a JSON double value. Throw if the value is not wrapped in quotes // when expected or if wrapped in quotes when not expected. private double readJSONDouble() throws TException { context_.read(); if (reader_.peek() == QUOTE[0]) { TByteArrayOutputStream arr = readJSONString(true); try { double dub = Double.valueOf(arr.toString("UTF-8")).doubleValue(); if (!context_.escapeNum() && !Double.isNaN(dub) && !Double.isInfinite(dub)) { // Throw exception -- we should not be in a string in this case throw new TProtocolException(TProtocolException.INVALID_DATA, "Numeric data unexpectedly quoted"); } return dub; } catch (UnsupportedEncodingException ex) { throw new TException("JVM DOES NOT SUPPORT UTF-8"); } } else { if (context_.escapeNum()) { // This will throw - we should have had a quote if escapeNum == true readJSONSyntaxChar(QUOTE); } try { return Double.valueOf(readJSONNumericChars()).doubleValue(); } catch (NumberFormatException ex) { throw new TProtocolException(TProtocolException.INVALID_DATA, "Bad data encounted in numeric data"); } } } // Read in a JSON string containing base-64 encoded data and decode it. private byte[] readJSONBase64() throws TException { TByteArrayOutputStream arr = readJSONString(false); byte[] b = arr.get(); int len = arr.len(); int off = 0; int size = 0; // Ignore padding int bound = len >= 2 ? len - 2 : 0; for (int i = len - 1; i >= bound && b[i] == '='; --i) { --len; } while (len >= 4) { // Decode 4 bytes at a time TBase64Utils.decode(b, off, 4, b, size); // NB: decoded in place off += 4; len -= 4; size += 3; } // Don't decode if we hit the end or got a single leftover byte (invalid // base64 but legal for skip of regular string type) if (len > 1) { // Decode remainder TBase64Utils.decode(b, off, len, b, size); // NB: decoded in place size += len - 1; } // Sadly we must copy the byte[] (any way around this?) byte[] result = new byte[size]; System.arraycopy(b, 0, result, 0, size); return result; } private void readJSONObjectStart() throws TException { context_.read(); readJSONSyntaxChar(LBRACE); pushContext(new JSONPairContext()); } private void readJSONObjectEnd() throws TException { readJSONSyntaxChar(RBRACE); popContext(); } private void readJSONArrayStart() throws TException { context_.read(); readJSONSyntaxChar(LBRACKET); pushContext(new JSONListContext()); } private void readJSONArrayEnd() throws TException { readJSONSyntaxChar(RBRACKET); popContext(); } public TMessage readMessageBegin() throws TException { readJSONArrayStart(); if (readJSONInteger() != VERSION) { throw new TProtocolException(TProtocolException.BAD_VERSION, "Message contained bad version."); } String name; try { name = readJSONString(false).toString("UTF-8"); } catch (UnsupportedEncodingException ex) { throw new TException("JVM DOES NOT SUPPORT UTF-8"); } byte type = (byte) readJSONInteger(); int seqid = (int) readJSONInteger(); return new TMessage(name, type, seqid); } public void readMessageEnd() throws TException { readJSONArrayEnd(); } public TStruct readStructBegin() throws TException { readJSONObjectStart(); return ANONYMOUS_STRUCT; } public void readStructEnd() throws TException { readJSONObjectEnd(); } public TField readFieldBegin() throws TException { byte ch = reader_.peek(); byte type; short id = 0; if (ch == RBRACE[0]) { type = TType.STOP; } else { id = (short) readJSONInteger(); readJSONObjectStart(); type = getTypeIDForTypeName(readJSONString(false).get()); } return new TField("", type, id); } public void readFieldEnd() throws TException { readJSONObjectEnd(); } public TMap readMapBegin() throws TException { readJSONArrayStart(); byte keyType = getTypeIDForTypeName(readJSONString(false).get()); byte valueType = getTypeIDForTypeName(readJSONString(false).get()); int size = (int) readJSONInteger(); readJSONObjectStart(); return new TMap(keyType, valueType, size); } public void readMapEnd() throws TException { readJSONObjectEnd(); readJSONArrayEnd(); } public TList readListBegin() throws TException { readJSONArrayStart(); byte elemType = getTypeIDForTypeName(readJSONString(false).get()); int size = (int) readJSONInteger(); return new TList(elemType, size); } public void readListEnd() throws TException { readJSONArrayEnd(); } public TSet readSetBegin() throws TException { readJSONArrayStart(); byte elemType = getTypeIDForTypeName(readJSONString(false).get()); int size = (int) readJSONInteger(); return new TSet(elemType, size); } public void readSetEnd() throws TException { readJSONArrayEnd(); } public boolean readBool() throws TException { return (readJSONInteger() == 0 ? false : true); } public byte readByte() throws TException { return (byte) readJSONInteger(); } public short readI16() throws TException { return (short) readJSONInteger(); } public int readI32() throws TException { return (int) readJSONInteger(); } public long readI64() throws TException { return readJSONInteger(); } public double readDouble() throws TException { return readJSONDouble(); } public String readString() throws TException { try { return readJSONString(false).toString("UTF-8"); } catch (UnsupportedEncodingException ex) { throw new TException("JVM DOES NOT SUPPORT UTF-8"); } } public byte[] readBinary() throws TException { return readJSONBase64(); } }