使用json.RawMessage捕获对象的变化部分。使用应用程序逻辑中确定的类型对原始消息进行解码。

func (m *MyObj) UnmarshalJSON(data []byte) error {

    // Declare new type with same fields as MyObj, but
    // but no methods. This type is used to avoid
    // recursion when unmarshaling a value of type 
    // Y declared below.
    type X MyObj

    // Declare a type to capture field_n as a raw message
    // and all other fields as normal.  The FieldN in 
    // MyObj is shadowed by the FieldN here.
    type Y struct {
        *X
        FieldN json.RawMessage `json:"field_n"`
    }

    // Unmarshal field_n to the raw message and all other fields
    // to m.
    y := Y{X: (*X)(m)}
    err := json.Unmarshal(data, &y)
    if err != nil {
        return err
    }

    // We now have field_n as a json.RawMessage in y.FieldN.
    // We can use whatever logic we want to determine the
    // concrete type, create a value of that type, and unmarshal
    // to that value.
    //
    // Here, I assume that field_1 specifies the concrete type.
    switch m.Field1 {
    case "type1":
        m.FieldN = &MyType1{}
    case "type2":
        m.FieldN = &MyType2{}
    default:
        return errors.New("unknown field 1")
    }

    return json.Unmarshal(y.FieldN, m.FieldN)

}

https://go.dev/play/p/hV3Lgn1RkBz

此演示基于@mkopriva的建议（DisallowUnknownFields），但仍然使用"try one; if failed, try another"过程。

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
)

type MyObj struct {
    Field1 string      `json:"field_1"`
    FieldN MyInterface `json:"field_n"`
}

type MyInterface interface{}

type MyType1 struct {
    FF1 string `json:"ff1"`
}

type MyType2 struct {
    FF2 string `json:"ff2"`
}

func (m *MyObj) UnmarshalJSON(data []byte) error {
    // We can not use MyObj directly. If we do this, the json decoder will
    // call this func, and result in a stack overflow panic. replace
    // "type MyObj1 MyObj" with "type MyObj1 = MyObj" and you will see the error.
    type MyObj1 MyObj
    out := MyObj1{FieldN: &MyType1{}}

    dec := json.NewDecoder(bytes.NewReader(data))
    dec.DisallowUnknownFields()

    if err := dec.Decode(&out); err == nil {
        *m = MyObj(out)
        return nil
    }

    out.FieldN = &MyType2{}
    dec = json.NewDecoder(bytes.NewReader(data))
    dec.DisallowUnknownFields()
    if err := dec.Decode(&out); err == nil {
        *m = MyObj(out)
        return nil
    } else {
        return err
    }
}

func main() {
    test(`{"field_1":"field1","field_n":{"ff1":"abc"}}`)
    test(`{"field_1":"field1","field_n":{"ff2":"abc"}}`)
}

func test(input string) {
    var obj MyObj

    if err := json.Unmarshal([]byte(input), &obj); err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("%#v, %#v\n", obj, obj.FieldN)
    }
}

输出：

main.MyObj{Field1:"field1", FieldN:(*main.MyType1)(0xc00009e270)}, &main.MyType1{FF1:"abc"}
main.MyObj{Field1:"field1", FieldN:(*main.MyType2)(0xc00009e3a0)}, &main.MyType2{FF2:"abc"}