Golang 依赖注入经典解决方案uber/fx理论解析

go get go.uber.org/fx@v1

app = fx.New(
   fx.Provide(newZapLogger),
   fx.Provide(newRedisClient),
   fx.Provide(newMeaningOfLifeCacheRedis),
   fx.Provide(newMeaningOfLifeHandler),
)

func NewLogger() *log.Logger {
    logger := log.New(os.Stdout, "" , 0 )
    logger.Print("Executing NewLogger.")
    return logger
}

func NewHandler(logger *log.Logger) (Http.Handler, error) {
    logger.Print("Executing NewHandler.")
    return http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
        logger.Print("Got a request.")
    }), nil
}

// Provide reGISters any number of constructor functions, teaching the
// application how to instantiate various types. The supplied constructor
// function(s) may depend on other types available in the application, must
// return one or more objects, and may return an error. For example:
//
//    // Constructs type *C, depends on *A and *B.
//    func(*A, *B) *C
//
//    // Constructs type *C, depends on *A and *B, and indicates failure by
//    // returning an error.
//    func(*A, *B) (*C, error)
//
//    // Constructs types *B and *C, depends on *A, and can fail.
//    func(*A) (*B, *C, error)
//
// The order in which constructors are provided doesn't matter, and passing
// multiple Provide options appends to the application's collection of
// constructors. Constructors are called only if one or more of their returned
// types are needed, and their results are cached for reuse (so instances of a
// type are effectively singletons within an application). Taken together,
// these properties make it perfectly reasonable to Provide a large number of
// constructors even if only a fraction of them are used.
//
// See the documentation of the In and Out types for advanced features,
// including optional parameters and named instances.
//
// Constructor functions should perfORM as little external interaction as
// possible, and should avoid spawning goroutines. Things like server listen
// loops, background timer loops, and background processing goroutines should
// instead be managed using Lifecycle callbacks.
func Provide(constructors ...interface{}) Option {
    return provideOption{
        Targets: constructors,
        Stack:   fxreflect.CallerStack(1, 0),
    }
}

// Module is a named group of zero or more fx.Options.
// A Module creates a scope in which certain operations are taken
// place. For more information, see [Decorate], [Replace], or [Invoke].
func Module(name string, opts ...Option) Option {
    mo := moduleOption{
        name:    name,
        options: opts,
    }
    return mo
}

/ ProvideLogger to fx  
func ProvideLogger() *zap.SugaredLogger {  
logger, _ := zap.NewProduction()  
slogger := logger.Sugar()  
return slogger  
}  
// Module provided to fx  
var Module = fx.Options(  
fx.Provide(ProvideLogger),  
)

func main() {  
    fx.New(  
        fx.Provide(http.NewServeMux),  
        fx.Invoke(server.New),  
        fx.Invoke(registerHooks),  
        loggerfx.Module,  
    ).Run()  
}

// Lifecycle allows constructors to register callbacks that are executed on
// application start and stop. See the documentation for App for details on Fx
// applications' initialization, startup, and shutdown logic.
type Lifecycle interface {
    Append(Hook)
}
// A Hook is a pair of start and stop callbacks, either of which can be nil.
// If a Hook's OnStart callback isn't executed (because a previous OnStart
// failure short-circuited application startup), its OnStop callback won't be
// executed.
type Hook struct {
    OnStart func(context.Context) error
    OnStop  func(context.Context) error
}

func runhttpserver(lifecycle fx.Lifecycle, molHandler *MeaningOfLifeHandler) {
   lifecycle.Append(fx.Hook{OnStart: func(context.Context) error {
      r := fasthttprouter.New()
      r.Handle(http.MethodGet, "/what-is-the-meaning-of-life", molHandler.Handle)
      return fasthttp.ListenAndServe("localhost:8080", r.Handler)
   }})
}

fx.New(
      fx.Provide(newZapLogger),
      fx.Provide(newRedisClient),
      fx.Provide(newMeaningOfLifeCacheRedis),
      fx.Provide(newMeaningOfLifeHandler),
      fx.Invoke(runHttpServer),
)

// New creates and initializes an App, immediately executing any functions
// registered via Invoke options. See the documentation of the App struct for
// details on the application's initialization, startup, and shutdown logic.
func New(opts ...Option) *App

func main() {
   ctx, cancel := context.WithCancel(context.Background())
   kill := make(chan os.Signal, 1)
   signal.Notify(kill)
   go func() {
      <-kill
      cancel()
   }()
   app := fx.New(
      fx.Provide(newZapLogger),
      fx.Provide(newRedisClient),
      fx.Provide(newMeaningOfLifeCacheRedis),
      fx.Provide(newMeaningOfLifeHandler),
      fx.Invoke(runHttpServer),
   )
   if err := app.Start(ctx);err != nil{
      fmt.Println(err)
   }
}

type ConstructorParam struct {
    fx.In
    Logger  *log.Logger
    Handler http.Handler
}
type Object struct {
    Logger  *log.Logger
    Handler http.Handler
}
func NewObject(p ConstructorParam) Object {
    return Object {
        Logger:  p.Logger,
        Handler: p.Handler,
    }
}

type Result struct {
    fx.Out
    Logger  *log.Logger
    Handler http.Handler
}
func NewResult() Result {
    // logger := xxx
    // handler := xxx
    return Result {
        Logger:  logger,
        Handler: handler,
    }
}

type RedisA *redis.Client
type RedisB *redis.Client

type GatewayParams struct {
  fx.In
  WriteToConn  *sql.DB `name:"rw"`
  ReadFromConn *sql.DB `name:"ro" optional:"true"`
}
func NewCommentGateway(p GatewayParams, log *log.Logger) (*CommentGateway, error) {
  if p.ReadFromConn == nil {
    log.Print("Warning: Using RW connection for reads")
    p.ReadFromConn = p.WriteToConn
  }
  // ...
}
type ConnectionResult struct {
  fx.Out
  ReadWrite *sql.DB `name:"rw"`
  ReadOnly  *sql.DB `name:"ro"`
}
func ConnectToDatabase(...) (ConnectionResult, error) {
  // ...
  return ConnectionResult{ReadWrite: rw, ReadOnly:  ro}, nil
}

func Annotate(t interface{}, anns ...Annotation) interface{} {
    result := annotated{Target: t}
    for _, ann := range anns {
        if err := ann.apply(&result); err != nil {
            return annotationError{
                target: t,
                err:    err,
            }
        }
    }
    return result
}

// Given,
type Doer interface{ ... }
// And three implementations,
type GoodDoer struct{ ... }
func NewGoodDoer() *GoodDoer
type BadDoer struct{ ... }
func NewBadDoer() *BadDoer
type UglyDoer struct{ ... }
func NewUglyDoer() *UglyDoer
fx.Provide(
  fx.Annotate(NewGoodDoer, fx.As(new(Doer)), fx.ResultTags(`name:"good"`)),
  fx.Annotate(NewBadDoer, fx.As(new(Doer)), fx.ResultTags(`name:"bad"`)),
  fx.Annotate(NewUglyDoer, fx.As(new(Doer)), fx.ResultTags(`name:"ugly"`)),
)

fx.Annotate(NewGoodDoer, fx.As(new(Doer))) 

func AsDoer(f any, name string) any {
  return fx.Anntoate(f, fx.As(new(Doer)), fx.ResultTags("name:" + strconv.Quote(name)))
}
fx.Provide(
 AsDoer(NewGoodDoer, "good"),
 AsDoer(NewBadDoer, "bad"),
 AsDoer(NewUglyDoer, "ugly"),
)

func Do(good, bad, ugly Doer) {
  // ...
}
fx.Invoke(
  fx.Annotate(Do, fx.ParamTags(`name:"good"`, `name:"bad"`, `name:"ugly"`)),
)
这样就无需通过 fx.In 和 fx.Out 的封装能力来实现了，非常简洁。
当然，如果我们上面的返回值直接就是 interface，那么久不需要 fx.As 这一步转换了。
go复制代码func NewGateway(ro, rw *db.Conn) *Gateway { ... }
fx.Provide(
  fx.Annotate(
    NewGateway,
    fx.ParamTags(`name:"ro" optional:"true"`, `name:"rw"`),
    fx.ResultTags(`name:"foo"`),
  ),
)

type params struct {
  fx.In
  RO *db.Conn `name:"ro" optional:"true"`
  RW *db.Conn `name:"rw"`
}
type result struct {
  fx.Out
  GW *Gateway `name:"foo"`
}
fx.Provide(func(p params) result {
   return result{GW: NewGateway(p.RO, p.RW)}
})

fx.Provide(
  fx.Annotate(
    NewGateWay,
    fx.ParamTags(`name:"ro" optional:"true"`),
    fx.ParamTags(`name:"rw"), // ERROR: ParamTags was already used above
    fx.ResultTags(`name:"foo"`)
  )
)