golang设计模式（3）组合模式

灰太狼 2022-06-07 07:44 145阅读 0赞

组合模式，使我们在树形结构问题中，使用者可以忽略简单元素和复杂元素的概念。客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素内部结构解耦。当应用场景出现分级、分层的时候，使用组合模式就会相对合适。  
**定义**(GoF《设计模式》)：将对象组合成树形结构以表示“部分整体”的层次结构。组合模式使得用户对单个对象和使用具有一致性。  
**涉及角色：**  
　　1.Component 是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component  
子部件。  
　　2.Leaf 在组合中表示叶子结点对象，叶子结点没有子结点。  
　　3.Composite 定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作。  
　　  
**适用性**  
　　以下情况下适用Composite模式：  
　　1．你想表示对象的部分-整体层次结构  
　　2．你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。  
**组合模式对应的uml图：**  
![组合模式uml][uml]

**golang实现：**  
笔者这边实际用到组合模式的情景是对web的url做对应的路由处理。url中的目录分级，将url按照‘/’切分后，有些是目录，最后一个是字符串就不是目录。伪代码如下：

package webapi
    
    import (
        "errors"
        "fmt"
        "net/http"
        "strings"
        "sync"
    )
    
    type NodeHandler func(http.ResponseWriter, *http.Request)
    
    type DirComponent interface {
        Add(DirComponent) bool
        Remove(string) bool
        GetChild() ([]DirComponent, bool)
        GetName() string
        Handler(w http.ResponseWriter, req *http.Request)
        IsDir() bool
    }
    
    type Node struct {
        Name        string
        Url         string
        NodeHandler NodeHandler
    }
    
    func NewNode(name string, handler NodeHandler) *Node {
        return &Node{Name: name, NodeHandler: handler}
    }
    
    func (pN *Node) Add(iDirComponent DirComponent) bool {
        return false
    }
    
    func (pN *Node) Remove(name string) bool {
        return false
    }
    
    func (pN *Node) GetChild() (sziDirComponent []DirComponent, b bool) {
        return
    }
    
    func (pN *Node) Handler(w http.ResponseWriter, req *http.Request) {
        pN.NodeHandler(w, req)
    }
    
    func (pN *Node) GetName() string {
        return pN.Name
    }
    
    func (pN *Node) IsDir() bool {
        return false
    }
    
    type Dir struct {
        Name  string
        Sons  []DirComponent
        mutex sync.Mutex
    }
    
    func NewDir(name string) *Dir {
        return &Dir{Name: name}
    }
    
    func (pD *Dir) Add(iDirComponent DirComponent) bool {
        pD.mutex.Lock()
        for _, dirComponent := range pD.Sons {
            if iDirComponent.GetName() == dirComponent.GetName() {
                return false
            }
        }
        pD.Sons = append(pD.Sons, iDirComponent)
        pD.mutex.Unlock()
        return true
    }
    
    func (pD *Dir) Remove(name string) bool {
        pD.mutex.Lock()
        for i, dirComponent := range pD.Sons {
            if name == dirComponent.GetName() {
                pD.Sons = append(pD.Sons[:i], pD.Sons[i+1:]...)
                pD.mutex.Unlock()
                return true
            }
        }
        pD.mutex.Unlock()
        return false
    }
    
    //dir in web must have child
    func (pD *Dir) GetChild() (dirs []DirComponent, b bool) {
        if len(pD.Sons) == 0 {
            return dirs, false
        }
        return pD.Sons, true
    }
    
    func (pD *Dir) GetName() string {
        return pD.Name
    }
    
    func (pD *Dir) IsDir() bool {
        return true
    }
    
    //return error
    func (pD *Dir) Handler(w http.ResponseWriter, req *http.Request) {
        return
    }
    
    func AddDir(url string, node DirComponent, root DirComponent) bool {
        if node == nil || root == nil || node.IsDir() {
            return false
        }
    
        dirs := strings.Split(url, "/")
        dirDeth := len(dirs)
        rootTmp := root
    
        for i, d := range dirs {
            if i == 0 {
                continue
            }
    
            if i == dirDeth-1 {
                sons, ok := rootTmp.GetChild()
                if ok {
                    for _, dir := range sons {
                        if d == dir.GetName() {
                            return false
                        }
                    }
                }
                fmt.Println("bbb")
                rootTmp.Add(node)
                return true
            }
            //获取子节点
            sons, ok := rootTmp.GetChild()
            if !ok {
                newdir := NewDir(d)
                rootTmp.Add(newdir)
                sons, _ = rootTmp.GetChild()
            }
    
            for _, dir := range sons {
                if d == dir.GetName() {
                    rootTmp = dir
                    break
                }
            }
        }
        return true
    }
    
    func DelDir(url string, root DirComponent) bool {
        if root == nil {
            return false
        }
    
        dirs := strings.Split(url, "/")
        dirDeth := len(dirs)
        rootTmp := root
        for i, d := range dirs {
            if i == 0 {
                continue
            }
    
            sons, ok := rootTmp.GetChild()
            if !ok {
                return false
            }
    
            for _, dir := range sons {
                if d == dir.GetName() {
                    if i == dirDeth-1 {
                        fmt.Println("last")
                        return rootTmp.Remove(d)
                    }
                    rootTmp = dir
                    break
                }
            }
    
        }
    
        return false
    }
    
    func UpdateDir(url string, node DirComponent, root DirComponent) bool {
        if DelDir(url, root) {
            return AddDir(url, node, root)
        }
        return false
    }
    
    func FindNode(url string, root DirComponent) (DirComponent, error) {
        if root == nil {
            return nil, errors.New("root is nil")
        }
    
        dirs := strings.Split(url, "/")
        dirDeth := len(dirs)
        rootTmp := root
        for i, d := range dirs {
            if i == 0 {
                continue
            }
            sons, ok := rootTmp.GetChild()
            if !ok {
                return nil, errors.New("dir no exist!")
            }
    
            for _, dir := range sons {
                if d == dir.GetName() {
                    if i == dirDeth-1 {
    
                        return dir, nil
                    }
                    rootTmp = dir
                    break
                }
            }
        }
        return nil, errors.New("no find!")
    }

[uml]: /images/20220607/b5a101f11b4d486395697b437dc3b746.png