Hessian二进制的网络协议使不需要引入大型框架下就可以使用，并且不需要学习其它的入门的协议。因为它是二进制协议，它更擅长于发送二进制数据，而不需要引入其它附件去扩展它的协议。
Hessian支持很多种语言，例如Java，Flash/Flex,python,c++,.net/c#,D,Erlang,PHP,Ruby,Object C等
下面我们就一起阅读一下Hessian2.0的文档，文档链接
Hessian是一个动态类型,二进制序列化,也是网络协议为了对象的定向传输。
Hessian是一个动态类型，简洁的，可以移植到各个语言
Hessian协议有以下的设计目标：
- 它必须自我描述序列化的类型，即不需要外部架构和接口定义
- 它必须是语言语言独立的，要支持包括脚本语言
- 它必须是可读可写的在单一的途径
- 它要尽可能的简洁
- 它必须是简单的，它可以有效地测试和实施
- 尽可能的快
- 必须要支持Unicode编码
- 它必须支持八位二进制文件，而不是逃避或者用附件
- 它必须支持加密,压缩,签名,还有事务的上下文
序列化语法：
# starting production
top ::= value
# 8-bit binary data split into 64k chunks
binary ::= x41 b1 b0 <binary-data> binary # non-final chunk
::= 'B' b1 b0 <binary-data> # final chunk
::= [x20-x2f] <binary-data> # binary data of
# length 0-15
::= [x34-x37] <binary-data> # binary data of
# length 0-1023
# boolean true/false
boolean ::= 'T'
::= 'F'
# definition for an object (compact map)
class-def ::= 'C' string int string*
# time in UTC encoded as 64-bit long milliseconds since
# epoch
date ::= x4a b7 b6 b5 b4 b3 b2 b1 b0
::= x4b b3 b2 b1 b0 # minutes since epoch
# 64-bit IEEE double
double ::= 'D' b7 b6 b5 b4 b3 b2 b1 b0
::= x5b # 0.0
::= x5c # 1.0
::= x5d b0 # byte cast to double
# (-128.0 to 127.0)
::= x5e b1 b0 # short cast to double
::= x5f b3 b2 b1 b0 # 32-bit float cast to double
# 32-bit signed integer
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
list ::= x55 type value* 'Z' # variable-length list
::= 'V' type int value* # fixed-length list
::= x57 value* 'Z' # variable-length untyped list
::= x58 int value* # fixed-length untyped list
::= [x70-77] type value* # fixed-length typed list
::= [x78-7f] value* # fixed-length untyped list
# 64-bit signed long integer
long ::= 'L' b7 b6 b5 b4 b3 b2 b1 b0
::= [xd8-xef] # -x08 to x0f
::= [xf0-xff] b0 # -x800 to x7ff
::= [x38-x3f] b1 b0 # -x40000 to x3ffff
::= x59 b3 b2 b1 b0 # 32-bit integer cast to long
# map/object
map ::= 'M' type (value value)* 'Z' # key, value map pairs
::= 'H' (value value)* 'Z' # untyped key, value
# null value
null ::= 'N'
# Object instance
object ::= 'O' int value*
::= [x60-x6f] value*
# value reference (e.g. circular trees and graphs)
ref ::= x51 int # reference to nth map/list/object
# UTF-8 encoded character string split into 64k chunks
string ::= x52 b1 b0 <utf8-data> string # non-final chunk
::= 'S' b1 b0 <utf8-data> # string of length
# 0-65535
::= [x00-x1f] <utf8-data> # string of length
# 0-31
::= [x30-x34] <utf8-data> # string of length
# 0-1023
# map/list types for OO languages
type ::= string # type name
::= int # type reference
# main production
value ::= null
::= binary
::= boolean
::= class-def value
::= date
::= double
::= int
::= list
::= long
::= map
::= object
::= ref
::= string
Hessian的对象有八种原始类型：
- 原生二进制数据
- Boolean
- 64位毫秒值的日期
- 64位double
- 32位int
- 64位long
- null
- utf-8的string
它有三种循环的类型：
- list for lists and arrays
- map for maps and dictionaries
- object for objects
最后，他有一种特殊组成:
- 共享和循环对象引用
Hessian 2.0 有三种内置的map：
- 一个object/list参考的map
- 一个类参考定义的map
- 一个类参考的map
binary ::= b b1 b0 <binary-data> binary
::= B b1 b0 <binary-data>
::= [x20-x2f] <binary-data>
二进制数据被编码成二进制编码块，'B'代表最后一块，'b'代表任编码块非最后一块的部分，每一个编码块有16 bit的长度。
len = 256 * b1 + b0
Binary data with length less than 15 may be encoded by a single octet length [x20-x2f].
len = code - 0x20
当二进制数据少于15的时候，可以用一个字节将他们编码。
x20 # zero-length binary data
x23 x01 x02 x03 # 3 octet data
B x10 x00 .... # 4k final chunk of data
b x04 x00 .... # 1k non-final chunk of data
boolean ::= T
::= F
The octet 'F' represents false and the octet T represents true.
时间编码：
date ::= x4a b7 b6 b5 b4 b3 b2 b1 b0
::= x4b b4 b3 b2 b1 b0
Date represented by a 64-bit long of milliseconds since Jan 1 1970 00:00H, UTC.
The second form contains a 32-bit int of minutes since Jan 1 1970 00:00H, UTC.
x4a x00 x00 x00 xd0 x4b x92 x84 xb8 # 09:51:31 May 8, 1998 UTC
x4b x4b x92 x0b xa0 # 09:51:00 May 8, 1998 UTC
double算法
double ::= D b7 b6 b5 b4 b3 b2 b1 b0
::= x5b
::= x5c
::= x5d b0
::= x5e b1 b0
::= x5f b3 b2 b1 b0
可以用x5b代替double的0.0
可以用x5c代替double的1.0
double 介于-128到127之间的无符号的可以用两个byte value来替代。
value = (double)b0
double 介于-32768和32767之间无符号的double，可以用三个八位字节来替代。
value = (double) (256 * b1 + b0)
32位浮点数可以转换成4位8字节二进制数
x5b # 0.0
x5c # 1.0
x5d x00 # 0.0
x5d x80 # -128.0
x5d x7f # 127.0
x5e x00 x00 # 0.0
x5e x80 x00 # -32768.0
x5e x7f xff # 32767.0
D x40 x28 x80 x00 x00 x00 x00 x00 # 12.25
int ::= 'I' b3 b2 b1 b0
::= [x80-xbf]
::= [xc0-xcf] b0
::= [xd0-xd7] b1 b0
一个32bit有符号整数，一个整数以'I'开头，后面跟着4个八个字节.
value = (b3 << 24) + (b2 << 16) + (b1 << 8) + b0;
数字介于-16至47之间的可以被编码成一个单独在x80到xbf之间。
value = code - 0x90
数字介于 -2048至2047，可以被编码成，两个八字节字符，规则是：
value = ((code - 0xc8) << 8) + b0;
Integers between -262144 and 262143 can be encoded in three bytes with the leading byte in the range xd0 to xd7.
value = ((code - 0xd4) << 16) + (b1 << 8) + b0;
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 ::= x55 type value* 'Z' # variable-length list
::= 'V' type int value* # fixed-length list
::= x57 value* 'Z' # variable-length untyped list
::= x58 int value* # fixed-length untyped list
::= [x70-77] type value* # fixed-length typed list
::= [x78-7f] value* # fixed-length untyped list
一个整齐的list，例如array。这两个list提供一个固定长度和可编长度的list，两个list都有一个类型，这个类型的String必须是一个可以被UTF-8支持的。
每个列表项都添加到引用列表中，以处理共享和循环元素。参见REF元素。
任何希望列表的解析器也必须接受null或共享引用。
类型的有效值没有在本文档中指定，并可能取决于特定的应用程序。例如，在静态类型的语言中实现的一个服务器，它公开了一个Hessian接口，它可以使用类型信息实例化特定的数组类型。另一方面，服务器用动态类型的语言可能会忽视型完全的内容并创建一个通用阵列。
Hesssian 2.0 允许一个紧凑的形式列表的连续列表相同的类型，其中的长度是事先已知的。类型和长度由整数编码，其中类型是对较早指定类型的引用。
序列化一个int类型的数组，int[] = {0, 1}
V # fixed length, typed list
x04 [int # encoding of int[] type
x92 # length = 2
x90 # integer 0
x91 # integer 1
没有类型长度可变的列表 list={0,1}
x57 # variable-length, untyped
x90 # integer 0
x91 # integer 1
Z
定长类型
x72 # typed list length=2
x04 [int # type for int[] (save as type #0)
x90 # integer 0
x91 # integer 1
x73 # typed list length = 3
x90 # type reference to int[] (integer #0)
x92 # integer 2
x93 # integer 3
x94 # integer 4
long 语法
long ::= L b7 b6 b5 b4 b3 b2 b1 b0
::= [xd8-xef]
::= [xf0-xff] b0
::= [x38-x3f] b1 b0
::= x4c b3 b2 b1 b0
64位有符号整数。一个长的字节x4c代表（L）随后在后面跟着八个比特。
long在-8至15是被一个八位比特替代的，在范围xd8至xef。
value = (code - 0xe0)
long在-2048值2047之间，使用两位byte保存，在范围xf0至xff value = ((code - 0xf8) << 8 ) + b0
三位八比特能表示的数，范围在-262144至262143 value = ((code - 0x3c) << 16) + (b1 << 8) + b0
long能用32bite表示的数
value = (b3 << 24) + (b2 << 16) + (b1 << 8) + b0
xe0 # 0
xd8 # -8
xef # 15
xf8 x00 # 0
xf0 x00 # -2048
xf7 x00 # -256
xff xff # 2047
x3c x00 x00 # 0
x38 x00 x00 # -262144
x3f xff xff # 262143
x4c x00 x00 x00 x00 # 0
x4c x00 x00 x01 x2c # 300
L x00 x00 x00 x00 x00 x00 x01 x2c # 300
Map语法
map ::= M type (value value)* Z
表示序列化的映射，并表示对象。类型元素描述映射的类型。
这个类型可能为空，一个长度为0，程序解释器会自动选择一个类型，如果一个值是没有类型的，对于对象，一个未确认的key将会被忽略。
每一个映射被添加到参考列表中，一些时间，语法解析程序期望一个映射，它必须支持空或者引用,这个类型被服务器选择。
map = new HashMap();
map.put(new Integer(1), "fee");
map.put(new Integer(16), "fie");
map.put(new Integer(256), "foe");
---
H # untyped map (HashMap for Java)
x91 # 1
x03 fee # "fee"
xa0 # 16
x03 fie # "fie"
xc9 x00 # 256
x03 foe # "foe"
Z
集合表示一个java对象
public class Car implements Serializable {
String color = "aquamarine";
String model = "Beetle";
int mileage = 65536;
}
---
M
x13 com.caucho.test.Car # type
x05 color # color field
x0a aquamarine
x05 model # model field
x06 Beetle
x07 mileage # mileage field
I x00 x01 x00 x00
Z
null语法
null代表一个空指针 'N'代表空的值
object 语法
class-def ::= 'C' string int string*
object ::= 'O' int value*
::= [x60-x6f] value*
Hessian2.0有一个紧凑的对象,字段只会序列化一次，以下对象只会序列化它们的值。
对象定义包括强制类型字符串、字段数和字段名。对象定义存储在对象定义映射中，并且将由具有整数引用的对象实例引用。
Hessian2.0有一个紧凑的对象,字段只会序列化一次，以下对象只会序列化它们的值。
对象实例化根据前面的定义创建一个新对象。整数值是指对象定义。
对象序列化
class Car {
String color;
String model;
}
out.writeObject(new Car("red", "corvette"));
out.writeObject(new Car("green", "civic"));
---
C # object definition (#0)
x0b example.Car # type is example.Car
x92 # two fields
x05 color # color field name
x05 model # model field name
O # object def (long form)
x90 # object definition #0
x03 red # color field value
x08 corvette # model field value
x60 # object def #0 (short form)
x05 green # color field value
x05 civic # model field value
enum Color {
RED,
GREEN,
BLUE,
}
out.writeObject(Color.RED);
out.writeObject(Color.GREEN);
out.writeObject(Color.BLUE);
out.writeObject(Color.GREEN);
---
C # class definition #0
x0b example.Color # type is example.Color
x91 # one field
x04 name # enumeration field is "name"
x60 # object #0 (class def #0)
x03 RED # RED value
x60 # object #1 (class def #0)
x90 # object definition ref #0
x05 GREEN # GREEN value
x60 # object #2 (class def #0)
x04 BLUE # BLUE value
x51 x91 # object ref #1, i.e. Color.GREEN
Ref 语法
ref ::= x51 int
指上一个列表、映射或对象实例的整数。当每个列表、映射或对象从输入流中读取时，它被分配到流中的整数位置，即第一个列表或映射是“0”，下一个是“1”，等等，后面的引用可以使用前面的对象。作者可以生成参考文献。解析器必须能够识别它们。
REF可以引用不完全读项。例如，在整个列表被读取之前，循环链表将引用第一个链接。
一个可能的实现是将每个映射、列表和对象添加到数组中，因为它是被读取的。REF将从数组返回相应的值。为了支持循环结构，在填充内容之前，实现将立即存储映射、列表或对象。
每个映射或列表在解析时存储在数组中。REF选择一个存储的对象。第一个对象编号为“0”。
list = new LinkedList();
list.data = 1;
list.tail = list;
---
C
x0a LinkedList
x92
x04 head
x04 tail
o x90 # object stores ref #0
x91 # data = 1
x51 x90 # next field refers to itself, i.e. ref #0
ref仅涉及到list，map和object。
string 语法
string ::= x52 b1 b0 <utf8-data> string
::= S b1 b0 <utf8-data>
::= [x00-x1f] <utf8-data>
::= [x30-x33] b0 <utf8-data>
一个16比特，利用utf-8的双字节编码，字符串会按块编码，非最后一块会用'R'来表示，最后一块会用'S'来表示，每一块都有一个16比特无符号整型长度的bytes。
16比特字符的长度，可能与字节的个数不相同。
字符串可能不能成对拆分。
长度小于32的字符串可能使用单字节编码。
value = code;
x00 # "", empty string
x05 hello # "hello"
x01 xc3 x83 # "\u00c3"
S x00 x05 hello # "hello" in long form
x52 x00 x07 hello, # "hello, world" split into two chunks
x05 world
type 语法
type ::= string
::= int
一个map或者list包含的属性，这个属性的属性名将会被标示，用在面向对象的语言中。每一个类型都会被添加到type map中，给未来提供一个参考。
重复类型的String的key，将会用type map来查询先前用过的类型，在解析过程中，这个类型应该是不依赖于任何类型的。
x00 - x1f # utf-8 string length 0-32
x20 - x2f # binary data length 0-16
x30 - x33 # utf-8 string length 0-1023
x34 - x37 # binary data length 0-1023
x38 - x3f # three-octet compact long (-x40000 to x3ffff)
x40 # reserved (expansion/escape)
x41 # 8-bit binary data non-final chunk ('A')
x42 # 8-bit binary data final chunk ('B')
x43 # object type definition ('C')
x44 # 64-bit IEEE encoded double ('D')
x45 # reserved
x46 # boolean false ('F')
x47 # reserved
x48 # untyped map ('H')
x49 # 32-bit signed integer ('I')
x4a # 64-bit UTC millisecond date
x4b # 32-bit UTC minute date
x4c # 64-bit signed long integer ('L')
x4d # map with type ('M')
x4e # null ('N')
x4f # object instance ('O')
x50 # reserved
x51 # reference to map/list/object - integer ('Q')
x52 # utf-8 string non-final chunk ('R')
x53 # utf-8 string final chunk ('S')
x54 # boolean true ('T')
x55 # variable-length list/vector ('U')
x56 # fixed-length list/vector ('V')
x57 # variable-length untyped list/vector ('W')
x58 # fixed-length untyped list/vector ('X')
x59 # long encoded as 32-bit int ('Y')
x5a # list/map terminator ('Z')
x5b # double 0.0
x5c # double 1.0
x5d # double represented as byte (-128.0 to 127.0)
x5e # double represented as short (-32768.0 to 327676.0)
x5f # double represented as float
x60 - x6f # object with direct type
x70 - x77 # fixed list with direct length
x78 - x7f # fixed untyped list with direct length
x80 - xbf # one-octet compact int (-x10 to x3f, x90 is 0)
xc0 - xcf # two-octet compact int (-x800 to x7ff)
xd0 - xd7 # three-octet compact int (-x40000 to x3ffff)
xd8 - xef # one-octet compact long (-x8 to xf, xe0 is 0)
xf0 - xff # two-octet compact long (-x800 to x7ff, xf8 is 0)