hessian-serialization

http://hessian.caucho.com/doc/hessian-serialization.html

1. Introduction
2. Design Goals
3. Hessian Grammar
4. Serialization
    4.1. binary data
        4.1.1. Compact: short binary
        4.1.2. Binary Examples
    4.2. boolean
        4.2.1. Boolean Examples
    4.3. date
        4.3.1. Compact: date in minutes
        4.3.2. Date Examples
    4.4. double
        4.4.1. Compact: double zero
        4.4.2. Compact: double one
        4.4.3. Compact: double octet
        4.4.4. Compact: double short
        4.4.5. Compact: double float
        4.4.6. Double Examples
    4.5. int
        4.5.1. Compact: single octet integers
        4.5.2. Compact: two octet integers
        4.5.3. Compact: three octet integers
        4.5.4. Integer Examples
    4.6. list
        4.6.1. Compact: fixed length list
        4.6.2. List examples
    4.7. long
        4.7.1. Compact: single octet longs
        4.7.2. Compact: two octet longs
        4.7.3. Compact: three octet longs
        4.7.4. Compact: four octet longs
        4.7.5. Long Examples
    4.8. map
        4.8.1. Map examples
    4.9. null
    4.10. object
        4.10.1. Compact: class definition
        4.10.2. Compact: object instantiation
        4.10.3. Object examples
    4.11. ref
        4.11.1. Ref Examples
    4.12. string
        4.12.1. Compact: short strings
        4.12.2. String Examples
    4.13. type
    4.14. Compact: type references
5. Reference Maps
    5.1. value reference
    5.2. class reference
    5.3. type reference
6. Bytecode map
§ Authors' Addresses
§ Intellectual Property and Copyright Statements

TOC

1. Introduction

Hessian is a dynamically-typed, binary serialization and Web Services protocol designed for object-oriented transmission.

TOC

2. Design Goals

Hessian is dynamically-typed, compact, and portable across languages.

The Hessian protocol has the following design goals:

It must self-describe the serialized types, i.e. not require external schema or interface definitions.
It must be language-independent, including supporting scripting languages.
It must be readable or writable in a single pass.
It must be as compact as possible.
It must be simple so it can be effectively tested and implemented.
It must be as fast as possible.
It must support Unicode strings.
It must support 8-bit binary data without escaping or using attachments.
It must support encryption, compression, signature, and transaction context envelopes.

TOC

3. Hessian Grammar

Serialization Grammar

           # 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

Figure 1

TOC

4. Serialization

Hessian's object serialization has 8 primitive types:

raw binary data
boolean
64-bit millisecond date
64-bit double
32-bit int
64-bit long
null
UTF8-encoded string

It has 3 recursive types:

list for lists and arrays
map for maps and dictionaries
object for objects

Finally, it has one special contruct:

ref for shared and circular object references.

Hessian 2.0 has 3 internal reference maps:

巴特西

hessian-serialization

Table of Contents

1. Introduction

2. Design Goals

3. Hessian Grammar

4. Serialization

最新文章

热门文章