Go语言中通过接口实现结构体方法复用与通用管理

// Task 代表一个任务
type Task struct {
    ID    int64  // 唯一标识符
    Title string // 描述
    Done  bool   // 任务是否完成
}

// TaskManager 管理内存中的任务列表
type TaskManager struct {
    tasks  []*Task
    lastID int64
}

package main

import "fmt"

// Manager 接口定义了通用数据管理操作
type Manager interface {
    Save(item interface{}) error
    All() ([]interface{}, error)
    // 根据需求，可以添加 Find(id int64) (interface{}, error) 等方法
}

// TaskManager 的具体实现
type TaskManager struct {
    tasks  []*Task
    lastID int64
}

// NewTaskManager 创建并返回一个新的 TaskManager 实例
func NewTaskManager() *TaskManager {
    return &TaskManager{
        tasks:  make([]*Task, 0),
        lastID: 0,
    }
}

// Save 方法实现了 Manager 接口的 Save 方法
func (m *TaskManager) Save(item interface{}) error {
    task, ok := item.(*Task) // 类型断言：将 interface{} 转换为 *Task
    if !ok {
        return fmt.Errorf("invalid item type: expected *Task, got %T", item)
    }

    if task.ID == 0 {
        m.lastID++
        task.ID = m.lastID
    } else {
        // 如果 ID 存在，可以考虑更新现有任务
        // 这里简化处理，直接添加到列表中，实际应用中可能需要查找并替换
        for i, t := range m.tasks {
            if t.ID == task.ID {
                m.tasks[i] = task
                return nil
            }
        }
    }
    m.tasks = append(m.tasks, task)
    return nil
}

// All 方法实现了 Manager 接口的 All 方法
func (m *TaskManager) All() ([]interface{}, error) {
    result := make([]interface{}, len(m.tasks))
    for i, task := range m.tasks {
        result[i] = task
    }
    return result, nil
}

func main() {
    taskMgr := NewTaskManager()

    // 保存一个新任务
    task1 := &Task{Title: "学习 Go 接口"}
    err := taskMgr.Save(task1)
    if err != nil {
        fmt.Println("Error saving task1:", err)
    }
    fmt.Printf("Saved task1: %+v\n", task1)

    // 保存另一个任务
    task2 := &Task{Title: "完成教程文章"}
    err = taskMgr.Save(task2)
    if err != nil {
        fmt.Println("Error saving task2:", err)
    }
    fmt.Printf("Saved task2: %+v\n", task2)

    // 获取所有任务
    items, err := taskMgr.All()
    if err != nil {
        fmt.Println("Error getting all tasks:", err)
    }
    fmt.Println("\nAll tasks:")
    for _, item := range items {
        if t, ok := item.(*Task); ok {
            fmt.Printf("- ID: %d, Title: %s, Done: %t\n", t.ID, t.Title, t.Done)
        }
    }

    // 尝试保存一个非 Task 类型 (会报错)
    type User struct {
        ID   int64
        Name string
    }
    user1 := &User{Name: "Alice"}
    err = taskMgr.Save(user1)
    if err != nil {
        fmt.Println("\nAttempt to save User (expected error):", err)
    }
}

// Entry 接口定义了具有唯一标识符的数据项
type Entry interface {
    GetID() int64
    SetID(id int64)
    // 可以根据需要添加其他通用方法，例如 GetTitle() string
}

// Task 实现 Entry 接口
func (t *Task) GetID() int64 {
    return t.ID
}

func (t *Task) SetID(id int64) {
    t.ID = id
}

// TaskManager 的 Save 方法现在接受 Entry 接口
func (m *TaskManager) SaveEntry(e Entry) error { // 命名为 SaveEntry 以区分
    task, ok := e.(*Task) // 仍然需要类型断言，因为 m.tasks 存储的是 *Task
    if !ok {
        return fmt.Errorf("invalid entry type: expected *Task, got %T", e)
    }

    if e.GetID() == 0 {
        m.lastID++
        e.SetID(m.lastID)
    } else {
        for i, t := range m.tasks {
            if t.ID == e.GetID() {
                m.tasks[i] = task // 更新现有任务
                return nil
            }
        }
    }
    m.tasks = append(m.tasks, task)
    return nil
}

// 如果希望 All 方法也返回 Entry 接口，则 TaskManager 需要存储 []Entry
// 例如：
/*
type GenericManager struct {
    entries []Entry
    lastID int64
}

func (gm *GenericManager) Save(e Entry) error {
    if e.GetID() == 0 {
        gm.lastID++
        e.SetID(gm.lastID)
    }
    // 实际存储逻辑，可能需要复制或处理
    gm.entries = append(gm.entries, e)
    return nil
}

func (gm *GenericManager) All() ([]Entry, error) {
    return gm.entries, nil
}
*/