Go语言中层级关系建模与数据持久化实践

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
    "io"
    "sync"
)

// NodeType 定义节点类型，例如存储区域、机架、货架、存储单元
type NodeType string

const (
    TypeStorageArea NodeType = "StorageArea"
    TypeRack        NodeType = "Rack"
    TypeShelf       NodeType = "Shelf"
    TypeBin         NodeType = "Bin"
)

// Node 表示层级结构中的一个通用节点
type Node struct {
    ID       string     // 唯一标识符
    Name     string     // 名称
    Type     NodeType   // 节点类型
    Children []*Node    // 子节点列表
    Parent   *Node      // 父节点引用 (可选，用于向上遍历)
    // 其他业务相关属性...
    mu sync.RWMutex // 用于并发访问的读写锁
}

// NewNode 创建一个新的节点
func NewNode(id, name string, nodeType NodeType) *Node {
    return &Node{
        ID:   id,
        Name: name,
        Type: nodeType,
    }
}

// AddChild 向当前节点添加一个子节点
func (n *Node) AddChild(child *Node) {
    n.mu.Lock()
    defer n.mu.Unlock()
    n.Children = append(n.Children, child)
    child.Parent = n // 设置父节点引用
}

// FindChildByID 查找指定ID的子节点（广度优先搜索）
func (n *Node) FindChildByID(id string) *Node {
    n.mu.RLock()
    defer n.mu.RUnlock()

    if n.ID == id {
        return n
    }

    queue := []*Node{n}
    for len(queue) > 0 {
        current := queue[0]
        queue = queue[1:]

        if current.ID == id {
            return current
        }

        for _, child := range current.Children {
            queue = append(queue, child)
        }
    }
    return nil
}

// TraverseFunc 定义遍历函数类型
type TraverseFunc func(node *Node)

// TraverseDFS 深度优先遍历
func (n *Node) TraverseDFS(f TraverseFunc) {
    n.mu.RLock()
    defer n.mu.RUnlock()
    f(n)
    for _, child := range n.Children {
        child.TraverseDFS(f)
    }
}

// TraverseBFS 广度优先遍历
func (n *Node) TraverseBFS(f TraverseFunc) {
    n.mu.RLock()
    defer n.mu.RUnlock()
    queue := []*Node{n}
    for len(queue) > 0 {
        current := queue[0]
        queue = queue[1:]
        f(current)
        for _, child := range current.Children {
            queue = append(queue, child)
        }
    }
}

func main() {
    // 构建一个示例树
    storageArea := NewNode("SA001", "主存储区", TypeStorageArea)
    rack1 := NewNode("R001", "机架A", TypeRack)
    rack2 := NewNode("R002", "机架B", TypeRack)
    shelf1_1 := NewNode("S001_1", "货架1-1", TypeShelf)
    shelf1_2 := NewNode("S001_2", "货架1-2", TypeShelf)
    bin1_1_1 := NewNode("B001_1_1", "存储单元1-1-1", TypeBin)
    bin1_1_2 := NewNode("B001_1_2", "存储单元1-1-2", TypeBin)

    storageArea.AddChild(rack1)
    storageArea.AddChild(rack2)
    rack1.AddChild(shelf1_1)
    rack1.AddChild(shelf1_2)
    shelf1_1.AddChild(bin1_1_1)
    shelf1_1.AddChild(bin1_1_2)

    fmt.Println("深度优先遍历:")
    storageArea.TraverseDFS(func(node *Node) {
        fmt.Printf("ID: %s, Name: %s, Type: %s\n", node.ID, node.Name, node.Type)
    })

    fmt.Println("\n广度优先遍历:")
    storageArea.TraverseBFS(func(node *Node) {
        fmt.Printf("ID: %s, Name: %s, Type: %s\n", node.ID, node.Name, node.Type)
    })

    // 查找节点
    foundBin := storageArea.FindChildByID("B001_1_1")
    if foundBin != nil {
        fmt.Printf("\n找到节点: %s (%s)\n", foundBin.Name, foundBin.Type)
    } else {
        fmt.Println("\n未找到节点 B001_1_1")
    }
}

// 序列化：将Node树编码为字节切片
func EncodeNodeTree(root *Node) ([]byte, error) {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)

    // 临时清除Parent引用以避免循环引用问题
    // 实际操作中，可能需要一个更复杂的遍历来处理或复制树
    // 这里我们直接在遍历时处理
    nodesToProcess := []*Node{root}
    processedNodes := make(map[string]*Node) // 记录已处理节点，避免重复

    for len(nodesToProcess) > 0 {
        n := nodesToProcess[0]
        nodesToProcess = nodesToProcess[1:]

        if _, ok := processedNodes[n.ID]; ok {
            continue // 已处理过
        }
        processedNodes[n.ID] = n

        // 暂时保存原始Parent，编码后再恢复
        originalParent := n.Parent
        n.Parent = nil // 清除Parent引用

        if err := enc.Encode(n); err != nil {
            return nil, fmt.Errorf("failed to encode node %s: %w", n.ID, err)
        }
        n.Parent = originalParent // 恢复Parent引用

        for _, child := range n.Children {
            nodesToProcess = append(nodesToProcess, child)
        }
    }
    return buf.Bytes(), nil
}

// 解码：从字节切片解码为Node树
func DecodeNodeTree(data []byte) (*Node, error) {
    var buf bytes.Buffer
    buf.Write(data)
    dec := gob.NewDecoder(&buf)

    // 假设我们知道根节点的ID或者第一个解码出来的就是根节点
    // 实际应用中，可能需要先解码一个包含根节点ID的元数据
    // 这里我们简化处理，假设第一个解码的Node就是根节点
    var root *Node
    nodesMap := make(map[string]*Node) // 用于重建父子关系

    for {
        var n Node
        err := dec.Decode(&n)
        if err == io.EOF {
            break // 数据读取完毕
        }
        if err != nil {
            return nil, fmt.Errorf("failed to decode node: %w", err)
        }

        // 创建一个新Node实例，并复制解码的数据
        newNode := &Node{
            ID:   n.ID,
            Name: n.Name,
            Type: n.Type,
            mu:   sync.RWMutex{}, // 确保新节点有自己的锁
        }
        // Children需要在后续遍历中设置，因为此时子节点可能还未被解码
        nodesMap[newNode.ID] = newNode

        if root == nil { // 假设第一个解码的节点是根节点
            root = newNode
        }
    }

    // 第二遍遍历，重建Children和Parent引用
    buf.Reset() // 重置buffer以再次读取数据
    buf.Write(data)
    dec = gob.NewDecoder(&buf)

    for {
        var n Node
        err := dec.Decode(&n)
        if err == io.EOF {
            break
        }
        if err != nil {
            return nil, fmt.Errorf("failed to decode node for second pass: %w", err)
        }

        currentNode := nodesMap[n.ID]
        for _, childRef := range n.Children {
            childNode := nodesMap[childRef.ID]
            if childNode != nil {
                currentNode.AddChild(childNode) // 使用AddChild来设置Parent和Children
            } else {
                // 理论上不应该发生，除非数据损坏或逻辑错误
                return nil, fmt.Errorf("child node %s not found for parent %s during reconstruction", childRef.ID, n.ID)
            }
        }
    }

    return root, nil
}

// 示例：使用gob进行持久化和加载
func main_gob() {
    // 构建一个示例树
    storageArea := NewNode("SA001", "主存储区", TypeStorageArea)
    rack1 := NewNode("R001", "机架A", TypeRack)
    shelf1_1 := NewNode("S001_1", "货架1-1", TypeShelf)
    bin1_1_1 := NewNode("B001_1_1", "存储单元1-1-1", TypeBin)

    storageArea.AddChild(rack1)
    rack1.AddChild(shelf1_1)
    shelf1_1.AddChild(bin1_1_1)

    // 注册Node类型，以便gob正确处理
    gob.Register(&Node{})

    // 1. 序列化树
    encodedData, err := EncodeNodeTree(storageArea)
    if err != nil {
        fmt.Printf("序列化失败: %v\n", err)
        return
    }
    fmt.Printf("序列化数据大小: %d bytes\n", len(encodedData))

    // 2. 反序列化树
    decodedRoot, err := DecodeNodeTree(encodedData)
    if err != nil {
        fmt.Printf("反序列化失败: %v\n", err)
        return
    }

    fmt.Println("\n解码后的树（深度优先遍历）:")
    decodedRoot.TraverseDFS(func(node *Node) {
        parentID := "无"
        if node.Parent != nil {
            parentID = node.Parent.ID
        }
        fmt.Printf("ID: %s, Name: %s, Type: %s, ParentID: %s\n", node.ID, node.Name, node.Type, parentID)
    })

    // 验证父子关系是否重建正确
    if decodedRoot.Children[0].Parent.ID == decodedRoot.ID {
        fmt.Println("\n父子关系重建成功!")
    } else {
        fmt.Println("\n父子关系重建失败!")
    }
}