《Go 简易速速上手小册》第4章：接口与抽象（2024 最新版）（下）

type Storage interface {
    Save(key string, value string) error
    Load(key string) (string, error)
}

// MemoryStorage 内存存储
type MemoryStorage struct {
    data map[string]string
}
func NewMemoryStorage() *MemoryStorage {
    return &MemoryStorage{data: make(map[string]string)}
}
func (m *MemoryStorage) Save(key string, value string) error {
    m.data[key] = value
    return nil
}
func (m *MemoryStorage) Load(key string) (string, error) {
    value, exists := m.data[key]
    if !exists {
        return "", fmt.Errorf("key not found")
    }
    return value, nil
}
// FileStorage 文件存储
type FileStorage struct {
    filePath string
}
func NewFileStorage(filePath string) *FileStorage {
    return &FileStorage{filePath: filePath}
}
func (f *FileStorage) Save(key string, value string) error {
    // 这里添加将数据保存到文件的逻辑
    return nil
}
func (f *FileStorage) Load(key string) (string, error) {
    // 这里添加从文件加载数据的逻辑
    return "", nil
}

func UseStorage(s Storage) {
    // 保存数据
    s.Save("username", "john_doe")
    // 加载数据
    value, err := s.Load("username")
    if err != nil {
        fmt.Println("Error loading data:", err)
        return
    }
    fmt.Println("Loaded value:", value)
}
func main() {
    memoryStorage := NewMemoryStorage()
    UseStorage(memoryStorage)
    fileStorage := NewFileStorage("data.txt")
    UseStorage(fileStorage)
    // 假设还有一个数据库存储，也可以以相同的方式使用
}

var anything interface{}
anything = "Go is awesome"
anything = 42
anything = []int{1, 2, 3}

str, ok := anything.(string)
if ok {
    fmt.Println(str)
} else {
    fmt.Println("Value is not a string")
}

// LoadConfig 从不同的来源加载配置
func LoadConfig(source string) interface{} {
    // 假设这里从不同的来源加载配置
    switch source {
    case "File":
        // 从文件加载配置，返回一个假设的结构
        return map[string]interface{}{"timeout": 30, "debug": true}
    case "Env":
        // 从环境变量加载配置，返回一个简单的字符串
        return "production"
    case "Remote":
        // 从远程服务加载配置，返回一个假设的复杂数组
        return []interface{}{200, "OK", []string{"server1", "server2"}}
    default:
        return nil
    }
}

// ProcessConfig 根据配置数据的类型进行处理
func ProcessConfig(config interface{}) {
    switch v := config.(type) {
    case map[string]interface{}:
        fmt.Println("处理来自文件的配置数据:", v)
    case string:
        fmt.Println("处理来自环境变量的配置数据:", v)
    case []interface{}:
        fmt.Println("处理来自远程服务的配置数据:", v)
    default:
        fmt.Println("未知配置类型")
    }
}

func main() {
    // 从文件加载配置
    fileConfig := LoadConfig("File")
    ProcessConfig(fileConfig)
    // 从环境变量加载配置
    envConfig := LoadConfig("Env")
    ProcessConfig(envConfig)
    // 从远程服务加载配置
    remoteConfig := LoadConfig("Remote")
    ProcessConfig(remoteConfig)
}

package main
import (
    "fmt"
)
// processData 根据不同的数据类型执行相应的处理逻辑
func processData(data interface{}) {
    switch v := data.(type) {
    case string:
        fmt.Printf("字符串处理: %s\n", v)
    case int:
        fmt.Printf("整数处理: %d\n", v)
    case float64:
        fmt.Printf("浮点数处理: %f\n", v)
    case bool:
        fmt.Printf("布尔值处理: %t\n", v)
    default:
        fmt.Printf("未知类型: %v\n", v)
    }
}
// 自定义类型示例
type CustomData struct {
    Description string
}
// 处理自定义类型的数据
func processCustomData(data CustomData) {
    fmt.Printf("处理自定义数据类型: %s\n", data.Description)
}
func main() {
    processData("Go is awesome!")
    processData(42)
    processData(3.14)
    processData(true)
    processData(CustomData{"自定义类型数据"})
    // 尝试直接使用类型断言处理自定义类型
    var data interface{} = CustomData{"直接处理自定义类型数据"}
    if customData, ok := data.(CustomData); ok {
        processCustomData(customData)
    }
}

package main
import (
    "fmt"
)
// LoginEvent 登录事件
type LoginEvent struct {
    Username string
}
// LogoutEvent 登出事件
type LogoutEvent struct {
    Username string
}
// ErrorEvent 错误事件
type ErrorEvent struct {
    ErrorMsg string
}

// EventDispatcher 事件分发器
type EventDispatcher struct{}
func (ed *EventDispatcher) Dispatch(event interface{}) {
    switch e := event.(type) {
    case LoginEvent:
        fmt.Printf("用户登录: %s\n", e.Username)
    case LogoutEvent:
        fmt.Printf("用户登出: %s\n", e.Username)
    case ErrorEvent:
        fmt.Printf("错误发生: %s\n", e.ErrorMsg)
    default:
        fmt.Println("未知事件")
    }
}

func main() {
    dispatcher := EventDispatcher{}
    // 创建并分发登录事件
    loginEvent := LoginEvent{Username: "john_doe"}
    dispatcher.Dispatch(loginEvent)
    // 创建并分发登出事件
    logoutEvent := LogoutEvent{Username: "john_doe"}
    dispatcher.Dispatch(logoutEvent)
    // 创建并分发错误事件
    errorEvent := ErrorEvent{ErrorMsg: "无法连接到服务器"}
    dispatcher.Dispatch(errorEvent)
}