为什么需要依赖注入，我们从不用依赖注入的常规思维写代码；按照经典的db,moudle,server的分层思想，然后将server注册到我们的路由或者其他服务中。

常规思维

1.db层

package db

type DB struct {
    Name string
}

func NewDb() *DB {
    db := &DB{Name: "12"}
    return db
}

• 一般这里是初始化数据库，然后返回数据库实例

---

2.moudle 层

package moudle

import (
    "fmt"
    "go-example/db"
)

type Moudle struct {
    DB *db.DB
}

func (m *Moudle) Query(id string) string {
    str := fmt.Sprintf("select * from %s where id = %s", m.DB.Name, id)
    return str
}

• 一般这里写操作数据库的逻辑

---

3.server 层

package server

import "go-example/moudle"

type Server struct {
    Moudle *moudle.Moudle
}

func (s *Server) Query(id string) string {
    return s.Moudle.Query(id)
}

• 这里对各个moudle 层的数据进行整合和校验

---

4.main

package main

import (
    "fmt"
    "go-example/db"
    "go-example/moudle"
    "go-example/server"
)

type HandlerFunc func(id string) string

var funcs []HandlerFunc = make([]HandlerFunc, 0)

func register(handle HandlerFunc) {
    funcs = append(funcs, handle)
}

func run() {
    for i, f := range funcs {
        fmt.Println(f(fmt.Sprintf("%d", i)))
    }
}

func main() {
    db := db.NewDb()
    m := &moudle.Moudle{DB: db}
    s := &server.Server{Moudle: m}

    register(s.Query)

    run()
}

• 最后我们将写好的服务注册到路由，GRPC等服务中
• 按照常规思维我们得先初始化db,然后使用db初始化moudle ,最后使用moudle 初始化 server ,才能拿到server实例将其注册到对应服务中
• 在我们项目很大，依赖很多是，这种初始化方式会很臃肿

使用依赖注入

go get github.com/google/wire

1. db层 顶部增加代买

// MoudleSet 注入Moudle
var MoudleSet = wire.NewSet(wire.Struct(new(Moudle), "*"))

2.server 层 顶部增加代买

// ServerSet 注入Server
var ServerSet = wire.NewSet(wire.Struct(new(Server), "*"))

3.新增 wirex

// wirex\wire.go
//go:build wireinject
// +build wireinject

package wirex

import (
    "go-example/db"
    "go-example/moudle"
    "go-example/server"

    "github.com/google/wire"
)

func BuildInjector() (*Injector, error) {
    wire.Build(
        db.NewDb,
        moudle.MoudleSet,
        server.ServerSet,
        InjectorSet,
    )
    return new(Injector), nil
}

// wirex\injector.go
package wirex

import (
    "go-example/server"

    "github.com/google/wire"
)

// InjectorSet 注入Injector
var InjectorSet = wire.NewSet(wire.Struct(new(Injector), "*"))

// Injector 注入器(用于初始化完成之后的引用)
type Injector struct {
    Server *server.Server
}

• 运行 wire gen ./wirex 生成 对应 wire_gen.go文件
• wire.go 顶部一定要有

//go:build wireinject
// +build wireinject

修改 main.go

func main() {
    injector, err := wirex.BuildInjector()
    if err != nil {
        panic(err)
    }

    register(injector.Server.Query)

    run()
}