README
¶
This is a feature-complete golang hessian serializer.
It's cloned from viant/gohessian , and do the following works:
- fix lots of bugs
- large scope refactoring to let code structure simple and human-friendly
- add ref and date features implement
- more unit tests
- api refactoring
Usage
name map and type map
name map: amap[string]stringused byencoderto determine the class name of a objecttype map: amap[string]reflect.Typeused bydecoderto determine the type of instance to initialize
You can use function hessian.ExtractTypeNameMap(interface{}) to generate both the type map and name map.
It's the recommendation way.
Of course, you can create by yourself, but make sure them contain all names and types which encoder and decoder needed.
simple example
type circular struct {
Num int
Previous *circular
Next *circular
}
func main() {
c := &circular{}
c.Num = 12345
c.Previous = c
c.Next = c
// create hessian serializer
serializer := hessian.NewSerializer(hessian.ExtractTypeNameMap(c))
fmt.Println("source object: ", c)
// encode to bytes
bytes, err := serializer.ToBytes(c)
if err != nil {
panic(err)
}
// decode from bytes
decoded, err := serializer.ToObject(bytes)
if err != nil {
panic(err)
}
fmt.Println("decode object: ", decoded)
}
using java class name
You can define a function HessianCodecName() string for your struct if using hessian.ExtractTypeNameMap(interface{}) to generate type map and name map.
type TraceVo struct {
Key string
Value string
}
func (TraceVo) HessianCodecName() string {
return "hessian.TraceVo"
}
typeMap,nameMap := hessian.ExtractTypeNameMap(&TraceVo{})
If you create type map and name map manually, you should also add the java class name mapping.
concurrently
hessian.NewSerializer contains serialization processing data, so a serializer can't be used concurrently, you should create a new one when needed.
If there is only one type of data to serialize , a goroutine can continue use the same serializer to ToBytes() or ToObject().
streaming transport
The following is a client-server streaming transport example:
server side:
_,nameMap := hessian.ExtractTypeNameMap(object)
encoder := hessian.NewEncoder(outputStreamWriter, nameMap) // write stream to outputStreamWriter
for {
data := getNewData()
err = encoder.Write(data) // write new data
if err != nil {
panic(err)
}
}
client side:
typeMap,_ := hessian.ExtractTypeNameMap(object)
decoder := hessian.NewDecoder(inputStreamReader, typeMap) // read stream from inputStreamReader
for {
obj,err := decoder.Read() // read new object
if err != nil {
panic(err)
}
// process obj
}
Reference
Documentation
¶
Index ¶
- Variables
- func AddrEqual(x, y interface{}) bool
- func ConvertSliceValueType(destTyp reflect.Type, v reflect.Value) (reflect.Value, error)
- func ElemKind(k reflect.Kind) bool
- func EnsureFloat64(i interface{}) float64
- func EnsureInt64(i interface{}) int64
- func EnsureInterface(in interface{}, err error) (interface{}, error)
- func EnsurePackValue(in interface{}) reflect.Value
- func EnsureRawValue(in interface{}) reflect.Value
- func EnsureUint64(i interface{}) uint64
- func ExtractTypeNameMap(v interface{}) (map[string]reflect.Type, map[string]string)
- func ExtractValue(v reflect.Value, extractor ValueExtractor)
- func FetchType(typ reflect.Type, typMap map[string]reflect.Type)
- func FloatKind(k reflect.Kind) bool
- func IntKind(k reflect.Kind) bool
- func IsRawKind(k reflect.Kind) bool
- func NameMapFrom(v interface{}) map[string]string
- func PackPtr(v reflect.Value) reflect.Value
- func RawValue(v reflect.Value) reflect.Value
- func SetLogger(l logger.Logger)
- func SetSlice(dest reflect.Value, objects interface{}) error
- func SetValue(dest, v reflect.Value)
- func ToBytes(object interface{}, nameMap map[string]string) ([]byte, error)
- func ToObject(ins []byte, typMap map[string]reflect.Type) (interface{}, error)
- func TypeMapFrom(v interface{}) map[string]reflect.Type
- func TypeMapOf(typ reflect.Type) map[string]reflect.Type
- func TypeName(t reflect.Type) string
- func UintKind(k reflect.Kind) bool
- func UnpackPtr(v reflect.Value) reflect.Value
- func UnpackPtrType(typ reflect.Type) reflect.Type
- func UnpackPtrValue(v reflect.Value) reflect.Value
- type ByteRuneReader
- type ClassDef
- type CodecErr
- type CodecNamable
- type Decoder
- func (d *Decoder) Decode() (interface{}, error)
- func (d *Decoder) ReadData() (interface{}, error)
- func (d *Decoder) ReadFrom(reader ByteRuneReader) (interface{}, error)
- func (d *Decoder) ReadLenTagObject(tag byte) (interface{}, error)
- func (d *Decoder) ReadList() (interface{}, error)
- func (d *Decoder) ReadObject() (interface{}, error)
- func (d *Decoder) RegisterType(key string, value reflect.Type)
- func (d *Decoder) RegisterTypeMap(mp map[string]reflect.Type)
- func (d *Decoder) RegisterVal(key string, val interface{})
- func (d *Decoder) Reset(r ByteRuneReader)
- func (d *Decoder) ToObject(bts []byte) (interface{}, error)
- type Encoder
- func (e *Encoder) RegisterNameMap(mp map[string]string)
- func (e *Encoder) RegisterNameType(key string, objectName string)
- func (e *Encoder) Reset(w io.Writer)
- func (e *Encoder) ToBytes(object interface{}) ([]byte, error)
- func (e *Encoder) WriteData(data interface{}) (int, error)
- func (e *Encoder) WriteObject(data interface{}) error
- func (e *Encoder) WriteTo(w io.Writer, data interface{}) error
- type Pool
- type Serializer
- type ValueExtractor
Constants ¶
This section is empty.
Variables ¶
var (
StringChunkSizeBytes = []byte{byte(strChunkSize >> 8), byte(strChunkSize)}
)
Functions ¶
func ConvertSliceValueType ¶
func EnsureInterface ¶
EnsureInterface get value of reflect.Value return original value if not reflect.Value
func EnsurePackValue ¶
EnsurePackValue pack the interface with value
func EnsureRawValue ¶
EnsureRawValue pack the interface with value, and make sure it's not a ref holder
func ExtractTypeNameMap ¶
ExtractTypeNameMap from reflect value
func RawValue ¶
RawValue unpack value to raw value. NOTE: it may be the zero value return value of pointer pointed if it's pointer
func SetValue ¶
SetValue set the value to dest. It will auto check the Ptr pack level and unpack/pack to the right level. It make sure success to set value
func UnpackPtrType ¶
UnpackPtrType unpack pointer type to original type
Types ¶
type ByteRuneReader ¶
type ByteRuneReader interface {
io.Reader
io.RuneReader
}
type CodecNamable ¶
type CodecNamable interface {
HessianCodecName() string
}
CodecNamable to define codec name for hessian
type Decoder ¶
type Decoder struct {
// contains filtered or unexported fields
}
Decoder type
func NewDecoder ¶
func NewDecoder(r ByteRuneReader, typ map[string]reflect.Type) *Decoder
NewDecoder new
func (*Decoder) ReadFrom ¶
func (d *Decoder) ReadFrom(reader ByteRuneReader) (interface{}, error)
ReadFrom read object from target reader
func (*Decoder) ReadLenTagObject ¶
ReadLenTagObject read length tag object
func (*Decoder) ReadObject ¶
ReadObject read new object from reader
func (*Decoder) RegisterType ¶
RegisterType register key/value type
func (*Decoder) RegisterTypeMap ¶
RegisterTypeMap register map
func (*Decoder) RegisterVal ¶
RegisterVal register from value
type Encoder ¶
type Encoder struct {
// contains filtered or unexported fields
}
Encoder type
func (*Encoder) RegisterNameMap ¶
RegisterNameMap register name map
func (*Encoder) RegisterNameType ¶
RegisterNameType register name type
func (*Encoder) WriteObject ¶
WriteObject write object
type Pool ¶
type Pool interface {
Get() interface{}
Return(interface{})
}
func NewDecoderPool ¶
NewDecoderPool new pool for decoder
func NewEncoderPool ¶
NewEncoderPool new pool for encoder
type Serializer ¶
type Serializer interface {
WriteTo(w io.Writer, object interface{}) error
Write(object interface{}) error
ToBytes(interface{}) ([]byte, error)
ReadFrom(reader ByteRuneReader) (interface{}, error)
Read() (interface{}, error)
ToObject([]byte) (interface{}, error)
}
Serializer a api composite of encoder and decoder
func NewSerializer ¶
NewSerializer init
type ValueExtractor ¶
ValueExtractor extract info from struct value return true to continue extracting process return false to return current extracting process
Source Files
Directories