手把手教你使用gomonkey落地Go AOP

引言

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在通过将横切关注点（如日志、事务管理等）从业务逻辑中分离出来，从而提高软件的模块化能力，增强应用程序的可维护性和可复用性。

gomonkey 是笔者开源的一款 Go 语言 的打桩框架，目标是让用户在单元测试中低成本的完成打桩，从而将精力聚焦于业务功能的开发。gomonkey 接口友好，功能强大，目前已被很多项目使用，用户遍及世界多个国家。尽管gomonkey主要用于单元测试，但也非常适用于落地Go AOP编程，且不要求用户增加静态代理（Proxy模式）。

应用案例

下面我们将通过实际案例，展示如何利用gomonkey在Go语言中落地AOP编程，重点展示其原理和应用价值。

函数案例

以下是一个简单的例子，展示了如何使用gomonkey对Add和Remove函数进行AOP编程：

package main

import (
    "errors"
    "fmt"

    . "github.com/agiledragon/gomonkey/v2"
)

var (
    ErrActual       = errors.New("actual")
    ErrElemExsit    = errors.New("elem already exist")
    ErrElemNotExsit = errors.New("elem not exist")
)

var slice []int

func Add(elem int) error {
    for _, v := range slice {
        if v == elem {
            fmt.Printf("Slice: Add elem: %v already exist\n", elem)
            return ErrElemExsit
        }
    }
    slice = append(slice, elem)
    fmt.Printf("Slice: Add elem: %v succ\n", elem)
    return nil
}

func Remove(elem int) error {
    found := false
    for i, v := range slice {
        if v == elem {
            if i == len(slice)-1 {
                slice = (slice)[:i]

            } else {
                slice = append((slice)[:i], (slice)[i+1:]...)
            }
            found = true
            break
        }
    }
    if !found {
        fmt.Printf("Slice: Remove elem: %v not exist\n", elem)
        return ErrElemNotExsit
    }
    fmt.Printf("Slice: Remove elem: %v succ\n", elem)
    return nil
}

func main() {
    patches := NewPatches()
    patches.ApplyFunc(Add, func(elem int) error {
        fmt.Println("Go AOP begin for Slice: Add elem: ", elem)
        patches.Origin(func() {
            _ = Add(elem)
        })
        fmt.Println("Go AOP end for Slice: Add elem: ", elem)
        return nil
    })

    patches.ApplyFunc(Remove, func(elem int) error {
        fmt.Println("Go AOP begin for Slice: Remove elem: ", elem)
        patches.Origin(func() {
            _ = Remove(elem)
        })
        fmt.Println("Go AOP end for Slice: Remove elem: ", elem)
        return nil
    })
    _ = Add(1)
    _ = Add(1)
    _ = Remove(1)
    _ = Add(1)
}

运行程序：符合预期

bogon:main zhangxiaolong$ go run -gcflags=all=-l main.go
Go AOP begin for Slice: Add elem:  1
Slice: Add elem: 1 succ
Go AOP end for Slice: Add elem:  1
Go AOP begin for Slice: Add elem:  1
Slice: Add elem: 1 already exist
Go AOP end for Slice: Add elem:  1
Go AOP begin for Slice: Remove elem:  1
Slice: Remove elem: 1 succ
Go AOP end for Slice: Remove elem:  1
Go AOP begin for Slice: Add elem:  1
Slice: Add elem: 1 succ

关键点说明：

• 前置和后置逻辑：通过gomonkey框架，我们在Add和Remove函数执行前后插入了日志打印语句。这是AOP的典型应用，允许我们在不修改原始函数代码的情况下增加额外的功能。
• 动态打桩：使用gomonkey进行的打桩是动态的，这意味着我们可以在运行时插入或修改行为，非常灵活。
• 价值体现：这种方式使得代码更加模块化，业务逻辑与辅助功能（如日志记录）清晰分离，增强了代码的可维护性和可测试性。

方法案例

接下来是对对象方法的AOP应用：

package main

import (
    "errors"
    "fmt"

    . "github.com/agiledragon/gomonkey/v2"
)

var (
    ErrActual       = errors.New("actual")
    ErrElemExsit    = errors.New("elem already exist")
    ErrElemNotExsit = errors.New("elem not exist")
)

type Slice []int

func NewSlice() Slice {
    return make(Slice, 0)
}

func (this *Slice) Add(elem int) error {
    for _, v := range *this {
        if v == elem {
            fmt.Printf("Slice: Add elem: %v already exist\n", elem)
            return ErrElemExsit
        }
    }
    *this = append(*this, elem)
    fmt.Printf("Slice: Add elem: %v succ\n", elem)
    return nil
}

func (this *Slice) Remove(elem int) error {
    found := false
    for i, v := range *this {
        if v == elem {
            if i == len(*this)-1 {
                *this = (*this)[:i]

            } else {
                *this = append((*this)[:i], (*this)[i+1:]...)
            }
            found = true
            break
        }
    }
    if !found {
        fmt.Printf("Slice: Remove elem: %v not exist\n", elem)
        return ErrElemNotExsit
    }
    fmt.Printf("Slice: Remove elem: %v succ\n", elem)
    return nil
}

func main() {
    patches := NewPatches()
    patches.ApplyFunc(NewSlice, func() Slice {
        fmt.Println("Go AOP begin for NewSlice")
        s := make(Slice, 0)
        var slice *Slice
        patches.ApplyMethodFunc(slice, "Add", func(elem int) error {
            fmt.Println("Go AOP begin for Slice: Add elem: ", elem)
            patches.Origin(func() {
                _ = s.Add(elem)
            })
            fmt.Println("Go AOP end for Slice: Add elem: ", elem)
            return nil
        })
        patches.ApplyMethodFunc(slice, "Remove", func(elem int) error {
            fmt.Println("Go AOP begin for Slice: Remove elem: ", elem)
            patches.Origin(func() {
                _ = s.Remove(elem)
            })
            fmt.Println("Go AOP end for Slice: Remove elem: ", elem)
            return nil
        })
        return s
    })

    slice := NewSlice()
    _ = slice.Add(1)
    _ = slice.Add(1)
    _ = slice.Remove(1)
    _ = slice.Add(1)
}

运行程序：符合预期

bogon:main zhangxiaolong$ go run -gcflags=all=-l main.go
Go AOP begin for NewSlice
Go AOP begin for Slice: Add elem:  1
Slice: Add elem: 1 succ
Go AOP end for Slice: Add elem:  1
Go AOP begin for Slice: Add elem:  1
Slice: Add elem: 1 already exist
Go AOP end for Slice: Add elem:  1
Go AOP begin for Slice: Remove elem:  1
Slice: Remove elem: 1 succ
Go AOP end for Slice: Remove elem:  1
Go AOP begin for Slice: Add elem:  1
Slice: Add elem: 1 succ
Go AOP end for Slice: Add elem:  1

关键点说明：

• 封装性和灵活性：通过对Slice类型的方法进行打桩，我们在保持封装性的同时，增加了灵活性，使得可以对成员函数进行类似的前后逻辑增强。
• 适用性：这种方法同样适用于任何需要在方法调用前后执行额外操作的场景，如权限验证和事务处理等。

总结

基于gomonkey可以无侵入且低成本的落地Go AOP编程，从而提升软件的模块化和可扩展性能力，特别适合处理那些需要在运行时动态改变行为的复杂系统。

本来通过案例手把手教你落地了函数和方法的Go AOP编程，我们不仅看到了如何实际应用gomonkey进行AOP编程，也理解了其带来的结构上的优势。这些技术可以广泛应用于日志、安全和事务管理等多个领域，极大地提高软件的可重用性和可维护性。

然而，需要强调的是，目前gomonkey的打桩是全局的，非并发安全，所以在高并发系统中应用gomonkey要非常慎重。我们在单元测试实践中，测试用例都是串行执行的，暂时规避了这个问题。从长远来看，支持并发安全是gomonkey的重要目标，我们计划后续通过协程来隔离桩函数，让用户打桩更美好！