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, "" /* prefix */, 0 /* flags */)
    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 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 的封裝能力來實現(xiàn)了，非常簡潔。
當然，如果我們上面的返回值直接就是 interface，那么久不需要 fx.As 這一步轉(zhuǎn)換了。
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"`)
  )
)