面试题：Go inject实践中如何优化因依赖注入导致的性能损耗

Question

在Go inject实践时，依赖注入可能会因为创建对象、传递参数等操作导致一定的性能损耗。请阐述几种优化这种性能损耗的方法，并结合代码示例说明如何在实际项目中应用这些优化方法。

Answer 1

复用对象

1. 原理：避免每次注入时都重新创建对象，而是复用已有的对象实例，减少对象创建开销。
2. 示例代码：

package main

import (
    "fmt"
)

// 定义一个服务接口
type Service interface {
    DoSomething() string
}

// 具体服务实现
type MyService struct{}

func (m *MyService) DoSomething() string {
    return "Doing something"
}

// 全局变量存储复用的服务实例
var serviceInstance Service

// 获取服务实例的函数，优先复用已有实例
func GetService() Service {
    if serviceInstance == nil {
        serviceInstance = &MyService{}
    }
    return serviceInstance
}

func main() {
    // 多次获取服务实例，实际复用同一个实例
    s1 := GetService()
    s2 := GetService()
    fmt.Println(s1.DoSomething())
    fmt.Println(s2.DoSomething())
}

减少不必要的参数传递

1. 原理：精简注入时传递的参数，只传递真正必要的参数，减少参数传递的开销。
2. 示例代码：

package main

import (
    "fmt"
)

// 定义一个结构体，接收必要的参数
type Processor struct {
    data string
}

// 结构体方法处理数据
func (p *Processor) Process() string {
    return "Processed: " + p.data
}

func main() {
    // 直接传入必要数据创建Processor实例
    data := "example data"
    processor := &Processor{data}
    result := processor.Process()
    fmt.Println(result)
}

使用缓存机制

1. 原理：对于一些计算结果可缓存的对象或操作，在注入时使用缓存，避免重复计算。
2. 示例代码：

package main

import (
    "fmt"
    "sync"
)

// 定义一个需要缓存结果的计算服务接口
type CalculationService interface {
    Calculate(x, y int) int
}

// 具体计算服务实现
type MyCalculationService struct {
    cache map[string]int
    mutex sync.Mutex
}

func (m *MyCalculationService) Calculate(x, y int) int {
    key := fmt.Sprintf("%d-%d", x, y)
    m.mutex.Lock()
    if result, ok := m.cache[key]; ok {
        m.mutex.Unlock()
        return result
    }
    result := x + y
    m.cache[key] = result
    m.mutex.Unlock()
    return result
}

func main() {
    service := &MyCalculationService{cache: make(map[string]int)}
    result1 := service.Calculate(2, 3)
    result2 := service.Calculate(2, 3)
    fmt.Println(result1)
    fmt.Println(result2)
}