Go语言中利用接口实现Map存储异构数据

package main

import (
    "fmt"
)

// 假设我们有不同类型的控制器
type IndexController struct {
    Name string
}

func (ic IndexController) HandleRequest() string {
    return fmt.Sprintf("IndexController %s handled request.", ic.Name)
}

type UserController struct {
    ID int
}

func (uc UserController) HandleRequest() string {
    return fmt.Sprintf("UserController %d handled request.", uc.ID)
}

// 模拟一个返回IndexController实例的构造函数
func NewIndexController() IndexController {
    return IndexController{Name: "DefaultIndex"}
}

// 模拟一个返回UserController实例的构造函数
func NewUserController() UserController {
    return UserController{ID: 123}
}

func main() {
    // 声明一个键为string，值为interface{}的map
    objects := make(map[string]interface{})

    // 存储不同类型的对象
    objects["IndexController"] = NewIndexController()
    objects["UserController"] = NewUserController()
    objects["ConfigValue"] = "some_config_string" // 也可以存储基本类型
    objects["Port"] = 8080                        // 也可以存储整数

    fmt.Println("存储的异构对象：", objects)

    // 遍历并尝试访问对象
    for key, value := range objects {
        fmt.Printf("键: %s, 值类型: %T, 值: %v\n", key, value, value)
    }

    // 检索和类型断言
    // 当从map中取出interface{}类型的值时，如果需要使用其原始的具体类型的方法或字段，
    // 就需要进行类型断言。
    if indexCtrl, ok := objects["IndexController"].(IndexController); ok {
        fmt.Println("成功断言为IndexController:", indexCtrl.HandleRequest())
    } else {
        fmt.Println("无法断言为IndexController")
    }

    if userCtrl, ok := objects["UserController"].(UserController); ok {
        fmt.Println("成功断言为UserController:", userCtrl.HandleRequest())
    } else {
        fmt.Println("无法断言为UserController")
    }

    // 尝试对不存在的键或错误类型进行断言
    if nonExistent, ok := objects["NonExistentKey"].(string); ok {
        fmt.Println("成功断言为string (但键不存在):", nonExistent)
    } else {
        fmt.Println("无法断言为string 或 键不存在")
    }

    if wrongType, ok := objects["ConfigValue"].(int); ok {
        fmt.Println("成功断言为int (但类型错误):", wrongType)
    } else {
        fmt.Println("无法断言为int (类型不匹配)")
    }
}

package main

import "fmt"

// 定义一个Controller接口
type Controller interface {
    HandleRequest() string
}

// IndexController 类型，隐式实现了 Controller 接口
type IndexController struct {
    Name string
}

func (ic IndexController) HandleRequest() string {
    return fmt.Sprintf("IndexController %s handled request.", ic.Name)
}

// UserController 类型，隐式实现了 Controller 接口
type UserController struct {
    ID int
}

func (uc UserController) HandleRequest() string {
    return fmt.Sprintf("UserController %d handled request.", uc.ID)
}

// 模拟构造函数
func NewIndexController() IndexController {
    return IndexController{Name: "DefaultIndex"}
}

func NewUserController() UserController {
    return UserController{ID: 123}
}

func main() {
    // 声明一个键为string，值为Controller接口的map
    controllers := make(map[string]Controller)

    // 存储实现了Controller接口的实例
    controllers["IndexController"] = NewIndexController()
    controllers["UserController"] = NewUserController()

    // 现在可以直接调用 HandleRequest 方法，无需类型断言
    fmt.Println(controllers["IndexController"].HandleRequest())
    fmt.Println(controllers["UserController"].HandleRequest())

    // 尝试存储未实现Controller接口的类型会引发编译错误
    // controllers["ConfigValue"] = "some_config_string" // 编译错误
}