Add: support skip unregistered pojo

decode.go

@@ -232,5 +232,8 @@ func (t *TypeRefs) appendTypeRefs(name string, p reflect.Type) {
 }
 
 func (t *TypeRefs) Get(index int) reflect.Type {
+	if len(t.typeRefs) <= index {
+		return nil
+	}
 	return t.typeRefs[index]
 }

hessian.go

@@ -32,6 +32,7 @@ const (
 	PackageHeartbeat          = PackageType(0x08)
 	PackageRequest_TwoWay     = PackageType(0x10)
 	PackageResponse_Exception = PackageType(0x20)
+	PackageType_BitSize       = 0x2f
 )
 
 // PackageType ...
@@ -173,7 +174,7 @@ func (h *HessianCodec) ReadBody(rspObj interface{}) error {
 		return perrors.WithStack(err)
 	}
 
-	switch h.pkgType & 0x2f {
+	switch h.pkgType & PackageType_BitSize {
 	case PackageResponse | PackageHeartbeat | PackageResponse_Exception, PackageResponse | PackageResponse_Exception:
 		decoder := NewDecoder(buf[:])
 		exception, err := decoder.Decode()
@@ -203,3 +204,35 @@ func (h *HessianCodec) ReadBody(rspObj interface{}) error {
 
 	return nil
 }
+
+// ignore body, but only read attachments
+func (h *HessianCodec) ReadAttachments() (map[string]string, error) {
+	if h.reader.Buffered() < h.bodyLen {
+		return nil, ErrBodyNotEnough
+	}
+	buf, err := h.reader.Peek(h.bodyLen)
+	if err != nil {
+		return nil, perrors.WithStack(err)
+	}
+	_, err = h.reader.Discard(h.bodyLen)
+	if err != nil { // this is impossible
+		return nil, perrors.WithStack(err)
+	}
+
+	switch h.pkgType & PackageType_BitSize {
+	case PackageRequest:
+		rspObj := make([]interface{}, 7)
+		if err = unpackRequestBody(buf, rspObj); err != nil {
+			return nil, perrors.WithStack(err)
+		}
+		return rspObj[6].(map[string]string), nil
+	case PackageResponse:
+		rspObj := &Response{}
+		if err = unpackResponseBody(buf, rspObj); err != nil {
+			return nil, perrors.WithStack(err)
+		}
+		return rspObj.Attachments, nil
+	}
+
+	return nil, nil
+}

object.go

@@ -478,7 +478,8 @@ func (d *Decoder) getStructDefByIndex(idx int) (reflect.Type, classInfo, error)
 	cls = d.classInfoList[idx]
 	s, ok = getStructInfo(cls.javaName)
 	if !ok {
-		return nil, cls, perrors.Errorf("can not find go type name %s in registry", cls.javaName)
+		return nil, cls, nil
+		//return nil, cls, perrors.Errorf("can not find go type name %s in registry", cls.javaName)
 	}
 
 	return s.typ, cls, nil
@@ -506,6 +507,15 @@ func (d *Decoder) decEnum(javaName string, flag int32) (JavaEnum, error) {
 	return enumValue, nil
 }
 
+// skip this object
+func (d *Decoder) skip(cls classInfo) error {
+	if len(cls.fieldNameList) < 1 {
+		return nil
+	}
+	_, err := d.DecodeValue()
+	return err
+}
+
 func (d *Decoder) decObject(flag int32) (interface{}, error) {
 	var (
 		tag byte
@@ -549,6 +559,9 @@ func (d *Decoder) decObject(flag int32) (interface{}, error) {
 		if err != nil {
 			return nil, err
 		}
+		if typ == nil {
+			return nil, d.skip(cls)
+		}
 		if typ.Implements(javaEnumType) {
 			return d.decEnum(cls.javaName, TAG_READ)
 		}
@@ -560,6 +573,9 @@ func (d *Decoder) decObject(flag int32) (interface{}, error) {
 		if err != nil {
 			return nil, err
 		}
+		if typ == nil {
+			return nil, d.skip(cls)
+		}
 		if typ.Implements(javaEnumType) {
 			return d.decEnum(cls.javaName, TAG_READ)
 		}

object_test.go

@@ -525,3 +525,28 @@ func doTestBasePointer(t *testing.T, base *BasePointer, expected *BasePointer) {
 		t.Errorf("expect: %v, but get: %v", base, decObj)
 	}
 }
+
+func TestSkip(t *testing.T) {
+	testDecodeFramework(t, "replyObject_0", nil)
+	testDecodeFramework(t, "replyObject_1", nil)
+	testDecodeFramework(t, "replyObject_16", make([]interface{}, 17))
+	testDecodeFramework(t, "replyObject_2a", make([]interface{}, 2))
+	testDecodeFramework(t, "replyObject_3", nil)
+
+	testDecodeFramework(t, "replyTypedMap_0", make(map[interface{}]interface{}))
+
+	testDecodeFramework(t, "replyTypedFixedList_0", make([]string, 0))
+	testDecodeFramework(t, "replyUntypedFixedList_0", []interface{}{})
+
+	testDecodeFramework(t, "customReplyTypedFixedListHasNull", make([]Object, 3))
+	testDecodeFramework(t, "customReplyTypedVariableListHasNull", make([]Object, 3))
+	testDecodeFramework(t, "customReplyUntypedFixedListHasNull", make([]interface{}, 3))
+	testDecodeFramework(t, "customReplyUntypedVariableListHasNull", make([]interface{}, 3))
+
+	testDecodeFramework(t, "customReplyTypedFixedList_A0", make([]interface{}, 3))
+	testDecodeFramework(t, "customReplyTypedVariableList_A0", make([]interface{}, 3))
+
+	testDecodeFramework(t, "customReplyTypedFixedList_Test", nil)
+
+	testDecodeFramework(t, "customReplyTypedFixedList_Object", make([]Object, 1))
+}

ref.go

@@ -165,7 +165,8 @@ func (d *Decoder) decRef(flag int32) (interface{}, error) {
 		}
 
 		if len(d.refs) <= int(i) {
-			return nil, ErrIllegalRefIndex
+			return nil, nil
+			//return nil, ErrIllegalRefIndex
 		}
 		// return the exact ref object, which maybe a _refHolder
 		return d.refs[i], nil