Hessian 2.0序列化协议规范

Hessian语法

序列化语法

#starting production
top ::=value

#分割成64k每chunk的8-bit二进制数据
binary ::= 'b' b1 b0 <binary-data> binary #不是最后一个chunk
::= 'B' b1 b0 <binary-data> #最后一个chunk
::= [x20-x2f] <binary-data> #长度范围为 0-15

#boolean true/false
boolean ::= 'T'
::= 'F'

#对象的定义(compact map)
class-def ::= 'O' type int string*

#time in UTC encoded as 64-bit long milliseconds since epoch
date ::= 'd' b7 b6 b5 b4 b3 b2 b1 b0

#64-bit IEEE double
double ::= 'D' b7 b6 b5 b4 b3 b2 b1 b0
::= x67 #0.0
::= x68 #1.0
::= x69 b0 #byte表示的double(-128.0 to 127.0)
::= x6a b1 b0 #short表示的double
::= x6b b3 b2 b1 b0 #32-bit float表示的double

#32-bit 有符号整型
int ::= 'I' b3 b2 b1 b0
::= [x80-xbf] #-x10 to x3f
::= [xc0-xcf] b0 #-x800 to x7ff
::= [xd0-xd7] b1 b0 #-x40000 to x3ffff

# list/vector length
length ::= 'l' b3 b2 b1 b0
::= x6e int

# list/vector
list ::= 'V' type? length? value* 'z'
::= 'v' int int value* #第一个int表示类型引用, 第二个int表示长度

#64-bit有符号long
long ::= 'L' b7 b6 b5 b4 b3 b2 b1 0
::= [xd8-xef] #-x08 to x0f
::= [xf0-xff] b0 #-x800 to x7ff
::= [x38-x3f] b1 b0 #-x40000 to x3ffff
::= x77 b3 b2 b1 b0 #32-bit 整型表示的long

#map/object
map ::= 'M' type? (value value)* 'z' #key, value map pairs

# null value
null ::= 'N'

#对象实例
object ::= 'o' int value*

#值引用
ref ::= 'R' b3 b2 b1 b0 # 对流中第n个map/list/object的引用

::= x4a b0 # 对map/list/object的引用，范围为1-255th
::= x4b b1 b0 # 对map/list/object 的引用，范围为1-65535th

#UTF-8 编码的字符串，分割成64k大小的chunks
string ::= 's' b1 b0 <utf8-data> string #非末尾chunk
::= 'S' b1 b0 <utf8-data> #长度范围为(0-65535)的字符串
::=[x00-x1f] <utf8-data> #长度范围为(0-31) 的字符串

#map/list 的类型（针对面向对象语言)
type ::= 't' b1 b0 <type-string> #类型名称
::= x75 int #类型引用值（用整数表示）

#main production
value ::=null
::= binary
::= boolean
::= date
::= double
::= int
::= list
::= long
::= map
::= class-def value
::= ref
::= string

二进制

二进制数据被分割成chunk，十六进制数x42（'B'）标识最后一个chunk，x62（'b'）标识普通的chunk，每个chunk有一个16-bit的长度值len=256*b1+b0。

长度小于15的二进制数据只需用单个十六进制数字来表示[x20-x2f]，len=code-0x20。

实例：

x20 #零长度的二进制数据
x23 x01 x02 x03 #长度为3的数据
B x10 x00 .... #4k大小的final chunk
b x04 x00 .... #1k大小的non-final chunk
Date
Date采用64-bit来表示距1970 00:00H，UTC以来经过的milliseconds。

double

符合IEEE标准的64-bit浮点数。

double ::= D b7 b6 b5 b4 b3 b2 b1 b0
::= x67
::= x68
::= x69 b0
::= x6a b1 b0
::= x6b b3 b2 b1 b0

（1）0.0用x67来表示
（2）1.0用x68来表示

（3）介于-128.0-127.0之间的无小数位的double型可以用两个十六进制来表示。

（4）介于-32768.0-32767之间的无小数位的double型可以用3个十六进制来表示。

（5）和32-bit float型等价的double能够用4个十六进制的float来表示。

x67 # 0.0
x68 # 1.0

x69 x00 # 0.0
x69 x80 # -128.0
x69 xff # 127.0

x70 x00 x00 # 0.0
x70 x80 x00 # -32768.0
x70 xff xff # 32767.0

D x40 x28 x80 x00 x00 x00 x00 x00 # 12.25

int

int ::= ’I’ b3 b2 b1 b0
::= [x80-xbf]
::= [xc0-xcf] b0
::= [xd0-xd7] b1 b0

一个整数由跟随在x49（'|'）之后的4个大端序（big-endian）的十六进数来表示。
value=(b3<<24)+(b2<<16)+(b1<<8)+b0

（1）介于-16和47之间的整型可以用单个字节来表示，用十六进制来表示范围

value=code-0x90

（2）介于-2048-2047之间的整型可以用两个字节来表示

value=((code-0xc8)<<8)+b0

（3）介于-2621444-262143之间的整型可以用三个字节来表示。

x90 # 0
x80 # -16
xbf # 47

xc8 x00 # 0
xc0 x00 # -2048
xc7 x00 # -256
xcf xff # 2047

xd4 x00 x00 # 0
xd0 x00 x00 # -262144
xd7 xff xff # 262143

I x00 x00 x00 x00 # 0
I x00 x00 x01 x2c # 300

list

list ::= V type? length? value* z
::=V int int value*

一个序列表，每个list都包含一个type字符串，长度length和一个值列表，以十六进制x7a（'z'）作为结尾。type可以是任意的UTF-8编码的字符串，length指定了值列表的长度。list的每个值都被添加到一个引用列表中，这样，所有list中的相同条目都共享同一份引用以节省空间。
Hessian2.0制定了一个格式紧凑的list，其中list元素类型和元素个数length都用整型来编码。

long

long ::=    L b7 b6 b5 b4 b3 b2 b1 b0
::=    [xd8-xef]
::=    [xf0-xff] b0
::=    [x38-x3f] b1 b0
::=    x77 b3 b2 b1 b0

一个64-bit的有符号整数，起头由十六进制x4c（‘L’）标识，后面为8字节的big-endian的整数。

（1）介于-8和15之间的long由单个字节表示

value=code-0xe0

（2）双字节

value=(code-0xf8)<<8+b0

（3）3字节

value=(code-0x3c)<<16+b1<<8+b0

map

map ::= M type? (value value)* z

type字段用来表示map类型，type可能为空，如果未指定，则由解析器来负责选择类型。

object

object ::= ‘o’ int value*
class-def ::=’O’ type int string*

类定义包括字符串、字段个数，所有的字段名，类定义被存在一个对象定义表中，每个类定义由一个唯一的整数作为key标识，之后被对象实例通过key来引用。

Class Car{
String color;
String model;
}
out.wirteObject(new Car(“red”, “corvette”));
out.writeObject(new Car(“green”, “civic”));

O # 类型定义 (假定在类型表中对应key为 0)
t x00 x0b example.Car # 类型为example.Car
x92 # 两个字段
x05 color # color字段名
x05 model # model字段名

o
x90 # 对象定义 (类型引用key=0)
x03 red # color字段取值
x08 corvette # model字段取值

o
x90 # 对象定义 (类型引用key=0)
x05 green # color字段取值
x05 civic # model字段取值

字节码映射表（Bytecode map）

x00 - x1f # utf-8字符串，长度范围 0-32
x20 - x2f # 二进制数据，长度范围 0-16
x30 - x37 # 保留
x38 - x3f # 长整型long 范围从-x40000 到 x3ffff
x40 - x41 # 保留
x42 # 8-bit 二进制数据，表示末尾chunk('B')
x43 # 保留('C' streaming call)
x44 # 64-bit IEEE 规范编码的双精度浮点double ('D')
x45 # 保留('E' envelope)
x46 # boolean false ('F')
x47 # 保留
x48 # 保留 ('H' header)
x49 # 32-bit有符号整型signed integer ('I')
x4a # 引用(ref)，范围为1-256th
x4b # 引用(ref)，范围为1-65536th
x4c # 64-bit有符号长整型long integer ('L')
x4d # 具有可选类型的map ('M')
x4e # null ('N')
x4f # 类型定义('O')
x50 # 保留('P' streaming message/post)
x51 # 保留
x52 # 引用(ref)，取值范围对应于整型int ('R')
x53 # utf-8字符串，末尾chunk ('S')
x54 # boolean true ('T')
x55 # 保留
x56 # list/vector ('V')
x57 - x62 # 保留
x62 # 8-bit二进制数据，非末尾chunk ('b')
x63 # 保留 ('c' call for RPC)
x64 # UTC time encoded as 64-bit long milliseconds since epoch ('d')
x65 # 保留
x66 # 保留('f' for fault for RPC)
x67 # double 0.0
x68 # double 1.0
x69 # double represented as byte (-128.0 to 127.0)
x6a # double represented as short (-32768.0 to 327676.0)
x6b # double represented as float
x6c # list/vector length ('l')
x6d # 保留 ('m' method for RPC call)
x6e # list/vector compact length
x6f # 对象实例('o')
x70 # 保留 ('p' - message/post)
x71 # 保留
x72 # 保留('r' reply for message/RPC)
x73 # utf-8字符串，非末尾chunk ('s')
x74 # map/list type ('t')
x75 # type-ref
x76 # 压缩格式的vector ('v')
x77 # 以32-bit整型编码的long
x78 - x79 # 保留
x7a # list/map 终止符('z')
x7b - x7f # 保留
x80 - xbf # 单字节压缩格式的整型int(-x10 to x3f, x90 is 0)
xc0 - xcf # 双字节压缩格式的整型int(-x800 to x3ff)
xd0 - xd7 # 三字节压缩格式的整型int(-x40000 to x3ffff)
xd8 - xef # 单字节压缩格式的长整型long(-x8 to x10, xe0 is 0)
xf0 - xff # 双字节压缩格式的长整型long (-x800 to x3ff, xf8 is 0)